TeamTalk 5 .NET DLL  Version 5.11A
TeamTalk.cs
1 /*
2  * Copyright (c) 2005-2018, BearWare.dk
3  *
4  * Contact Information:
5  *
6  * Bjoern D. Rasmussen
7  * Kirketoften 5
8  * DK-8260 Viby J
9  * Denmark
10  * Email: contact@bearware.dk
11  * Phone: +45 20 20 54 59
12  * Web: http://www.bearware.dk
13  *
14  * This source code is part of the TeamTalk SDK owned by
15  * BearWare.dk. Use of this file, or its compiled unit, requires a
16  * TeamTalk SDK License Key issued by BearWare.dk.
17  *
18  * The TeamTalk SDK License Agreement along with its Terms and
19  * Conditions are outlined in the file License.txt included with the
20  * TeamTalk SDK distribution.
21  *
22  */
23 
24 using System;
25 using System.Collections.Generic;
26 using System.Text;
27 using System.Windows.Forms;
28 using System.Drawing;
29 using System.Drawing.Imaging;
30 using System.Threading;
31 using System.Diagnostics;
32 using System.Reflection;
33 using System.Runtime.InteropServices;
34 using c_tt;
35 
36 namespace BearWare
37 {
43  [Flags]
44  public enum StreamType : uint
45  {
47  STREAMTYPE_NONE = 0x00000000,
50  STREAMTYPE_VOICE = 0x00000001,
53  STREAMTYPE_VIDEOCAPTURE = 0x00000002,
56  STREAMTYPE_MEDIAFILE_AUDIO = 0x00000004,
59  STREAMTYPE_MEDIAFILE_VIDEO = 0x00000008,
62  STREAMTYPE_DESKTOP = 0x00000010,
66  STREAMTYPE_DESKTOPINPUT = 0x00000020,
78  STREAMTYPE_CHANNELMSG = 0x00000040,
85 
93  }
106  public enum SoundSystem : uint
107  {
109  SOUNDSYSTEM_NONE = 0,
111  SOUNDSYSTEM_WINMM = 1,
113  SOUNDSYSTEM_DSOUND = 2,
121  SOUNDSYSTEM_ALSA = 3,
134  SOUNDSYSTEM_WASAPI = 5,
155  }
156 
161  [Flags]
162  public enum SoundDeviceFeature : uint
163  {
164  SOUNDDEVICEFEATURE_NONE = 0x0000,
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;
246  public int nMaxInputChannels;
248  public int nMaxOutputChannels;
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;
260  public int nDefaultSampleRate;
267  }
268 
269 
278  public struct SoundDeviceEffects
279  {
295  public bool bEnableAGC;
312  public bool bEnableDenoise;
329  }
330 
333  public struct SoundDeviceConstants
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 
575  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
576  public struct AudioFormat
577  {
581  public int nSampleRate;
583  public int nChannels;
584  }
585 
596  public enum FourCC : uint
597  {
599  FOURCC_NONE = 0,
602  FOURCC_I420 = 100,
605  FOURCC_YUY2 = 101,
608  FOURCC_RGB32 = 102
609  }
610 
617  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
618  public struct VideoFormat
619  {
622  public int nWidth;
625  public int nHeight;
629  public int nFPS_Numerator;
633  public int nFPS_Denominator;
636  }
637 
645  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
646  public struct VideoFrame
647  {
650  public int nWidth;
653  public int nHeight;
659  public int nStreamID;
664  public bool bKeyFrame;
666  public System.IntPtr frameBuffer;
669  public int nFrameBufferSize;
670  }
671 
681  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
682  public struct VideoCaptureDevice
683  {
685  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
686  public string szDeviceID;
688  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
689  public string szDeviceName;
702  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
703  public string szCaptureAPI;
705  [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_VIDEOFORMATS_MAX)]
709  public int nVideoFormatsCount;
710  }
711 
719  public enum BitmapFormat : uint
720  {
722  BMP_NONE = 0,
728  BMP_RGB8_PALETTE = 1,
731  BMP_RGB16_555 = 2,
735  BMP_RGB24 = 3,
739  BMP_RGB32 = 4
740  }
741 
746  public enum DesktopProtocol : uint
747  {
751  }
752 
759  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
760  public struct DesktopWindow
761  {
763  public int nWidth;
765  public int nHeight;
770  public int nBytesPerLine;
777  public int nSessionID;
781  public IntPtr frameBuffer;
784  public int nFrameBufferSize;
785  }
786 
790  public enum DesktopKeyState : uint
791  {
793  DESKTOPKEYSTATE_NONE = 0x00000000,
795  DESKTOPKEYSTATE_DOWN = 0x00000001,
797  DESKTOPKEYSTATE_UP = 0x00000002,
798  }
799 
807  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
808  public struct DesktopInput
809  {
813  public ushort uMousePosX;
817  public ushort uMousePosY;
823  public uint uKeyCode;
828  public DesktopInput(bool set_defaults)
829  {
830  if (set_defaults)
831  {
834  uKeyState = DesktopKeyState.DESKTOPKEYSTATE_NONE;
835  }
836  else
837  {
838  uMousePosX = uMousePosY = 0;
839  uKeyCode = 0;
840  uKeyState = DesktopKeyState.DESKTOPKEYSTATE_NONE;
841  }
842  }
843  }
844 
846  public struct DesktopInputConstants
847  {
855  public const uint DESKTOPINPUT_KEYCODE_IGNORE = 0xFFFFFFFF;
856 
864  public const ushort DESKTOPINPUT_MOUSEPOS_IGNORE = 0xFFFF;
865 
872  public const uint DESKTOPINPUT_KEYCODE_LMOUSEBTN = 0x1000;
873 
880  public const uint DESKTOPINPUT_KEYCODE_RMOUSEBTN = 0x1001;
881 
888  public const uint DESKTOPINPUT_KEYCODE_MMOUSEBTN = 0x1002;
889  }
890 
903  [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
904  public struct SpeexCodec
905  {
908  [FieldOffset(0)]
909  public int nBandmode;
912  [FieldOffset(4)]
913  public int nQuality;
923  [FieldOffset(8)]
924  public int nTxIntervalMSec;
930  [FieldOffset(12)]
931  public bool bStereoPlayback;
932  }
933 
939  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
940  public struct SpeexVBRCodec
941  {
944  public int nBandmode;
947  public int nQuality;
954  public int nBitRate;
958  public int nMaxBitRate;
962  public bool bDTX;
971  public int nTxIntervalMSec;
977  public bool bStereoPlayback;
978  }
979 
981  public struct SpeexConstants
982  {
984  public const int SPEEX_BANDMODE_NARROW = 0;
986  public const int SPEEX_BANDMODE_WIDE = 1;
988  public const int SPEEX_BANDMODE_UWIDE = 2;
990  public const int SPEEX_QUALITY_MIN = 0;
992  public const int SPEEX_QUALITY_MAX = 10;
995  public const int SPEEX_NB_MIN_BITRATE = 2150;
998  public const int SPEEX_NB_MAX_BITRATE = 24600;
1001  public const int SPEEX_WB_MIN_BITRATE = 3950;
1004  public const int SPEEX_WB_MAX_BITRATE = 42200;
1007  public const int SPEEX_UWB_MIN_BITRATE = 4150;
1010  public const int SPEEX_UWB_MAX_BITRATE = 44000;
1013  public const int DEFAULT_SPEEX_BANDMODE = 1;
1016  public const int DEFAULT_SPEEX_QUALITY = 4;
1019  public const int DEFAULT_SPEEX_DELAY = 40;
1022  public const bool DEFAULT_SPEEX_SIMSTEREO = false;
1025  public const int DEFAULT_SPEEX_BITRATE = 0;
1028  public const int DEFAULT_SPEEX_MAXBITRATE = 0;
1031  public const bool DEFAULT_SPEEX_DTX = true;
1032  }
1033 
1036  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1037  public struct OpusCodec
1038  {
1041  public int nSampleRate;
1043  public int nChannels;
1047  public int nApplication;
1050  public int nComplexity;
1053  public bool bFEC;
1056  public bool bDTX;
1060  public int nBitRate;
1062  public bool bVBR;
1065  public bool bVBRConstraint;
1072  public int nTxIntervalMSec;
1076  public int nFrameSizeMSec;
1077  }
1078 
1080  public struct OpusConstants
1081  {
1084  public const int OPUS_APPLICATION_VOIP = 2048;
1087  public const int OPUS_APPLICATION_AUDIO = 2049;
1090  public const int OPUS_MIN_BITRATE = 6000;
1093  public const int OPUS_MAX_BITRATE = 510000;
1094 
1097  public const int OPUS_MIN_FRAMESIZE = 2; /* Actually it's 2.5 */
1100  public const int OPUS_MAX_FRAMESIZE = 60;
1104  public const int OPUS_REALMAX_FRAMESIZE = 120;
1105 
1107  public const int DEFAULT_OPUS_SAMPLERATE = 48000;
1108  public const int DEFAULT_OPUS_CHANNELS = 1;
1109  public const int DEFAULT_OPUS_COMPLEXITY = 10;
1110  public const bool DEFAULT_OPUS_FEC = true;
1111  public const bool DEFAULT_OPUS_DTX = false;
1112  public const bool DEFAULT_OPUS_VBR = true;
1113  public const bool DEFAULT_OPUS_VBRCONSTRAINT = false;
1114  public const int DEFAULT_OPUS_BITRATE = 32000;
1115  public const int DEFAULT_OPUS_DELAY = 20;
1116  }
1117 
1135  [StructLayout(LayoutKind.Explicit)]
1136  public struct SpeexDSP
1137  {
1145  [FieldOffset(0)]
1146  public bool bEnableAGC;
1149  [FieldOffset(4)]
1150  public int nGainLevel;
1154  [FieldOffset(8)]
1155  public int nMaxIncDBSec;
1160  [FieldOffset(12)]
1161  public int nMaxDecDBSec;
1165  [FieldOffset(16)]
1166  public int nMaxGainDB;
1169  [FieldOffset(20)]
1170  public bool bEnableDenoise;
1174  [FieldOffset(24)]
1194  [FieldOffset(28)]
1199  [FieldOffset(32)]
1200  public int nEchoSuppress;
1204  [FieldOffset(36)]
1206 
1207  public SpeexDSP(bool set_defaults)
1208  {
1209  if (set_defaults)
1210  {
1216 
1219 
1223  }
1224  else
1225  {
1226  bEnableAGC = false;
1227  nGainLevel = 0;
1228  nMaxIncDBSec = 0;
1229  nMaxDecDBSec = 0;
1230  nMaxGainDB = 0;
1231 
1232  bEnableDenoise = false;
1233  nMaxNoiseSuppressDB = 0;
1234 
1235  bEnableEchoCancellation = false;
1236  nEchoSuppress = 0;
1237  nEchoSuppressActive = 0;
1238  }
1239  }
1240  }
1241 
1244  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1245  public struct TTAudioPreprocessor
1246  {
1250  public int nGainLevel;
1252  public bool bMuteLeftSpeaker;
1254  public bool bMuteRightSpeaker;
1255  }
1256 
1266  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1268  {
1270  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1271  public struct Preamplifier
1272  {
1275  public bool bEnable;
1277  public float fFixedGainFactor;
1278  }
1280 
1283  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1284  public struct EchoCanceller
1285  {
1291  public bool bEnable;
1292  }
1294 
1297  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1298  public struct NoiseSuppression
1299  {
1301  public bool bEnable;
1304  public int nLevel;
1305  }
1307 
1309  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1310  public struct VoiceDetection
1311  {
1321  public bool bEnable;
1322  }
1324 
1327  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1328  public struct GainController2
1329  {
1332  public bool bEnable;
1335  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1336  public struct FixedDigital
1337  {
1340  public float fGainDB;
1341  }
1343 
1345  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1346  public struct AdaptiveDigital
1347  {
1348  /* @brief Enable saturation protector where saturation
1349  * margin is 2 dB. */
1350  public bool bEnable;
1351  /* Range: 0 <= x <= 100. Default: 20 dB */
1353  /* Range: 0 <= x <= 100. Default: 2 dB */
1355  /* Range: 0 < x < infinite. Default: 3 dB/sec */
1357  /* Range: -infinite < x < 0. Default: -50 */
1359  }
1361  }
1363 
1365  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1366  public struct LevelEstimation
1367  {
1373  public bool bEnable;
1374  }
1376 
1377  public WebRTCAudioPreprocessor(bool set_defaults)
1378  {
1379  if (set_defaults)
1380  {
1383 
1385 
1388 
1390 
1393 
1399 
1401  }
1402  else
1403  {
1404  preamplifier.bEnable = false;
1406 
1407  echocanceller.bEnable = false;
1408 
1409  noisesuppression.bEnable = false;
1411 
1412  voicedetection.bEnable = false;
1413 
1414  gaincontroller2.bEnable = false;
1416 
1422 
1423  levelestimation.bEnable = false;
1424  }
1425  }
1426  }
1427 
1429  public struct WebRTCConstants
1430  {
1431  public const bool DEFAULT_WEBRTC_PREAMPLIFIER_ENABLE = false;
1432  public const float DEFAULT_WEBRTC_PREAMPLIFIER_GAINFACTOR = 1.0f;
1433  public const bool DEFAULT_WEBRTC_VAD_ENABLE = false;
1434  public const bool DEFAULT_WEBRTC_LEVELESTIMATION_ENABLE = false;
1435  public const bool DEFAULT_WEBRTC_GAINCTL_ENABLE = false;
1436  public const float DEFAULT_WEBRTC_GAINDB = 15;
1437  public const bool DEFAULT_WEBRTC_SAT_PROT_ENABLE = false;
1438  public const float DEFAULT_WEBRTC_INIT_SAT_MARGIN_DB = 20;
1439  public const float DEFAULT_WEBRTC_EXTRA_SAT_MARGIN_DB = 2;
1440  public const float DEFAULT_WEBRTC_MAXGAIN_DBSEC = 3;
1441  public const float DEFAULT_WEBRTC_MAX_OUT_NOISE = -50;
1442  public const bool DEFAULT_WEBRTC_NOISESUPPRESS_ENABLE = false;
1444  public const bool DEFAULT_WEBRTC_ECHO_CANCEL_ENABLE = false;
1445  public const float WEBRTC_GAINCONTROLLER2_FIXEDGAIN_MAX = 49.9f;
1446  }
1447 
1451  public enum AudioPreprocessorType : uint
1452  {
1463  };
1464 
1466  [StructLayout(LayoutKind.Explicit)]
1467  public struct AudioPreprocessor
1468  {
1470  [FieldOffset(0)]
1473  [FieldOffset(4)]
1476  [FieldOffset(4)]
1479  [FieldOffset(4)]
1481  }
1482 
1484  public struct SpeexDSPConstants
1485  {
1486  public const bool DEFAULT_AGC_ENABLE = true;
1487  public const int DEFAULT_AGC_GAINLEVEL = 8000;
1488  public const int DEFAULT_AGC_INC_MAXDB = 12;
1489  public const int DEFAULT_AGC_DEC_MAXDB = -40;
1490  public const int DEFAULT_AGC_GAINMAXDB = 30;
1491  public const bool DEFAULT_DENOISE_ENABLE = true;
1492  public const int DEFAULT_DENOISE_SUPPRESS = -30;
1493  public const bool DEFAULT_ECHO_ENABLE = true;
1494  public const int DEFAULT_ECHO_SUPPRESS = -40;
1495  public const int DEFAULT_ECHO_SUPPRESS_ACTIVE = -15;
1496  }
1497 
1502  [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
1503  public struct WebMVP8Codec
1504  {
1506  [FieldOffset(0)]
1507  public int nRcTargetBitrate;
1513  [FieldOffset(0)]
1514  public int rc_target_bitrate;
1522  [FieldOffset(4)]
1523  public uint nEncodeDeadline;
1524  }
1525 
1527  {
1530  public const int WEBM_VPX_DL_REALTIME = 1;
1533  public const int WEBM_VPX_DL_GOOD_QUALITY = 1000000;
1536  public const int WEBM_VPX_DL_BEST_QUALITY = 0;
1537  }
1538 
1543  public enum Codec : uint
1544  {
1546  NO_CODEC = 0,
1549  SPEEX_CODEC = 1,
1552  SPEEX_VBR_CODEC = 2,
1554  OPUS_CODEC = 3,
1556  WEBM_VP8_CODEC = 128
1557  }
1558 
1562  [StructLayout(LayoutKind.Explicit)]
1563  public struct AudioCodec
1564  {
1567  [FieldOffset(0)]
1568  public Codec nCodec;
1571  [FieldOffset(4)]
1575  [FieldOffset(4)]
1579  [FieldOffset(4)]
1580  public OpusCodec opus;
1581  }
1582 
1596  [StructLayout(LayoutKind.Explicit)]
1597  public struct AudioConfig
1598  {
1600  [FieldOffset(0)]
1601  public bool bEnableAGC;
1603  [FieldOffset(4)]
1604  public int nGainLevel;
1605 
1606  public AudioConfig(bool set_defaults)
1607  {
1608  if (set_defaults)
1609  {
1610  bEnableAGC = true;
1612  }
1613  else
1614  {
1615  bEnableAGC = false;
1616  nGainLevel = 0;
1617  }
1618  }
1619  }
1620 
1621  public struct AudioConfigConstants
1622  {
1623  public const int DEFAULT_AGC_GAINLEVEL = 8000;
1624  public const int DEFAULT_AGC_INC_MAXDB = 12;
1625  }
1626 
1628  [StructLayout(LayoutKind.Explicit)]
1629  public struct VideoCodec
1630  {
1634  [FieldOffset(0)]
1635  public Codec nCodec;
1636  [FieldOffset(4)]
1638  }
1649  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1650  public struct MediaFileInfo
1651  {
1656  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1657  public string szFileName;
1663  public uint uDurationMSec;
1665  public uint uElapsedMSec;
1666  }
1675  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1676  public struct MediaFilePlayback
1677  {
1682  public uint uOffsetMSec;
1684  public bool bPaused;
1687  }
1688 
1691  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1692  public struct AudioInputProgress
1693  {
1695  public int nStreamID;
1698  public uint uQueueMSec;
1701  public uint uElapsedMSec;
1702  }
1703 
1720  [Flags]
1721  public enum UserRight : uint
1722  {
1725  USERRIGHT_NONE = 0x00000000,
1728  USERRIGHT_MULTI_LOGIN = 0x00000001,
1730  USERRIGHT_VIEW_ALL_USERS = 0x00000002,
1738  USERRIGHT_MODIFY_CHANNELS = 0x00000008,
1741  USERRIGHT_TEXTMESSAGE_BROADCAST = 0x00000010,
1743  USERRIGHT_KICK_USERS = 0x00000020,
1746  USERRIGHT_BAN_USERS = 0x00000040,
1749  USERRIGHT_MOVE_USERS = 0x00000080,
1752  USERRIGHT_OPERATOR_ENABLE = 0x00000100,
1754  USERRIGHT_UPLOAD_FILES = 0x00000200,
1757  USERRIGHT_DOWNLOAD_FILES = 0x00000400,
1760  USERRIGHT_UPDATE_SERVERPROPERTIES = 0x00000800,
1763  USERRIGHT_TRANSMIT_VOICE = 0x00001000,
1766  USERRIGHT_TRANSMIT_VIDEOCAPTURE = 0x00002000,
1769  USERRIGHT_TRANSMIT_DESKTOP = 0x00004000,
1772  USERRIGHT_TRANSMIT_DESKTOPINPUT = 0x00008000,
1788  USERRIGHT_LOCKED_NICKNAME = 0x00040000,
1791  USERRIGHT_LOCKED_STATUS = 0x00080000,
1794  USERRIGHT_RECORD_VOICE = 0x00100000,
1796  USERRIGHT_VIEW_HIDDEN_CHANNELS = 0x00200000,
1799  }
1800 
1807  [Flags]
1808  public enum ServerLogEvent : uint
1809  {
1811  SERVERLOGEVENT_NONE = 0x00000000,
1813  SERVERLOGEVENT_USER_CONNECTED = 0x00000001,
1815  SERVERLOGEVENT_USER_DISCONNECTED = 0x00000002,
1817  SERVERLOGEVENT_USER_LOGGEDIN = 0x00000004,
1819  SERVERLOGEVENT_USER_LOGGEDOUT = 0x00000008,
1821  SERVERLOGEVENT_USER_LOGINFAILED = 0x00000010,
1823  SERVERLOGEVENT_USER_TIMEDOUT = 0x00000020,
1825  SERVERLOGEVENT_USER_KICKED = 0x00000040,
1827  SERVERLOGEVENT_USER_BANNED = 0x00000080,
1829  SERVERLOGEVENT_USER_UNBANNED = 0x00000100,
1831  SERVERLOGEVENT_USER_UPDATED = 0x00000200,
1833  SERVERLOGEVENT_USER_JOINEDCHANNEL = 0x00000400,
1835  SERVERLOGEVENT_USER_LEFTCHANNEL = 0x00000800,
1837  SERVERLOGEVENT_USER_MOVED = 0x00001000,
1847  SERVERLOGEVENT_CHANNEL_CREATED = 0x00020000,
1849  SERVERLOGEVENT_CHANNEL_UPDATED = 0x00040000,
1851  SERVERLOGEVENT_CHANNEL_REMOVED = 0x00080000,
1853  SERVERLOGEVENT_FILE_UPLOADED = 0x00100000,
1855  SERVERLOGEVENT_FILE_DOWNLOADED = 0x00200000,
1857  SERVERLOGEVENT_FILE_DELETED = 0x00400000,
1859  SERVERLOGEVENT_SERVER_UPDATED = 0x00800000,
1861  SERVERLOGEVENT_SERVER_SAVECONFIG = 0x01000000,
1862  }
1863 
1875  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1876  public struct ServerProperties
1877  {
1879  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1880  public string szServerName;
1883  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1884  public string szMOTD;
1893  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1894  public string szMOTDRaw;
1897  public int nMaxUsers;
1900  public int nMaxLoginAttempts;
1926  public bool bAutoSave;
1928  public int nTcpPort;
1930  public int nUdpPort;
1933  public int nUserTimeout;
1935  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1936  public string szServerVersion;
1938  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1948  public int nLoginDelayMSec;
1952  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1953  public string szAccessToken;
1960  }
1961 
1969  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1970  public struct ServerStatistics
1971  {
1974  public long nTotalBytesTX;
1977  public long nTotalBytesRX;
1980  public long nVoiceBytesTX;
1983  public long nVoiceBytesRX;
1992  public long nMediaFileBytesTX;
1995  public long nMediaFileBytesRX;
1998  public long nDesktopBytesTX;
2001  public long nDesktopBytesRX;
2003  public int nUsersServed;
2005  public int nUsersPeak;
2008  public long nFilesTx;
2011  public long nFilesRx;
2013  public long nUptimeMSec;
2014  }
2015 
2021  [Flags]
2022  public enum BanType : uint
2023  {
2025  BANTYPE_NONE = 0x00,
2029  BANTYPE_CHANNEL = 0x01,
2031  BANTYPE_IPADDR = 0x02,
2033  BANTYPE_USERNAME = 0x04
2034  };
2035 
2040  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2041  public struct BannedUser
2042  {
2044  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2045  public string szIPAddress;
2047  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2048  public string szChannelPath;
2050  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2051  public string szBanTime;
2053  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2054  public string szNickname;
2056  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2057  public string szUsername;
2060  }
2061 
2065  [Flags]
2066  public enum UserType : uint
2067  {
2070  USERTYPE_NONE = 0x0,
2072  USERTYPE_DEFAULT = 0x01,
2074  USERTYPE_ADMIN = 0x02
2075  }
2076 
2085  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2086  public struct AbusePrevention
2087  {
2097  public int nCommandsLimit;
2100  }
2101 
2110  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2111  public struct UserAccount
2112  {
2114  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2115  public string szUsername;
2117  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2118  public string szPassword;
2128  public int nUserData;
2130  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2131  public string szNote;
2136  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2137  public string szInitChannel;
2141  [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_CHANNELS_OPERATOR_MAX)]
2142  public int[] autoOperatorChannels;
2154  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2155  public string szLastModified;
2156  }
2180  [Flags]
2181  public enum Subscription : uint
2182  {
2184  SUBSCRIBE_NONE = 0x00000000,
2187  SUBSCRIBE_USER_MSG = 0x00000001,
2190  SUBSCRIBE_CHANNEL_MSG = 0x00000002,
2193  SUBSCRIBE_BROADCAST_MSG = 0x00000004,
2196  SUBSCRIBE_CUSTOM_MSG = 0x00000008,
2198  SUBSCRIBE_VOICE = 0x00000010,
2200  SUBSCRIBE_VIDEOCAPTURE = 0x00000020,
2202  SUBSCRIBE_DESKTOP = 0x00000040,
2206  SUBSCRIBE_DESKTOPINPUT = 0x00000080,
2209  SUBSCRIBE_MEDIAFILE = 0x00000100,
2212  SUBSCRIBE_INTERCEPT_USER_MSG = 0x00010000,
2215  SUBSCRIBE_INTERCEPT_CHANNEL_MSG = 0x00020000,
2216  /* unused SUBSCRIBE_INTERCEPT_BROADCAST_MSG = 0x00040000 */
2219  SUBSCRIBE_INTERCEPT_CUSTOM_MSG = 0x00080000,
2224  SUBSCRIBE_INTERCEPT_VOICE = 0x00100000,
2229  SUBSCRIBE_INTERCEPT_VIDEOCAPTURE = 0x00200000,
2234  SUBSCRIBE_INTERCEPT_DESKTOP = 0x00400000,
2235  /* unused SUBSCRIBE_INTERCEPT_DESKTOPINPUT = 0x00800000, */
2240  SUBSCRIBE_INTERCEPT_MEDIAFILE = 0x01000000,
2241  }
2242 
2246  [Flags]
2247  public enum UserState : uint
2248  {
2250  USERSTATE_NONE = 0x0000000,
2254  USERSTATE_VOICE = 0x00000001,
2256  USERSTATE_MUTE_VOICE = 0x00000002,
2259  USERSTATE_MUTE_MEDIAFILE = 0x00000004,
2264  USERSTATE_DESKTOP = 0x00000008,
2269  USERSTATE_VIDEOCAPTURE = 0x00000010,
2275  USERSTATE_MEDIAFILE_AUDIO = 0x00000020,
2279  USERSTATE_MEDIAFILE_VIDEO = 0x00000040,
2285  }
2286 
2291  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2292  public struct User
2293  {
2297  public int nUserID;
2302  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2303  public string szUsername;
2308  public int nUserData;
2314  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2315  public string szIPAddress;
2321  public uint uVersion;
2327  public int nChannelID;
2344  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2345  public string szNickname;
2350  public int nStatusMode;
2355  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2356  public string szStatusMsg;
2362  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2363  public string szMediaStorageDir;
2369  public int nVolumeVoice;
2375  public int nVolumeMediaFile;
2388  [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
2389  public float[] soundPositionVoice;
2394  [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
2395  public float[] soundPositionMediaFile;
2400  [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
2401  public bool[] stereoPlaybackVoice;
2406  [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
2411  public int nBufferMSecVoice;
2423  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2424  public string szClientName;
2425  }
2426 
2431  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2432  public struct UserStatistics
2433  {
2435  public long nVoicePacketsRecv;
2437  public long nVoicePacketsLost;
2464  }
2465 
2474  public enum TextMsgType : uint
2475  {
2478  MSGTYPE_USER = 1,
2483  MSGTYPE_CHANNEL = 2,
2486  MSGTYPE_BROADCAST = 3,
2489  MSGTYPE_CUSTOM = 4
2490  }
2491 
2499  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2500  public struct TextMessage
2501  {
2505  public int nFromUserID;
2507  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2508  public string szFromUsername;
2510  public int nToUserID;
2513  public int nChannelID;
2516  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2517  public string szMessage;
2520  public bool bMore;
2521  }
2529  [Flags]
2530  public enum ChannelType : uint
2531  {
2534  CHANNEL_DEFAULT = 0x0000,
2537  CHANNEL_PERMANENT = 0x0001,
2539  CHANNEL_SOLO_TRANSMIT = 0x0002,
2550  CHANNEL_CLASSROOM = 0x0004,
2555  CHANNEL_OPERATOR_RECVONLY = 0x0008,
2558  CHANNEL_NO_VOICEACTIVATION = 0x0010,
2560  CHANNEL_NO_RECORDING = 0x0020,
2563  CHANNEL_HIDDEN = 0x0040,
2564  }
2565 
2577  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2578  public struct Channel
2579  {
2582  public int nParentID;
2585  public int nChannelID;
2587  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2588  public string szName;
2590  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2591  public string szTopic;
2595  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2596  public string szPassword;
2599  public bool bPassword;
2605  public int nUserData;
2607  public long nDiskQuota;
2610  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2611  public string szOpPassword;
2613  public int nMaxUsers;
2674  [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_TRANSMITUSERS_MAX * 2)]
2675  public int[] transmitUsers;
2680  [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_TRANSMITQUEUE_MAX)]
2681  public int[] transmitUsersQueue;
2682 
2691 
2694  public void AddTransmitUser(int nUserID, StreamType uStreamType)
2695  {
2696  int i;
2697  for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
2698  {
2699  if (transmitUsers[i * 2] == 0 || transmitUsers[i * 2] == nUserID)
2700  break;
2701  }
2703  {
2704  transmitUsers[i * 2] = nUserID;
2705  transmitUsers[i * 2 + 1] |= (int)uStreamType;
2706  }
2707  }
2711  {
2712  int i;
2713  for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
2714  {
2715  if (transmitUsers[i * 2] == nUserID)
2716  return (StreamType)transmitUsers[i * 2 + 1];
2717  }
2718  return StreamType.STREAMTYPE_NONE;
2719  }
2722  {
2723  int i;
2724  for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
2725  {
2726  if (transmitUsers[i * 2] == 0)
2727  break;
2728  }
2729  return i;
2730  }
2732  public void RemoveTransmitUser(int nUserID, StreamType uStreamType)
2733  {
2734  int i;
2735  for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
2736  {
2737  if (transmitUsers[i * 2] == nUserID)
2738  break;
2739  }
2741  {
2742  transmitUsers[i * 2] = nUserID;
2743  transmitUsers[i * 2 + 1] &= (int)~uStreamType;
2744 
2745  if (transmitUsers[i * 2 + 1] == (int)StreamType.STREAMTYPE_NONE)
2746  {
2747  for (; i < TeamTalkBase.TT_TRANSMITUSERS_MAX - 1; i++)
2748  {
2749  transmitUsers[i * 2] = transmitUsers[(i + 1) * 2 + 1];
2750  transmitUsers[i * 2 + 1] = transmitUsers[(i + 1) * 2 + 1];
2751  }
2752  }
2753  }
2754  }
2755  }
2756 
2759  public enum FileTransferStatus : uint
2760  {
2762  FILETRANSFER_CLOSED = 0,
2764  FILETRANSFER_ERROR = 1,
2766  FILETRANSFER_ACTIVE = 2,
2769  }
2770 
2774  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2775  public struct FileTransfer
2776  {
2780  public int nTransferID;
2782  public int nChannelID;
2784  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2785  public string szLocalFilePath;
2787  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2788  public string szRemoteFileName;
2790  public long nFileSize;
2792  public long nTransferred;
2794  public bool bInbound;
2795  }
2796 
2800  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2801  public struct RemoteFile
2802  {
2804  public int nChannelID;
2806  public int nFileID;
2808  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2809  public string szFileName;
2811  public long nFileSize;
2813  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2814  public string szUsername;
2817  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2818  public string szUploadTime;
2819  }
2830  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2831  public struct EncryptionContext
2832  {
2838  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2839  public string szCertificateFile;
2841  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2842  public string szPrivateKeyFile;
2847  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2848  public string szCAFile;
2851  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2852  public string szCADir;
2859  public bool bVerifyPeer;
2870  public bool bVerifyClientOnce;
2878  public int nVerifyDepth;
2879  }
2880 
2888  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2889  public struct ClientKeepAlive
2890  {
2933  }
2934 
2939  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2940  public struct ClientStatistics
2941  {
2943  public long nUdpBytesSent;
2945  public long nUdpBytesRecv;
2947  public long nVoiceBytesSent;
2949  public long nVoiceBytesRecv;
2963  public long nDesktopBytesSent;
2965  public long nDesktopBytesRecv;
2969  public int nUdpPingTimeMs;
2973  public int nTcpPingTimeMs;
2992  }
2993 
2999  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
3000  public struct JitterConfig
3001  {
3003  public int nFixedDelayMSec;
3005  public bool bUseAdativeDejitter;
3016  }
3017 
3018 
3028  public enum ClientError : uint
3029  {
3031  CMDERR_SUCCESS = 0,
3032  SUCCESS = 0,
3033 
3034  /* COMMAND ERRORS 1000-1999 ARE DUE TO INVALID OR UNSUPPORTED
3035  * COMMANDS */
3036 
3038  CMDERR_SYNTAX_ERROR = 1000,
3043  CMDERR_UNKNOWN_COMMAND = 1001,
3046  CMDERR_MISSING_PARAMETER = 1002,
3057  CMDERR_INVALID_USERNAME = 1005,
3058 
3059  /* COMMAND ERRORS 2000-2999 ARE DUE TO INSUFFICIENT RIGHTS */
3060 
3077  CMDERR_INVALID_ACCOUNT = 2002,
3094  CMDERR_SERVER_BANNED = 2005,
3126  CMDERR_NOT_AUTHORIZED = 2006,
3134 
3141 
3148 
3155 
3159 
3164  CMDERR_COMMAND_FLOOD = 2014,
3165 
3171  CMDERR_CHANNEL_BANNED = 2015,
3172 
3173  /* COMMAND ERRORS 3000-3999 ARE DUE TO INVALID STATE OF CLIENT INSTANCE */
3174 
3180  CMDERR_NOT_LOGGEDIN = 3000,
3181 
3185  CMDERR_ALREADY_LOGGEDIN = 3001,
3189  CMDERR_NOT_IN_CHANNEL = 3002,
3216  CMDERR_CHANNEL_NOT_FOUND = 3005,
3227  CMDERR_USER_NOT_FOUND = 3006,
3232  CMDERR_BAN_NOT_FOUND = 3007,
3242  CMDERR_OPENFILE_FAILED = 3009,
3247  CMDERR_ACCOUNT_NOT_FOUND = 3010,
3252  CMDERR_FILE_NOT_FOUND = 3011,
3263 
3267  CMDERR_CHANNEL_HAS_USERS = 3015,
3268 
3273 
3279 
3280  /* ERRORS 10000-10999 ARE NOT COMMAND ERRORS BUT INSTEAD
3281  * ERRORS IN THE CLIENT INSTANCE. */
3282 
3287  INTERR_SNDINPUT_FAILURE = 10000,
3292  INTERR_SNDOUTPUT_FAILURE = 10001,
3321  INTERR_SNDEFFECT_FAILURE = 10005,
3322  }
3323 
3324  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
3325  public struct ClientErrorMsg
3326  {
3328  public int nErrorNo;
3330  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
3331  public string szErrorMsg;
3332  }
3333 
3343  public enum ClientEvent : uint
3344  {
3345  CLIENTEVENT_NONE = 0,
3897  }
3898 
3899 
3900  /* List of structures used internally by TeamTalkBase. */
3901  public enum TTType : uint
3902  {
3903  __NONE = 0,
3904  __AUDIOCODEC = 1,
3905  __BANNEDUSER = 2,
3906  __VIDEOFORMAT = 3,
3907  __OPUSCODEC = 4,
3908  __CHANNEL = 5,
3909  __CLIENTSTATISTICS = 6,
3910  __REMOTEFILE = 7,
3911  __FILETRANSFER = 8,
3912  __MEDIAFILESTATUS = 9,
3913  __SERVERPROPERTIES = 10,
3914  __SERVERSTATISTICS = 11,
3915  __SOUNDDEVICE = 12,
3916  __SPEEXCODEC = 13,
3917  __TEXTMESSAGE = 14,
3918  __WEBMVP8CODEC = 15,
3919  __TTMESSAGE = 16,
3920  __USER = 17,
3921  __USERACCOUNT = 18,
3922  __USERSTATISTICS = 19,
3923  __VIDEOCAPTUREDEVICE = 20,
3924  __VIDEOCODEC = 21,
3925  __AUDIOCONFIG = 22,
3926  __SPEEXVBRCODEC = 23,
3927  __VIDEOFRAME = 24,
3928  __AUDIOBLOCK = 25,
3929  __AUDIOFORMAT = 26,
3930  __MEDIAFILEINFO = 27,
3931  __CLIENTERRORMSG = 28,
3932  __TTBOOL = 29,
3933  __INT32 = 30,
3934  __DESKTOPINPUT = 31,
3935  __SPEEXDSP = 32,
3936  __STREAMTYPE = 33,
3938  __AUDIOPREPROCESSOR = 35,
3939  __TTAUDIOPREPROCESSOR = 36,
3940  __MEDIAFILEPLAYBACK = 37,
3941  __CLIENTKEEPALIVE = 38,
3942  __UINT32 = 39,
3943  __AUDIOINPUTPROGRESS = 40,
3944  __JITTERCONFIG = 41,
3946  __ENCRYPTIONCONTEXT = 43,
3947  }
3948 
3959  [StructLayout(LayoutKind.Sequential)]
3960  public struct TTMessage
3961  {
3965  public int nSource;
3967  public TTType ttType;
3969  public uint uReserved;
3970  [MarshalAs(UnmanagedType.ByValArray, SizeConst = TTDLL.SIZEOF_TTMESSAGE_DATA)]
3971  public byte[] data;
3972  //UnionData data;
3973 
3974  public object DataToObject()
3975  {
3976  switch (ttType)
3977  {
3978  case TTType.__CHANNEL:
3979  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(Channel));
3980  case TTType.__CLIENTERRORMSG:
3981  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(ClientErrorMsg));
3982  case TTType.__DESKTOPINPUT:
3983  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(DesktopInput));
3984  case TTType.__FILETRANSFER:
3985  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(FileTransfer));
3986  case TTType.__MEDIAFILEINFO:
3987  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(MediaFileInfo));
3988  case TTType.__REMOTEFILE:
3989  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(RemoteFile));
3990  case TTType.__SERVERPROPERTIES:
3991  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(ServerProperties));
3992  case TTType.__SERVERSTATISTICS:
3993  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(ServerStatistics));
3994  case TTType.__TEXTMESSAGE:
3995  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(TextMessage));
3996  case TTType.__USER:
3997  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(User));
3998  case TTType.__USERACCOUNT:
3999  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(UserAccount));
4000  case TTType.__BANNEDUSER :
4001  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(BannedUser));
4002  case TTType.__TTBOOL:
4003  return Marshal.ReadInt32(TTDLL.TT_DBG_GETDATAPTR(ref this)) != 0;
4004  case TTType.__INT32:
4005  return Marshal.ReadInt32(TTDLL.TT_DBG_GETDATAPTR(ref this));
4006  case TTType.__STREAMTYPE :
4007  return (StreamType)Marshal.ReadInt32(TTDLL.TT_DBG_GETDATAPTR(ref this));
4008  case TTType.__AUDIOINPUTPROGRESS :
4009  return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(AudioInputProgress));
4010  default:
4011  return null;
4012  }
4013  }
4014  }
4015 
4016  [StructLayout(LayoutKind.Explicit, Size = 5224)]
4017  struct UnionData
4018  {
4019  [FieldOffset(0)]
4021  [FieldOffset(0)]
4023  [FieldOffset(0)]
4025  [FieldOffset(0)]
4027  [FieldOffset(0)]
4029  [FieldOffset(0)]
4031  [FieldOffset(0)]
4033  [FieldOffset(0)]
4035  [FieldOffset(0)]
4036  public User user;
4037  [FieldOffset(0)]
4039  [FieldOffset(0)]
4040  public bool bActive;
4041  [FieldOffset(0)]
4042  public int nBytesRemain;
4043  [FieldOffset(0)]
4044  public int nStreamID;
4045  [FieldOffset(0)]
4046  public int nPayloadSize;
4047  }
4048 
4066  [Flags]
4067  public enum ClientFlag : uint
4068  {
4071  CLIENT_CLOSED = 0x00000000,
4075  CLIENT_SNDINPUT_READY = 0x00000001,
4079  CLIENT_SNDOUTPUT_READY = 0x00000002,
4085  CLIENT_SNDINOUTPUT_DUPLEX = 0x00000004,
4092  CLIENT_SNDINPUT_VOICEACTIVATED = 0x00000008,
4099  CLIENT_SNDINPUT_VOICEACTIVE = 0x00000010,
4102  CLIENT_SNDOUTPUT_MUTE = 0x00000020,
4108  CLIENT_SNDOUTPUT_AUTO3DPOSITION = 0x00000040,
4112  CLIENT_VIDEOCAPTURE_READY = 0x00000080,
4115  CLIENT_TX_VOICE = 0x00000100,
4118  CLIENT_TX_VIDEOCAPTURE = 0x00000200,
4124  CLIENT_TX_DESKTOP = 0x00000400,
4129  CLIENT_DESKTOP_ACTIVE = 0x00000800,
4133  CLIENT_MUX_AUDIOFILE = 0x00001000,
4136  CLIENT_CONNECTING = 0x00002000,
4141  CLIENT_CONNECTED = 0x00004000,
4148  CLIENT_AUTHORIZED = 0x00008000,
4153  CLIENT_STREAM_AUDIO = 0x00010000,
4158  CLIENT_STREAM_VIDEO = 0x00020000
4159  }
4160 
4168  public abstract class TeamTalkBase : IDisposable
4169  {
4178  public const int TT_STRLEN = 512;
4179 
4181  public const int TT_USERID_MAX = 0xFFF;
4182 
4185  public const int TT_CHANNELID_MAX = 0xFFF;
4186 
4190  public const int TT_VIDEOFORMATS_MAX = 1024;
4191 
4197  public const int TT_TRANSMITUSERS_MAX = 128;
4198 
4206  public const int TT_CLASSROOM_FREEFORALL = 0xFFF;
4207 
4210  public const int TT_CLASSROOM_USERID_INDEX = 0;
4211 
4214  public const int TT_CLASSROOM_STREAMTYPE_INDEX = 1;
4215 
4218  public const int TT_TRANSMITUSERS_FREEFORALL = 0xFFF;
4219 
4222  public const int TT_TRANSMITUSERS_USERID_INDEX = 0;
4223 
4227 
4241  public const int TT_LOCAL_USERID = 0;
4242 
4250  public const int TT_LOCAL_TX_USERID = 0x1002;
4251 
4259  public const int TT_MUXED_USERID = 0x1001; /* TT_USERID_MAX + 2 */
4260 
4265  public const int TT_CHANNELS_OPERATOR_MAX = 16;
4266 
4270  public const int TT_TRANSMITQUEUE_MAX = 16;
4271 
4274  public const int TT_SAMPLERATES_MAX = 16;
4275 
4280  public const int TT_DESKTOPINPUT_MAX = 16;
4281 
4290  public const uint TT_MEDIAPLAYBACK_OFFSET_IGNORE = 0xFFFFFFFF;
4291 
4292 
4294  public static string GetVersion() { return Marshal.PtrToStringAuto(TTDLL.TT_GetVersion()); }
4295 
4306  protected TeamTalkBase(bool poll_based)
4307  {
4308  Assembly assembly = Assembly.GetExecutingAssembly();
4309  AssemblyName name = assembly.GetName();
4310  Version dllversion = new Version(Marshal.PtrToStringUni((c_tt.TTDLL.TT_GetVersion())));
4311  if (!name.Version.Equals(dllversion))
4312  {
4313  string errmsg = String.Format("Invalid {2} version loaded. {2} is version {0} and {3} is version {1}",
4314  dllversion.ToString(), name.Version.ToString(), c_tt.TTDLL.dllname, c_tt.TTDLL.mgtdllname);
4315 
4316  // throw new Exception(errmsg);
4317 
4318  System.Diagnostics.Debug.WriteLine(errmsg);
4319  }
4320 
4321  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOCODEC) == Marshal.SizeOf(new AudioCodec()));
4322  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__BANNEDUSER) == Marshal.SizeOf(new BannedUser()));
4323  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOFORMAT) == Marshal.SizeOf(new VideoFormat()));
4324  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__OPUSCODEC) == Marshal.SizeOf(new OpusCodec()));
4325  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CHANNEL) == Marshal.SizeOf(new Channel()));
4326  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CLIENTSTATISTICS) == Marshal.SizeOf(new ClientStatistics()));
4327  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__REMOTEFILE) == Marshal.SizeOf(new RemoteFile()));
4328  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__FILETRANSFER) == Marshal.SizeOf(new FileTransfer()));
4329  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__MEDIAFILESTATUS) == Marshal.SizeOf(Enum.GetUnderlyingType(typeof(MediaFileStatus))));
4330  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SERVERPROPERTIES) == Marshal.SizeOf(new ServerProperties()));
4331  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SERVERSTATISTICS) == Marshal.SizeOf(new ServerStatistics()));
4332  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SOUNDDEVICE) == Marshal.SizeOf(new SoundDevice()));
4333  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SPEEXCODEC) == Marshal.SizeOf(new SpeexCodec()));
4334  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__TEXTMESSAGE) == Marshal.SizeOf(new TextMessage()));
4335  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__WEBMVP8CODEC) == Marshal.SizeOf(new WebMVP8Codec()));
4336  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__TTMESSAGE) == Marshal.SizeOf(new TTMessage()));
4337  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__USER) == Marshal.SizeOf(new User()));
4338  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__USERACCOUNT) == Marshal.SizeOf(new UserAccount()));
4339  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__USERSTATISTICS) == Marshal.SizeOf(new UserStatistics()));
4340  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOCAPTUREDEVICE) == Marshal.SizeOf(new VideoCaptureDevice()));
4341  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOCODEC) == Marshal.SizeOf(new VideoCodec()));
4342  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOCONFIG) == Marshal.SizeOf(new AudioConfig()));
4343  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SPEEXVBRCODEC) == Marshal.SizeOf(new SpeexVBRCodec()));
4344  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOFRAME) == Marshal.SizeOf(new VideoFrame()));
4345  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOBLOCK) == Marshal.SizeOf(new AudioBlock()));
4346  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOFORMAT) == Marshal.SizeOf(new AudioFormat()));
4347  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__MEDIAFILEINFO) == Marshal.SizeOf(new MediaFileInfo()));
4348  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CLIENTERRORMSG) == Marshal.SizeOf(new ClientErrorMsg()));
4349  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__DESKTOPINPUT) == Marshal.SizeOf(new DesktopInput()));
4350  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SPEEXDSP) == Marshal.SizeOf(new SpeexDSP()));
4351  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__STREAMTYPE) == Marshal.SizeOf(Enum.GetUnderlyingType(typeof(StreamType))));
4352  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOPREPROCESSORTYPE) == Marshal.SizeOf(Enum.GetUnderlyingType(typeof(AudioPreprocessorType))));
4353  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__WEBRTCAUDIOPREPROCESSOR) == Marshal.SizeOf(new WebRTCAudioPreprocessor()));
4354  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__TTAUDIOPREPROCESSOR) == Marshal.SizeOf(new TTAudioPreprocessor()));
4355  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOPREPROCESSOR) == Marshal.SizeOf(new AudioPreprocessor()));
4356  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__MEDIAFILEPLAYBACK) == Marshal.SizeOf(new MediaFilePlayback()));
4357  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CLIENTKEEPALIVE) == Marshal.SizeOf(new ClientKeepAlive()));
4358  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOINPUTPROGRESS) == Marshal.SizeOf(new AudioInputProgress()));
4359  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__JITTERCONFIG) == Marshal.SizeOf(new JitterConfig()));
4360  Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__ENCRYPTIONCONTEXT) == Marshal.SizeOf(new EncryptionContext()));
4361 
4362  if (poll_based)
4363  m_ttInst = TTDLL.TT_InitTeamTalkPoll();
4364  else
4365  {
4366  m_eventhandler = new MyEventHandler(this);
4367 #if PocketPC
4368  IntPtr hWnd = m_eventhandler.Hwnd;
4369 #else
4370  m_eventhandler.CreateControl();
4371  IntPtr hWnd = m_eventhandler.Handle;
4372 #endif
4373  m_ttInst = TTDLL.TT_InitTeamTalk(hWnd, MyEventHandler.WM_TEAMTALK_CLIENTEVENT);
4374  }
4375  }
4376 
4381  ~TeamTalkBase()
4382  {
4383  DeleteMe();
4384  }
4385 
4386 
4387  #region IDisposable Members
4388 
4389  public void Dispose()
4390  {
4391  DeleteMe();
4392  }
4393 
4394  private void DeleteMe()
4395  {
4396  if (m_ttInst != IntPtr.Zero)
4397  {
4398  TTDLL.TT_CloseTeamTalk(m_ttInst);
4399  m_ttInst = IntPtr.Zero;
4400  }
4401  }
4402 
4403  #endregion
4404 
4422  public bool GetMessage(ref TTMessage pMsg, int nWaitMs)
4423  {
4424  return TTDLL.TT_GetMessage(m_ttInst, ref pMsg, ref nWaitMs);
4425  }
4426 
4453  public bool PumpMessage(ClientEvent nClientEvent,
4454  int nIdentifier)
4455  {
4456  return TTDLL.TT_PumpMessage(m_ttInst, nClientEvent, nIdentifier);
4457  }
4458 
4467  public BearWare.ClientFlag GetFlags()
4468  {
4469  return TTDLL.TT_GetFlags(m_ttInst);
4470  }
4471 
4476  {
4477  get { return GetFlags(); }
4478  }
4479 
4489  public static bool SetLicenseInformation(string szRegName, string szRegKey)
4490  {
4491  return TTDLL.TT_SetLicenseInformation(szRegName, szRegKey);
4492  }
4493 
4498  public void ProcessMsg(TTMessage msg)
4499  {
4500  switch (msg.nClientEvent)
4501  {
4502  case ClientEvent.CLIENTEVENT_CON_SUCCESS:
4503  if(OnConnectionSuccess != null)
4505  break;
4506  case ClientEvent.CLIENTEVENT_CON_FAILED:
4507  if (OnConnectionFailed != null)
4509  break;
4510  case ClientEvent.CLIENTEVENT_CON_LOST:
4511  if (OnConnectionLost != null)
4512  OnConnectionLost();
4513  break;
4514  case ClientEvent.CLIENTEVENT_CON_MAX_PAYLOAD_UPDATED :
4515  if (OnConnectionMaxPayloadUpdated != null)
4517  break;
4518  case ClientEvent.CLIENTEVENT_CMD_PROCESSING:
4519  if (OnCmdProcessing != null)
4520  OnCmdProcessing(msg.nSource, (bool)msg.DataToObject());
4521  break;
4522  case ClientEvent.CLIENTEVENT_CMD_ERROR:
4523  if (OnCmdError != null)
4524  OnCmdError((int)msg.nSource, (ClientErrorMsg)msg.DataToObject());
4525  break;
4526  case ClientEvent.CLIENTEVENT_CMD_SUCCESS :
4527  if (OnCmdSuccess != null)
4528  OnCmdSuccess((int)msg.nSource);
4529  break;
4530  case ClientEvent.CLIENTEVENT_CMD_MYSELF_LOGGEDIN:
4531  if (OnCmdMyselfLoggedIn != null)
4533  break;
4534  case ClientEvent.CLIENTEVENT_CMD_MYSELF_LOGGEDOUT:
4535  if (OnCmdMyselfLoggedOut != null)
4537  break;
4538  case ClientEvent.CLIENTEVENT_CMD_MYSELF_KICKED:
4539  if (msg.ttType == TTType.__USER)
4540  {
4541  if (OnCmdMyselfKicked != null)
4543  }
4544  else if (OnCmdMyselfKicked != null)
4545  OnCmdMyselfKicked(new User());
4546  break;
4547  case ClientEvent.CLIENTEVENT_CMD_USER_LOGGEDIN:
4548  if (OnCmdUserLoggedIn != null)
4550  break;
4551  case ClientEvent.CLIENTEVENT_CMD_USER_LOGGEDOUT:
4552  if (OnCmdUserLoggedOut != null)
4554  break;
4555  case ClientEvent.CLIENTEVENT_CMD_USER_UPDATE:
4556  if (OnCmdUserUpdate != null)
4558  break;
4559  case ClientEvent.CLIENTEVENT_CMD_USER_JOINED:
4560  if (OnCmdUserJoinedChannel != null)
4562  break;
4563  case ClientEvent.CLIENTEVENT_CMD_USER_LEFT:
4564  if (OnCmdUserLeftChannel != null)
4566  break;
4567  case ClientEvent.CLIENTEVENT_CMD_USER_TEXTMSG:
4568  if (OnCmdUserTextMessage != null)
4570  break;
4571  case ClientEvent.CLIENTEVENT_CMD_CHANNEL_NEW:
4572  if (OnCmdChannelNew != null)
4574  break;
4575  case ClientEvent.CLIENTEVENT_CMD_CHANNEL_UPDATE:
4576  if (OnCmdChannelUpdate != null)
4578  break;
4579  case ClientEvent.CLIENTEVENT_CMD_CHANNEL_REMOVE:
4580  if (OnCmdChannelRemove != null)
4582  break;
4583  case ClientEvent.CLIENTEVENT_CMD_SERVER_UPDATE:
4584  if (OnCmdServerUpdate != null)
4586  break;
4587  case ClientEvent.CLIENTEVENT_CMD_SERVERSTATISTICS :
4588  if (OnCmdServerStatistics != null)
4590  break;
4591  case ClientEvent.CLIENTEVENT_CMD_FILE_NEW:
4592  if (OnCmdFileNew != null)
4594  break;
4595  case ClientEvent.CLIENTEVENT_CMD_FILE_REMOVE:
4596  if (OnCmdFileRemove != null)
4598  break;
4599  case ClientEvent.CLIENTEVENT_CMD_USERACCOUNT :
4600  if (OnCmdUserAccount != null)
4602  break;
4603  case ClientEvent.CLIENTEVENT_CMD_BANNEDUSER :
4604  if (OnCmdBannedUser != null)
4606  break;
4607 
4608  case ClientEvent.CLIENTEVENT_USER_STATECHANGE :
4609  if (OnUserStateChange != null)
4611  break;
4612  case ClientEvent.CLIENTEVENT_USER_VIDEOCAPTURE:
4613  if (OnUserVideoCapture != null)
4614  OnUserVideoCapture(msg.nSource, (int)msg.DataToObject());
4615  break;
4616  case ClientEvent.CLIENTEVENT_USER_MEDIAFILE_VIDEO:
4617  if (OnUserMediaFileVideo != null)
4618  OnUserMediaFileVideo((int)msg.nSource, (int)msg.DataToObject());
4619  break;
4620  case ClientEvent.CLIENTEVENT_USER_DESKTOPWINDOW:
4621  if (OnUserDesktopWindow != null)
4622  OnUserDesktopWindow((int)msg.nSource, (int)msg.DataToObject());
4623  break;
4624  case ClientEvent.CLIENTEVENT_USER_DESKTOPCURSOR:
4625  if (OnUserDesktopCursor != null)
4627  break;
4628  case ClientEvent.CLIENTEVENT_USER_DESKTOPINPUT :
4629  if (OnUserDesktopInput != null)
4631  break;
4632  case ClientEvent.CLIENTEVENT_USER_RECORD_MEDIAFILE :
4633  if(OnUserRecordMediaFile != null)
4635  break;
4636  case ClientEvent.CLIENTEVENT_USER_AUDIOBLOCK :
4637  if(OnUserAudioBlock != null)
4638  OnUserAudioBlock((int)msg.nSource, (StreamType)msg.DataToObject());
4639  break;
4640  case ClientEvent.CLIENTEVENT_INTERNAL_ERROR :
4641  if(OnInternalError!= null)
4643  break;
4644  case ClientEvent.CLIENTEVENT_VOICE_ACTIVATION :
4645  if(OnVoiceActivation != null)
4646  OnVoiceActivation((bool)msg.DataToObject());
4647  break;
4648  case ClientEvent.CLIENTEVENT_HOTKEY :
4649  if(OnHotKeyToggle != null)
4650  OnHotKeyToggle(msg.nSource, (bool)msg.DataToObject());
4651  break;
4652  case ClientEvent.CLIENTEVENT_HOTKEY_TEST :
4653  if(OnHotKeyTest != null)
4654  OnHotKeyTest(msg.nSource, (bool)msg.DataToObject());
4655  break;
4656  case ClientEvent.CLIENTEVENT_FILETRANSFER :
4657  if(OnFileTransfer != null)
4659  break;
4660  case ClientEvent.CLIENTEVENT_DESKTOPWINDOW_TRANSFER :
4661  if(OnDesktopWindowTransfer != null)
4662  OnDesktopWindowTransfer(msg.nSource, (int)msg.DataToObject());
4663  break;
4664  case ClientEvent.CLIENTEVENT_STREAM_MEDIAFILE :
4665  if(OnStreamMediaFile != null)
4667  break;
4668  case ClientEvent.CLIENTEVENT_LOCAL_MEDIAFILE:
4669  if (OnLocalMediaFile != null)
4671  break;
4672  case ClientEvent.CLIENTEVENT_AUDIOINPUT:
4673  if (OnAudioInput != null)
4675  break;
4676  case ClientEvent.CLIENTEVENT_USER_FIRSTVOICESTREAMPACKET:
4677  if (OnUserFirstVoiceStreamPacket != null)
4679  break;
4680  }
4681  }
4682 
4695  public static bool GetDefaultSoundDevices(ref int lpnInputDeviceID,
4696  ref int lpnOutputDeviceID)
4697  {
4698  return TTDLL.TT_GetDefaultSoundDevices(ref lpnInputDeviceID, ref lpnOutputDeviceID);
4699  }
4704  public static bool GetDefaultSoundDevicesEx(SoundSystem nSndSystem,
4705  ref int lpnInputDeviceID,
4706  ref int lpnOutputDeviceID)
4707  {
4708  return TTDLL.TT_GetDefaultSoundDevicesEx(nSndSystem, ref lpnInputDeviceID, ref lpnOutputDeviceID);
4709  }
4718  public static bool GetSoundDevices(out SoundDevice[] lpSoundDevices)
4719  {
4720  int count = 0;
4721  bool b = TTDLL.TT_GetSoundDevices_NULL(IntPtr.Zero, ref count);
4722  SoundDevice[] devs = new SoundDevice[count];
4723  b = TTDLL.TT_GetSoundDevices(devs, ref count);
4724  lpSoundDevices = b ? devs : null;
4725  return b;
4726  }
4742  public static bool RestartSoundSystem()
4743  {
4744  return TTDLL.TT_RestartSoundSystem();
4745  }
4750  public static IntPtr StartSoundLoopbackTest(int nInputDeviceID, int nOutputDeviceID,
4751  int nSampleRate, int nChannels,
4752  bool bDuplexMode, SpeexDSP lpSpeexDSP)
4753  {
4754  return TTDLL.TT_StartSoundLoopbackTest(nInputDeviceID, nOutputDeviceID,
4755  nSampleRate, nChannels, bDuplexMode,
4756  ref lpSpeexDSP);
4757  }
4789  public static IntPtr StartSoundLoopbackTest(int nInputDeviceID, int nOutputDeviceID,
4790  int nSampleRate, int nChannels,
4791  bool bDuplexMode, AudioPreprocessor lpAudioPreprocessor,
4792  BearWare.SoundDeviceEffects lpSoundDeviceEffects)
4793  {
4794  return TTDLL.TT_StartSoundLoopbackTestEx(nInputDeviceID, nOutputDeviceID,
4795  nSampleRate, nChannels, bDuplexMode,
4796  ref lpAudioPreprocessor, ref lpSoundDeviceEffects);
4797  }
4804  public static bool CloseSoundLoopbackTest(IntPtr lpTTSoundLoop)
4805  {
4806  return TTDLL.TT_CloseSoundLoopbackTest(lpTTSoundLoop);
4807  }
4836  public bool InitSoundInputDevice(int nInputDeviceID)
4837  {
4838  return TTDLL.TT_InitSoundInputDevice(m_ttInst, nInputDeviceID);
4839  }
4840 
4871  public bool InitSoundInputSharedDevice(int nSampleRate,int nChannels, int nFrameSize)
4872  {
4873  return TTDLL.TT_InitSoundInputSharedDevice(nSampleRate, nChannels, nFrameSize);
4874  }
4875 
4904  public bool InitSoundOutputDevice(int nOutputDeviceID)
4905  {
4906  return TTDLL.TT_InitSoundOutputDevice(m_ttInst, nOutputDeviceID);
4907  }
4938  public bool InitSoundOutputSharedDevice(int nSampleRate, int nChannels,int nFrameSize)
4939  {
4940  return TTDLL.TT_InitSoundOutputSharedDevice(nSampleRate, nChannels, nFrameSize);
4941  }
4975  public bool InitSoundDuplexDevices(int nInputDeviceID, int nOutputDeviceID)
4976  {
4977  return TTDLL.TT_InitSoundDuplexDevices(m_ttInst, nInputDeviceID, nOutputDeviceID);
4978  }
4999  {
5000  return TTDLL.TT_CloseSoundInputDevice(m_ttInst);
5001  }
5021  {
5022  return TTDLL.TT_CloseSoundOutputDevice(m_ttInst);
5023  }
5031  {
5032  return TTDLL.TT_CloseSoundDuplexDevices(m_ttInst);
5033  }
5069  public bool SetSoundDeviceEffects(SoundDeviceEffects lpSoundDeviceEffect)
5070  {
5071  return TTDLL.TT_SetSoundDeviceEffects(m_ttInst, ref lpSoundDeviceEffect);
5072  }
5077  public bool GetSoundDeviceEffects(ref SoundDeviceEffects lpSoundDeviceEffect)
5078  {
5079  return TTDLL.TT_GetSoundDeviceEffects(m_ttInst, ref lpSoundDeviceEffect);
5080  }
5097  public int GetSoundInputLevel()
5098  {
5099  return TTDLL.TT_GetSoundInputLevel(m_ttInst);
5100  }
5116  public bool SetSoundInputGainLevel(int nLevel)
5117  {
5118  return TTDLL.TT_SetSoundInputGainLevel(m_ttInst, nLevel);
5119  }
5127  {
5128  return TTDLL.TT_GetSoundInputGainLevel(m_ttInst);
5129  }
5130 
5146  public bool SetSoundInputPreprocess(SpeexDSP lpSpeexDSP)
5147  {
5148  return TTDLL.TT_SetSoundInputPreprocess(m_ttInst, ref lpSpeexDSP);
5149  }
5150 
5159  public bool GetSoundInputPreprocess(ref SpeexDSP lpSpeexDSP)
5160  {
5161  return TTDLL.TT_GetSoundInputPreprocess(m_ttInst, ref lpSpeexDSP);
5162  }
5174  public bool SetSoundInputPreprocess(AudioPreprocessor lpAudioPreprocessor)
5175  {
5176  return TTDLL.TT_SetSoundInputPreprocessEx(m_ttInst, ref lpAudioPreprocessor);
5177  }
5178 
5186  public bool GetSoundInputPreprocess(ref AudioPreprocessor lpAudioPreprocessor)
5187  {
5188  return TTDLL.TT_GetSoundInputPreprocessEx(m_ttInst, ref lpAudioPreprocessor);
5189  }
5197  public bool SetSoundOutputVolume(int nVolume)
5198  {
5199  return TTDLL.TT_SetSoundOutputVolume(m_ttInst, nVolume);
5200  }
5208  {
5209  return TTDLL.TT_GetSoundOutputVolume(m_ttInst);
5210  }
5218  public bool SetSoundOutputMute(bool bMuteAll)
5219  {
5220  return TTDLL.TT_SetSoundOutputMute(m_ttInst, bMuteAll);
5221  }
5232  public bool Enable3DSoundPositioning(bool bEnable)
5233  {
5234  return TTDLL.TT_Enable3DSoundPositioning(m_ttInst, bEnable);
5235  }
5245  public bool AutoPositionUsers()
5246  {
5247  return TTDLL.TT_AutoPositionUsers(m_ttInst);
5248  }
5249 
5313  public bool EnableAudioBlockEvent(int nUserID, StreamType uStreamTypes,
5314  bool bEnable)
5315  {
5316  return TTDLL.TT_EnableAudioBlockEvent(m_ttInst, nUserID, uStreamTypes, bEnable);
5317  }
5346  public bool EnableAudioBlockEvent(int nUserID, StreamType uStreamTypes,
5347  AudioFormat lpAudioFormat, bool bEnable)
5348  {
5349  return TTDLL.TT_EnableAudioBlockEventEx(m_ttInst, nUserID, uStreamTypes, ref lpAudioFormat, bEnable);
5350  }
5385  public bool InsertAudioBlock(AudioBlock lpAudioBlock)
5386  {
5387  return TTDLL.TT_InsertAudioBlock(m_ttInst, ref lpAudioBlock);
5388  }
5389 
5407  public bool EnableVoiceTransmission(bool bEnable)
5408  {
5409  return TTDLL.TT_EnableVoiceTransmission(m_ttInst, bEnable);
5410  }
5411 
5437  public bool EnableVoiceActivation(bool bEnable)
5438  {
5439  return TTDLL.TT_EnableVoiceActivation(m_ttInst, bEnable);
5440  }
5455  public bool SetVoiceActivationLevel(int nLevel)
5456  {
5457  return TTDLL.TT_SetVoiceActivationLevel(m_ttInst, nLevel);
5458  }
5466  {
5467  return TTDLL.TT_GetVoiceActivationLevel(m_ttInst);
5468  }
5481  public bool SetVoiceActivationStopDelay(int nDelayMSec)
5482  {
5483  return TTDLL.TT_SetVoiceActivationStopDelay(m_ttInst, nDelayMSec);
5484  }
5485 
5496  {
5497  return TTDLL.TT_GetVoiceActivationStopDelay(m_ttInst);
5498  }
5499 
5542  public bool StartRecordingMuxedAudioFile(AudioCodec lpAudioCodec,
5543  string szAudioFileName,
5544  AudioFileFormat uAFF)
5545  {
5546  return TTDLL.TT_StartRecordingMuxedAudioFile(m_ttInst,
5547  ref lpAudioCodec,
5548  szAudioFileName,
5549  uAFF);
5550  }
5551 
5571  public bool StartRecordingMuxedAudioFile(int nChannelID,
5572  string szAudioFileName,
5573  AudioFileFormat uAFF)
5574  {
5575  return TTDLL.TT_StartRecordingMuxedAudioFileEx(m_ttInst,
5576  nChannelID,
5577  szAudioFileName,
5578  uAFF);
5579  }
5580 
5581 
5613  public bool StartRecordingMuxedStreams(StreamType uStreamTypes,
5614  AudioCodec lpAudioCodec,
5615  string szAudioFileName,
5616  AudioFileFormat uAFF)
5617  {
5618  return TTDLL.TT_StartRecordingMuxedStreams(m_ttInst, uStreamTypes, ref lpAudioCodec, szAudioFileName, uAFF);
5619  }
5620 
5633  {
5634  return TTDLL.TT_StopRecordingMuxedAudioFile(m_ttInst);
5635  }
5636 
5643  public bool StopRecordingMuxedAudioFile(int nChannelID)
5644  {
5645  return TTDLL.TT_StopRecordingMuxedAudioFileEx(m_ttInst, nChannelID);
5646  }
5647 
5670  public bool StartVideoCaptureTransmission(VideoCodec lpVideoCodec)
5671  {
5672  return TTDLL.TT_StartVideoCaptureTransmission(m_ttInst, ref lpVideoCodec);
5673  }
5674 
5680  {
5681  return TTDLL.TT_StopVideoCaptureTransmission(m_ttInst);
5682  }
5683 
5695  public static bool GetVideoCaptureDevices(out VideoCaptureDevice[] lpVideoDevices)
5696  {
5697  //To speed up query we only query for a max of 25.
5698  //Hopefully no one has more than 25 capture devices.
5699  VideoCaptureDevice[] devs = new VideoCaptureDevice[25];
5700  int count = devs.Length;
5701  bool b = TTDLL.TT_GetVideoCaptureDevices(devs, ref count);
5702  if (b)
5703  {
5704  lpVideoDevices = new VideoCaptureDevice[count];
5705  for (int i = 0; i < count; i++)
5706  lpVideoDevices[i] = devs[i];
5707  }
5708  else lpVideoDevices = null;
5709 
5710  return b;
5711  }
5723  public bool InitVideoCaptureDevice(string szDeviceID,
5724  VideoFormat lpVideoFormat)
5725  {
5726  return TTDLL.TT_InitVideoCaptureDevice(m_ttInst, szDeviceID, ref lpVideoFormat);
5727  }
5733  {
5734  return TTDLL.TT_CloseVideoCaptureDevice(m_ttInst);
5735  }
5750  public bool PaintVideoFrame(int nUserID,
5751  System.IntPtr hDC,
5752  int XDest,
5753  int YDest,
5754  int nDestWidth,
5755  int nDestHeight,
5756  ref VideoFrame lpVideoFrame)
5757  {
5758  return TTDLL.TT_PaintVideoFrame(nUserID, hDC, XDest, YDest, nDestWidth,
5759  nDestHeight, ref lpVideoFrame);
5760  }
5761 
5793  public bool PaintVideoFrameEx(int nUserID,
5794  System.IntPtr hDC,
5795  int XDest,
5796  int YDest,
5797  int nDestWidth,
5798  int nDestHeight,
5799  int XSrc,
5800  int YSrc,
5801  int nSrcWidth,
5802  int nSrcHeight,
5803  ref VideoFrame lpVideoFrame)
5804  {
5805  return TTDLL.TT_PaintVideoFrameEx(nUserID, hDC, XDest, YDest, nDestWidth, nDestHeight,
5806  XSrc, YSrc, nSrcWidth, nSrcHeight,
5807  ref lpVideoFrame);
5808  }
5809 
5828  public VideoFrame AcquireUserVideoCaptureFrame(int nUserID, out Bitmap bmp)
5829  {
5830  bmp = null;
5831  IntPtr ptr = TTDLL.TT_AcquireUserVideoCaptureFrame(m_ttInst, nUserID);
5832  if(ptr == IntPtr.Zero)
5833  return new VideoFrame();
5834 
5835  VideoFrame frm = (VideoFrame)Marshal.PtrToStructure(ptr, typeof(VideoFrame));
5836  vidcapframes.Add(frm.frameBuffer, ptr);
5837 
5838  PixelFormat pixelformat = PixelFormat.Format32bppRgb;
5839  bmp = new Bitmap(frm.nWidth, frm.nHeight, frm.nWidth*4, pixelformat, frm.frameBuffer);
5840  return frm;
5841  }
5842 
5843  Dictionary<IntPtr, IntPtr> vidcapframes = new Dictionary<IntPtr, IntPtr>();
5844 
5852  public bool ReleaseUserVideoCaptureFrame(VideoFrame lpVideoFrame)
5853  {
5854  IntPtr ptr;
5855  if (vidcapframes.TryGetValue(lpVideoFrame.frameBuffer, out ptr))
5856  {
5857  vidcapframes.Remove(lpVideoFrame.frameBuffer);
5858  return TTDLL.TT_ReleaseUserVideoCaptureFrame(m_ttInst, ptr);
5859  }
5860  return false;
5861  }
5862 
5875  /*
5876  public bool GetUserVideoFrame(int nUserID,
5877  ref System.Drawing.Bitmap lpPicture)
5878  {
5879  CaptureFormat cap;
5880  if (!TTDLL.TT_GetUserVideoFrame(m_ttInst, nUserID, IntPtr.Zero, 0, out cap))
5881  return false;
5882 
5883  PixelFormat pixelformat = PixelFormat.Format32bppRgb;
5884 
5885  if (lpPicture == null ||
5886  lpPicture.Width != cap.nWidth ||
5887  lpPicture.Height != cap.nHeight
5888 #if PocketPC
5889  )
5890 #else
5891  || lpPicture.PixelFormat != pixelformat)
5892 #endif
5893  {
5894  lpPicture = new Bitmap(cap.nWidth, cap.nHeight,
5895  pixelformat);
5896  }
5897 
5898  // Lock the bitmap's bits.
5899  System.Drawing.Rectangle rect = new System.Drawing.Rectangle(0, 0, lpPicture.Width, lpPicture.Height);
5900  BitmapData bmpData = lpPicture.LockBits(rect, ImageLockMode.ReadWrite, pixelformat);
5901 
5902  // Get the address of the first line.
5903  IntPtr ptr = bmpData.Scan0;
5904 
5905  bool b = TTDLL.TT_GetUserVideoFrame(m_ttInst, nUserID, ptr,
5906  cap.nWidth * cap.nHeight * 4, out cap);
5907  // Unlock the bits.
5908  lpPicture.UnlockBits(bmpData);
5909  return b;
5910  }
5911  * */
5912 
5920  public bool StartStreamingMediaFileToChannel(string szMediaFilePath,
5921  VideoCodec lpVideoCodec)
5922  {
5923  return TTDLL.TT_StartStreamingMediaFileToChannel(m_ttInst, szMediaFilePath,
5924  ref lpVideoCodec);
5925  }
5926 
5956  public bool StartStreamingMediaFileToChannel(string szMediaFilePath,
5957  MediaFilePlayback lpMediaFilePlayback,
5958  VideoCodec lpVideoCodec)
5959  {
5960  return TTDLL.TT_StartStreamingMediaFileToChannelEx(m_ttInst, szMediaFilePath,
5961  ref lpMediaFilePlayback,
5962  ref lpVideoCodec);
5963  }
5964 
5981  public bool UpdateStreamingMediaFileToChannel(MediaFilePlayback lpMediaFilePlayback,
5982  VideoCodec lpVideoCodec)
5983  {
5984  return TTDLL.TT_UpdateStreamingMediaFileToChannel(m_ttInst, ref lpMediaFilePlayback, ref lpVideoCodec);
5985  }
5986 
5995  {
5996  return TTDLL.TT_StopStreamingMediaFileToChannel(m_ttInst);
5997  }
5998 
6023  public int InitLocalPlayback(string szMediaFilePath, MediaFilePlayback lpMediaFilePlayback)
6024  {
6025  return TTDLL.TT_InitLocalPlayback(m_ttInst, szMediaFilePath, ref lpMediaFilePlayback);
6026  }
6027 
6039  public bool UpdateLocalPlayback(int nPlaybackSessionID,
6040  MediaFilePlayback lpMediaFilePlayback)
6041  {
6042  return TTDLL.TT_UpdateLocalPlayback(m_ttInst, nPlaybackSessionID, ref lpMediaFilePlayback);
6043  }
6044 
6053  public bool StopLocalPlayback(int nPlaybackSessionID)
6054  {
6055  return TTDLL.TT_StopLocalPlayback(m_ttInst, nPlaybackSessionID);
6056  }
6057 
6065  public static bool GetMediaFileInfo(string szMediaFilePath,
6066  ref MediaFileInfo lpMediaFileInfo)
6067  {
6068  return TTDLL.TT_GetMediaFileInfo(szMediaFilePath, ref lpMediaFileInfo);
6069  }
6070 
6090  public VideoFrame AcquireUserMediaVideoFrame(int nUserID, out Bitmap bmp)
6091  {
6092  bmp = null;
6093  IntPtr ptr = TTDLL.TT_AcquireUserMediaVideoFrame(m_ttInst, nUserID);
6094  if (ptr == IntPtr.Zero)
6095  return new VideoFrame();
6096 
6097  VideoFrame frm = (VideoFrame)Marshal.PtrToStructure(ptr, typeof(VideoFrame));
6098  mediaframes.Add(frm.frameBuffer, ptr);
6099 
6100  PixelFormat pixelformat = PixelFormat.Format32bppRgb;
6101  bmp = new Bitmap(frm.nWidth, frm.nHeight, frm.nWidth * 4, pixelformat, frm.frameBuffer);
6102  return frm;
6103  }
6104 
6112  public bool ReleaseUserMediaVideoFrame(VideoFrame lpVideoFrame)
6113  {
6114  IntPtr ptr;
6115  if (mediaframes.TryGetValue(lpVideoFrame.frameBuffer, out ptr))
6116  {
6117  mediaframes.Remove(lpVideoFrame.frameBuffer);
6118  return TTDLL.TT_ReleaseUserMediaVideoFrame(m_ttInst, ptr);
6119  }
6120  return false;
6121  }
6122 
6123  Dictionary<IntPtr, IntPtr> mediaframes = new Dictionary<IntPtr, IntPtr>();
6124 
6167  public int SendDesktopWindow(DesktopWindow lpDesktopWindow,
6168  BitmapFormat nConvertBmpFormat)
6169  {
6170  return TTDLL.TT_SendDesktopWindow(m_ttInst, ref lpDesktopWindow, nConvertBmpFormat);
6171  }
6172 
6180  public bool CloseDesktopWindow()
6181  {
6182  return TTDLL.TT_CloseDesktopWindow(m_ttInst);
6183  }
6184 
6201  public static System.Drawing.Color Palette_GetColorTable(BitmapFormat nBmpPalette,
6202  int nIndex)
6203  {
6204  IntPtr ptr = TTDLL.TT_Palette_GetColorTable(nBmpPalette, nIndex);
6205  switch(nBmpPalette)
6206  {
6207  case BitmapFormat.BMP_RGB8_PALETTE:
6208  return Color.FromArgb(Marshal.ReadInt32(ptr));
6209  }
6210  return new Color();
6211  }
6212 
6223  public int SendDesktopWindowFromHWND(System.IntPtr hWnd,
6224  BitmapFormat nBitmapFormat,
6225  DesktopProtocol nDesktopProtocol)
6226  {
6227  return TTDLL.TT_SendDesktopWindowFromHWND(m_ttInst, hWnd, nBitmapFormat, nDesktopProtocol);
6228  }
6229 
6244  public bool PaintDesktopWindow(int nUserID,
6245  System.IntPtr hDC,
6246  int XDest,
6247  int YDest,
6248  int nDestWidth,
6249  int nDestHeight)
6250  {
6251  return TTDLL.TT_PaintDesktopWindow(m_ttInst, nUserID, hDC, XDest, YDest, nDestWidth, nDestHeight);
6252  }
6253 
6286  public bool PaintDesktopWindowEx(int nUserID,
6287  System.IntPtr hDC,
6288  int XDest,
6289  int YDest,
6290  int nDestWidth,
6291  int nDestHeight,
6292  int XSrc,
6293  int YSrc,
6294  int nSrcWidth,
6295  int nSrcHeight)
6296  {
6297  return TTDLL.TT_PaintDesktopWindowEx(m_ttInst, nUserID, hDC, XDest,
6298  YDest, nDestWidth, nDestHeight,
6299  XSrc, YSrc, nSrcWidth, nSrcHeight);
6300  }
6301 
6314  public bool SendDesktopCursorPosition(ushort nPosX,
6315  ushort nPosY)
6316  {
6317  return TTDLL.TT_SendDesktopCursorPosition(m_ttInst, nPosX, nPosY);
6318  }
6319 
6343  public bool SendDesktopInput(int nUserID,
6344  DesktopInput[] lpDesktopInputs)
6345  {
6346  return TTDLL.TT_SendDesktopInput(m_ttInst, nUserID, lpDesktopInputs, lpDesktopInputs.Length);
6347  }
6348 
6373  {
6374  IntPtr ptr = TTDLL.TT_AcquireUserDesktopWindow(m_ttInst, nUserID);
6375  if (ptr == IntPtr.Zero)
6376  return new DesktopWindow();
6377  DesktopWindow lpDesktopWindow = (DesktopWindow)Marshal.PtrToStructure(ptr, typeof(DesktopWindow));
6378  desktopwindows.Add(lpDesktopWindow.frameBuffer, ptr);
6379  return lpDesktopWindow;
6380  }
6381 
6388  public DesktopWindow AcquireUserDesktopWindowEx(int nUserID, BitmapFormat nBitmapFormat)
6389  {
6390  IntPtr ptr = TTDLL.TT_AcquireUserDesktopWindowEx(m_ttInst, nUserID, nBitmapFormat);
6391  if (ptr == IntPtr.Zero)
6392  return new DesktopWindow();
6393  DesktopWindow lpDesktopWindow = (DesktopWindow)Marshal.PtrToStructure(ptr, typeof(DesktopWindow));
6394  desktopwindows.Add(lpDesktopWindow.frameBuffer, ptr);
6395  return lpDesktopWindow;
6396  }
6397 
6398  Dictionary<IntPtr, IntPtr> desktopwindows = new Dictionary<IntPtr, IntPtr>();
6401  public bool ReleaseUserDesktopWindow(DesktopWindow lpDesktopWindow)
6402  {
6403  IntPtr ptr;
6404  if (desktopwindows.TryGetValue(lpDesktopWindow.frameBuffer, out ptr))
6405  {
6406  desktopwindows.Remove(lpDesktopWindow.frameBuffer);
6407  return TTDLL.TT_ReleaseUserDesktopWindow(m_ttInst, ptr);
6408  }
6409  return false;
6410  }
6411 
6428  public bool SetEncryptionContext(EncryptionContext lpEncryptionContext)
6429  {
6430  return TTDLL.TT_SetEncryptionContext(m_ttInst, ref lpEncryptionContext);
6431  }
6432 
6461  public bool Connect(string szHostAddress,
6462  int nTcpPort,
6463  int nUdpPort,
6464  int nLocalTcpPort,
6465  int nLocalUdpPort,
6466  bool bEncrypted)
6467  {
6468  return TTDLL.TT_Connect(m_ttInst, szHostAddress, nTcpPort, nUdpPort,
6469  nLocalTcpPort, nLocalUdpPort, bEncrypted);
6470  }
6471 
6495  public bool ConnectSysID(string szHostAddress,
6496  int nTcpPort,
6497  int nUdpPort,
6498  int nLocalTcpPort,
6499  int nLocalUdpPort,
6500  bool bEncrypted,
6501  string szSystemID)
6502  {
6503  return TTDLL.TT_ConnectSysID(m_ttInst, szHostAddress,
6504  nTcpPort, nUdpPort, nLocalTcpPort,
6505  nLocalUdpPort, bEncrypted, szSystemID);
6506  }
6507 
6528  public bool ConnectEx(string szHostAddress,
6529  int nTcpPort,
6530  int nUdpPort,
6531  string szBindIPAddr,
6532  int nLocalTcpPort,
6533  int nLocalUdpPort,
6534  bool bEncrypted)
6535  {
6536  return TTDLL.TT_ConnectEx(m_ttInst, szHostAddress, nTcpPort, nUdpPort,
6537  szBindIPAddr, nLocalTcpPort, nLocalUdpPort,
6538  bEncrypted);
6539  }
6540 
6545  public bool Disconnect()
6546  {
6547  return TTDLL.TT_Disconnect(m_ttInst);
6548  }
6558  public bool QueryMaxPayload(int nUserID)
6559  {
6560  return TTDLL.TT_QueryMaxPayload(m_ttInst, nUserID);
6561  }
6567  public bool GetClientStatistics(ref ClientStatistics lpClientStatistics)
6568  {
6569  return TTDLL.TT_GetClientStatistics(m_ttInst, ref lpClientStatistics);
6570  }
6571 
6586  public bool SetClientKeepAlive(ClientKeepAlive lpClientKeepAlive)
6587  {
6588  return TTDLL.TT_SetClientKeepAlive(m_ttInst, ref lpClientKeepAlive);
6589  }
6590 
6597  public bool GetClientKeepAlive(ref ClientKeepAlive lpClientKeepAlive)
6598  {
6599  return TTDLL.TT_GetClientKeepAlive(m_ttInst, ref lpClientKeepAlive);
6600  }
6623  public int DoPing()
6624  {
6625  return TTDLL.TT_DoPing(m_ttInst);
6626  }
6627 
6639  public int DoLogin(string szNickname, string szUsername, string szPassword)
6640  {
6641  return TTDLL.TT_DoLogin(m_ttInst, szNickname, szUsername, szPassword);
6642  }
6643 
6673  public int DoLoginEx(string szNickname, string szUsername, string szPassword,
6674  string szClientName)
6675  {
6676  return TTDLL.TT_DoLoginEx(m_ttInst, szNickname, szUsername, szPassword, szClientName);
6677  }
6691  public int DoLogout()
6692  {
6693  return TTDLL.TT_DoLogout(m_ttInst);
6694  }
6734  public int DoJoinChannel(Channel lpChannel)
6735  {
6736  return TTDLL.TT_DoJoinChannel(m_ttInst, ref lpChannel);
6737  }
6761  public int DoJoinChannelByID(int nChannelID, string szPassword)
6762  {
6763  return TTDLL.TT_DoJoinChannelByID(m_ttInst, nChannelID, szPassword);
6764  }
6784  public int DoLeaveChannel()
6785  {
6786  return TTDLL.TT_DoLeaveChannel(m_ttInst);
6787  }
6805  public int DoChangeNickname(string szNewNick)
6806  {
6807  return TTDLL.TT_DoChangeNickname(m_ttInst, szNewNick);
6808  }
6828  public int DoChangeStatus(int nStatusMode, string szStatusMessage)
6829  {
6830  return TTDLL.TT_DoChangeStatus(m_ttInst, nStatusMode, szStatusMessage);
6831  }
6850  public int DoTextMessage(TextMessage lpTextMessage)
6851  {
6852  return TTDLL.TT_DoTextMessage(m_ttInst, ref lpTextMessage);
6853  }
6874  public int DoChannelOp(int nUserID, int nChannelID, bool bMakeOperator)
6875  {
6876  return TTDLL.TT_DoChannelOp(m_ttInst, nUserID, nChannelID, bMakeOperator);
6877  }
6897  public int DoChannelOpEx(int nUserID,
6898  int nChannelID,
6899  string szOpPassword,
6900  bool bMakeOperator)
6901  {
6902  return TTDLL.TT_DoChannelOpEx(m_ttInst, nUserID, nChannelID, szOpPassword, bMakeOperator);
6903  }
6926  public int DoKickUser(int nUserID, int nChannelID)
6927  {
6928  return TTDLL.TT_DoKickUser(m_ttInst, nUserID, nChannelID);
6929  }
6964  public int DoSendFile(int nChannelID, string szLocalFilePath)
6965  {
6966  return TTDLL.TT_DoSendFile(m_ttInst, nChannelID, szLocalFilePath);
6967  }
6997  public int DoRecvFile(int nChannelID, int nFileID, string szLocalFilePath)
6998  {
6999  return TTDLL.TT_DoRecvFile(m_ttInst, nChannelID, nFileID, szLocalFilePath);
7000  }
7023  public int DoDeleteFile(int nChannelID, int nFileID)
7024  {
7025  return TTDLL.TT_DoDeleteFile(m_ttInst, nChannelID, nFileID);
7026  }
7041  public int DoSubscribe(int nUserID, Subscription uSubscriptions)
7042  {
7043  return TTDLL.TT_DoSubscribe(m_ttInst, nUserID, uSubscriptions);
7044  }
7060  public int DoUnsubscribe(int nUserID, Subscription uSubscriptions)
7061  {
7062  return TTDLL.TT_DoUnsubscribe(m_ttInst, nUserID, uSubscriptions);
7063  }
7089  public int DoMakeChannel(Channel lpChannel)
7090  {
7091  return TTDLL.TT_DoMakeChannel(m_ttInst, ref lpChannel);
7092  }
7125  public int DoUpdateChannel(Channel lpChannel)
7126  {
7127  return TTDLL.TT_DoUpdateChannel(m_ttInst, ref lpChannel);
7128  }
7147  public int DoRemoveChannel(int nChannelID)
7148  {
7149  return TTDLL.TT_DoRemoveChannel(m_ttInst, nChannelID);
7150  }
7170  public int DoMoveUser(int nUserID, int nChannelID)
7171  {
7172  return TTDLL.TT_DoMoveUser(m_ttInst, nUserID, nChannelID);
7173  }
7190  public int DoUpdateServer(ServerProperties lpServerProperties)
7191  {
7192  return TTDLL.TT_DoUpdateServer(m_ttInst, ref lpServerProperties);
7193  }
7218  public int DoListUserAccounts(int nIndex, int nCount)
7219  {
7220  return TTDLL.TT_DoListUserAccounts(m_ttInst, nIndex, nCount);
7221  }
7244  public int DoNewUserAccount(UserAccount lpUserAccount)
7245  {
7246  return TTDLL.TT_DoNewUserAccount(m_ttInst, ref lpUserAccount);
7247  }
7266  public int DoDeleteUserAccount(string szUsername)
7267  {
7268  return TTDLL.TT_DoDeleteUserAccount(m_ttInst, szUsername);
7269  }
7297  public int DoBanUser(int nUserID, int nChannelID)
7298  {
7299  return TTDLL.TT_DoBanUser(m_ttInst, nUserID, nChannelID);
7300  }
7301 
7313  public int DoBanUserEx(int nUserID, BanType uBanTypes)
7314  {
7315  return TTDLL.TT_DoBanUserEx(m_ttInst, nUserID, uBanTypes);
7316  }
7317 
7336  public int DoBan(BannedUser lpBannedUser)
7337  {
7338  return TTDLL.TT_DoBan(m_ttInst, ref lpBannedUser);
7339  }
7340 
7361  public int DoBanIPAddress(string szIPAddress, int nChannelID)
7362  {
7363  return TTDLL.TT_DoBanIPAddress(m_ttInst, szIPAddress, nChannelID);
7364  }
7365 
7386  public int DoUnBanUser(string szIPAddress, int nChannelID)
7387  {
7388  return TTDLL.TT_DoUnBanUser(m_ttInst, szIPAddress, nChannelID);
7389  }
7390 
7400  public int DoUnBanUserEx(BannedUser lpBannedUser)
7401  {
7402  return TTDLL.TT_DoUnBanUserEx(m_ttInst, ref lpBannedUser);
7403  }
7404 
7425  public int DoListBans(int nChannelID, int nIndex, int nCount)
7426  {
7427  return TTDLL.TT_DoListBans(m_ttInst, nChannelID, nIndex, nCount);
7428  }
7446  public int DoSaveConfig()
7447  {
7448  return TTDLL.TT_DoSaveConfig(m_ttInst);
7449  }
7466  public int DoQueryServerStats()
7467  {
7468  return TTDLL.TT_DoQueryServerStats(m_ttInst);
7469  }
7482  public int DoQuit()
7483  {
7484  return TTDLL.TT_DoQuit(m_ttInst);
7485  }
7497  public bool GetServerProperties(ref ServerProperties lpServerProperties)
7498  {
7499  return TTDLL.TT_GetServerProperties(m_ttInst, ref lpServerProperties);
7500  }
7511  public bool GetServerUsers(out User[] lpUsers)
7512  {
7513  int count = 0;
7514  bool b = TTDLL.TT_GetServerUsers_NULL(m_ttInst, IntPtr.Zero, ref count);
7515  User[] users = new User[count];
7516  b = TTDLL.TT_GetServerUsers(m_ttInst, users, ref count);
7517  lpUsers = b ? users : null;
7518  return b;
7519  }
7532  public int GetRootChannelID()
7533  {
7534  return TTDLL.TT_GetRootChannelID(m_ttInst);
7535  }
7542  public int GetMyChannelID()
7543  {
7544  return TTDLL.TT_GetMyChannelID(m_ttInst);
7545  }
7549  public int ChannelID { get { return GetMyChannelID(); } }
7557  public bool GetChannel(int nChannelID, ref Channel lpChannel)
7558  {
7559  return TTDLL.TT_GetChannel(m_ttInst, nChannelID, ref lpChannel);
7560  }
7567  public bool GetChannelPath(int nChannelID, ref string szChannelPath)
7568  {
7569  IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
7570  bool b = TTDLL.TT_GetChannelPath(m_ttInst, nChannelID, ptr);
7571  if(b)
7572  szChannelPath = Marshal.PtrToStringUni(ptr);
7573  Marshal.FreeHGlobal(ptr);
7574  return b;
7575  }
7582  public int GetChannelIDFromPath(string szChannelPath)
7583  {
7584  return TTDLL.TT_GetChannelIDFromPath(m_ttInst, szChannelPath);
7585  }
7594  public bool GetChannelUsers(int nChannelID, out User[] lpUsers)
7595  {
7596  int count = 0;
7597  bool b = TTDLL.TT_GetChannelUsers_NULL(m_ttInst, nChannelID, IntPtr.Zero, ref count);
7598  User[] users = new User[count];
7599  b = TTDLL.TT_GetChannelUsers(m_ttInst, nChannelID, users, ref count);
7600  lpUsers = b ? users : null;
7601  return b;
7602  }
7611  public bool GetChannelFiles(int nChannelID, out RemoteFile[] lpRemoteFiles)
7612  {
7613  int count = 0;
7614  bool b = TTDLL.TT_GetChannelFiles_NULL(m_ttInst, nChannelID, IntPtr.Zero, ref count);
7615  RemoteFile[] files = new RemoteFile[count];
7616  b = TTDLL.TT_GetChannelFiles(m_ttInst, nChannelID, files, ref count);
7617  lpRemoteFiles = b ? files : null;
7618  return b;
7619  }
7627  public bool GetChannelFile(int nChannelID, int nFileID, ref RemoteFile lpRemoteFile)
7628  {
7629  return TTDLL.TT_GetChannelFile(m_ttInst, nChannelID, nFileID, ref lpRemoteFile);
7630  }
7637  public bool IsChannelOperator(int nUserID, int nChannelID)
7638  {
7639  return TTDLL.TT_IsChannelOperator(m_ttInst, nUserID, nChannelID);
7640  }
7647  public bool GetServerChannels(out Channel[] lpChannels)
7648  {
7649  int count = 0;
7650  bool b = TTDLL.TT_GetServerChannels_NULL(m_ttInst, IntPtr.Zero, ref count);
7651  Channel[] channels = new Channel[count];
7652  b = TTDLL.TT_GetServerChannels(m_ttInst, channels, ref count);
7653  lpChannels = b ? channels : null;
7654  return b;
7655  }
7669  public int GetMyUserID()
7670  {
7671  return TTDLL.TT_GetMyUserID(m_ttInst);
7672  }
7673 
7684  public bool GetMyUserAccount(ref UserAccount lpUserAccount)
7685  {
7686  return TTDLL.TT_GetMyUserAccount(m_ttInst, ref lpUserAccount);
7687  }
7688 
7692  public int UserID { get { return GetMyUserID(); } }
7693 
7705  {
7706  return TTDLL.TT_GetMyUserType(m_ttInst);
7707  }
7708 
7712  public BearWare.UserType UserType { get { return GetMyUserType(); } }
7713 
7717  public BearWare.UserRight UserRights { get { return GetMyUserRights(); } }
7718 
7720  public BearWare.UserRight GetMyUserRights()
7721  {
7722  return TTDLL.TT_GetMyUserRights(m_ttInst);
7723  }
7724 
7734  public int GetMyUserData()
7735  {
7736  return TTDLL.TT_GetMyUserData(m_ttInst);
7737  }
7738 
7742  public int UserData { get { return GetMyUserData(); } }
7743 
7750  public bool GetUser(int nUserID, ref User lpUser)
7751  {
7752  return TTDLL.TT_GetUser(m_ttInst, nUserID, ref lpUser);
7753  }
7759  public bool GetUserStatistics(int nUserID, ref UserStatistics lpUserStatistics)
7760  {
7761  return TTDLL.TT_GetUserStatistics(m_ttInst, nUserID, ref lpUserStatistics);
7762  }
7771  public bool GetUserByUsername(string szUsername, ref User lpUser)
7772  {
7773  return TTDLL.TT_GetUserByUsername(m_ttInst, szUsername, ref lpUser);
7774  }
7791  public bool SetUserVolume(int nUserID, StreamType nStreamType, int nVolume)
7792  {
7793  return TTDLL.TT_SetUserVolume(m_ttInst, nUserID, nStreamType, nVolume);
7794  }
7806  public bool SetUserMute(int nUserID, StreamType nStreamType, bool bMute)
7807  {
7808  return TTDLL.TT_SetUserMute(m_ttInst, nUserID, nStreamType, bMute);
7809  }
7822  public bool SetUserStoppedPlaybackDelay(int nUserID,
7823  StreamType nStreamType,
7824  int nDelayMSec)
7825  {
7826  return TTDLL.TT_SetUserStoppedPlaybackDelay(m_ttInst, nUserID, nStreamType, nDelayMSec);
7827  }
7828 
7853  public bool SetUserJitterControl(int nUserID,
7854  StreamType nStreamType,
7855  JitterConfig lpJitterConfig)
7856  {
7857  return TTDLL.TT_SetUserJitterControl(m_ttInst, nUserID, nStreamType, ref lpJitterConfig);
7858  }
7859 
7870  public bool GetUserJitterControl(int nUserID,
7871  StreamType nStreamType,
7872  ref JitterConfig lpJitterConfig)
7873  {
7874  return TTDLL.TT_GetUserJitterControl(m_ttInst, nUserID, nStreamType, ref lpJitterConfig);
7875  }
7876 
7892  public bool SetUserPosition(int nUserID, StreamType nStreamType,
7893  float x, float y, float z)
7894  {
7895  return TTDLL.TT_SetUserPosition(m_ttInst, nUserID, nStreamType, x, y, z);
7896  }
7908  public bool SetUserStereo(int nUserID, StreamType nStreamType, bool bLeftSpeaker, bool bRightSpeaker)
7909  {
7910  return TTDLL.TT_SetUserStereo(m_ttInst, nUserID, nStreamType, bLeftSpeaker, bRightSpeaker);
7911  }
7947  public bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars,
7948  AudioFileFormat uAFF)
7949  {
7950  return TTDLL.TT_SetUserMediaStorageDir(m_ttInst, nUserID, szFolderPath, szFileNameVars, uAFF);
7951  }
7952 
7977  public bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars,
7978  AudioFileFormat uAFF, int nStopRecordingExtraDelayMSec)
7979  {
7980  return TTDLL.TT_SetUserMediaStorageDirEx(m_ttInst, nUserID, szFolderPath, szFileNameVars, uAFF, nStopRecordingExtraDelayMSec);
7981  }
7982 
8007  public bool SetUserAudioStreamBufferSize(int nUserID, StreamType uStreamType,
8008  int nMSec)
8009  {
8010  return TTDLL.TT_SetUserAudioStreamBufferSize(m_ttInst, nUserID, uStreamType, nMSec);
8011  }
8031  public AudioBlock AcquireUserAudioBlock(StreamType uStreamTypes, int nUserID)
8032  {
8033  IntPtr ptr = TTDLL.TT_AcquireUserAudioBlock(m_ttInst, uStreamTypes, nUserID);
8034  if (ptr == IntPtr.Zero)
8035  return new AudioBlock();
8036  AudioBlock lpAudioBlock = (AudioBlock)Marshal.PtrToStructure(ptr, typeof(AudioBlock));
8037  audioblocks.Add(lpAudioBlock.lpRawAudio, ptr);
8038  return lpAudioBlock;
8039  }
8040 
8041  Dictionary<IntPtr, IntPtr> audioblocks = new Dictionary<IntPtr, IntPtr>();
8042 
8056  public bool ReleaseUserAudioBlock(AudioBlock lpAudioBlock)
8057  {
8058  IntPtr ptr;
8059  if (audioblocks.TryGetValue(lpAudioBlock.lpRawAudio, out ptr))
8060  {
8061  audioblocks.Remove(lpAudioBlock.lpRawAudio);
8062  return TTDLL.TT_ReleaseUserAudioBlock(m_ttInst, ptr);
8063  }
8064  return false;
8065  }
8079  public bool GetFileTransferInfo(int nTransferID, ref FileTransfer lpFileTransfer)
8080  {
8081  return TTDLL.TT_GetFileTransferInfo(m_ttInst, nTransferID, ref lpFileTransfer);
8082  }
8083 
8092  public bool CancelFileTranfer(int nTransferID)
8093  {
8094  return TTDLL.TT_CancelFileTransfer(m_ttInst, nTransferID);
8095  }
8096 
8107  public static string GetErrorMessage(ClientError nError)
8108  {
8109  IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8110  TTDLL.TT_GetErrorMessage((int)nError, ptr);
8111  string s = Marshal.PtrToStringUni(ptr);
8112  Marshal.FreeHGlobal(ptr);
8113  return s;
8114  }
8115 
8142  public bool HotKey_Register(int nHotKeyID, int[] lpnVKCodes)
8143  {
8144  return TTDLL.TT_HotKey_Register(m_ttInst, nHotKeyID, lpnVKCodes, lpnVKCodes.Length);
8145  }
8151  public bool HotKey_Unregister(int nHotKeyID)
8152  {
8153  return TTDLL.TT_HotKey_Unregister(m_ttInst, nHotKeyID);
8154  }
8160  public int HotKey_IsActive(int nHotKeyID)
8161  {
8162  return TTDLL.TT_HotKey_IsActive(m_ttInst, nHotKeyID);
8163  }
8174  {
8175  if (m_eventhandler != null)
8176  {
8177 #if PocketPC
8178  IntPtr hWnd = m_eventhandler.Hwnd;
8179 #else
8180  IntPtr hWnd = m_eventhandler.Handle;
8181 #endif
8182  return TTDLL.TT_HotKey_InstallTestHook(m_ttInst, hWnd,
8183  MyEventHandler.WM_TEAMTALK_CLIENTEVENT);
8184  }
8185  return false;
8186  }
8193  {
8194  return TTDLL.TT_HotKey_RemoveTestHook(m_ttInst);
8195  }
8202  public bool HotKey_GetKeyString(int nVKCode, ref string szKeyName)
8203  {
8204  IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8205  bool b = TTDLL.TT_HotKey_GetKeyString(m_ttInst, nVKCode, ptr);
8206  if(b)
8207  szKeyName = Marshal.PtrToStringUni(ptr);
8208  Marshal.FreeHGlobal(ptr);
8209  return b;
8210  }
8213  public bool DBG_SetSoundInputTone(StreamType uStreamTypes, int nFrequency)
8214  {
8215  return TTDLL.TT_DBG_SetSoundInputTone(m_ttInst, uStreamTypes, nFrequency);
8216  }
8217 
8218 
8219  public bool DBG_WriteAudioFileTone(MediaFileInfo lpMediaFileInfo,
8220  int nFrequency)
8221  {
8222  return TTDLL.TT_DBG_WriteAudioFileTone(ref lpMediaFileInfo, nFrequency);
8223  }
8224 
8231  public delegate void Connection();
8257 
8263  public delegate void MaxPayloadUpdate(int nPayloadSize);
8264 
8273 
8281  public delegate void CommandProcessing(int nCmdID, bool bActive);
8282 
8294 
8299  public delegate void CommandError(int nCmdID, ClientErrorMsg clienterrormsg);
8300 
8309  public event CommandError OnCmdError;
8310 
8314  public delegate void CommandSuccess(int nCmdID);
8315 
8324 
8330  public delegate void MyselfLoggedIn(int nMyUserID, UserAccount useraccount);
8331 
8341 
8343  public delegate void MyselfLoggedOut();
8352 
8358  public delegate void MyselfKicked(User user);
8365 
8370  public delegate void UserUpdate(User user);
8371 
8375  public delegate void UserStreamUpdate(User user, int nStreamID);
8376 
8385 
8395 
8401 
8407 
8413 
8419  public delegate void UserTextMessage(TextMessage textmessage);
8420 
8426 
8427 
8430  public delegate void ChannelUpdate(Channel channel);
8431 
8439 
8445 
8450 
8452  public delegate void ServerUpdate(ServerProperties serverproperties);
8453 
8460 
8462  public delegate void ServerStats(ServerStatistics serverstatistics);
8463 
8469 
8471  public delegate void FileUpdate(RemoteFile remotefile);
8472 
8477  public event FileUpdate OnCmdFileNew;
8478 
8484 
8486  public delegate void ListUserAccount(UserAccount useraccount);
8487 
8491 
8493  public delegate void ListBannedUser(BannedUser banneduser);
8494 
8498 
8504 
8509 
8511  public delegate void UserVideoFrame(int nUserID, int nStreamID);
8512 
8518 
8524 
8533  public delegate void NewDesktopWindow(int nUserID, int nStreamID);
8534 
8544 
8546  public delegate void UserDesktopInput(int nSrcUserID, DesktopInput desktopinput);
8547 
8554 
8561 
8563  public delegate void UserRecordMediaFile(int nUserID, MediaFileInfo mediafileinfo);
8564 
8570 
8572  public delegate void NewAudioBlock(int nUserID, StreamType nStreamType);
8573 
8584 
8586  public delegate void ErrorOccured(ClientErrorMsg clienterrormsg);
8587 
8593 
8596  public delegate void VoiceActivation(bool bVoiceActive);
8597 
8603 
8609  public delegate void HotKeyToggle(int nHotKeyID, bool bActive);
8610 
8620 
8625  public delegate void HotKeyTest(int nVkCode, bool bActive);
8626 
8643  public event HotKeyTest OnHotKeyTest;
8644 
8648  public delegate void FileTransferUpdate(FileTransfer filetransfer);
8649 
8662 
8672  public delegate void DesktopTransferUpdate(int nSessionID, int nBytesRemain);
8673 
8684 
8686  public delegate void StreamMediaFile(MediaFileInfo mediafileinfo);
8687 
8693 
8695  public delegate void LocalMediaFile(MediaFileInfo mediafileinfo);
8696 
8702 
8704  public delegate void AudioInput(AudioInputProgress aip);
8705 
8710  public event AudioInput OnAudioInput;
8711 
8714  //TTDLL instance
8715  private IntPtr m_ttInst;
8716  //TTDLL event handler
8717  c_tt.MyEventHandler m_eventhandler;
8718  }
8719 
8728  public class TeamTalk5 : TeamTalkBase
8729  {
8730  public const int DEFAULT_TCPPORT = 10333;
8731  public const int DEFAULT_UDPPORT = 10333;
8732 
8734  public TeamTalk5(bool poll_based)
8735  : base(poll_based)
8736  {
8737  }
8738  }
8739 
8746  {
8747  public const int DEFAULT_TCPPORT = 10443;
8748  public const int DEFAULT_UDPPORT = 10443;
8749 
8751  public TeamTalk5Pro(bool poll_based)
8752  : base(poll_based)
8753  {
8754  }
8755  }
8764  public enum TTKeyTranslate : uint
8765  {
8767  TTKEY_NO_TRANSLATE = 0,
8781  }
8782 
8804  public enum MixerControl : uint
8805  {
8807  WAVEOUT_WAVE,
8809 
8811  WAVEIN_LINEIN,
8813  }
8814 
8818  public class WindowsMixer
8819  {
8826  public static int GetMixerCount()
8827  {
8828  return TTDLL.TT_Mixer_GetMixerCount();
8829  }
8836  public static bool GetMixerName(int nMixerIndex,
8837  ref string szMixerName)
8838  {
8839  IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8840  bool b = TTDLL.TT_Mixer_GetMixerName(nMixerIndex, ptr);
8841  if(b)
8842  szMixerName = Marshal.PtrToStringUni(ptr);
8843 
8844  Marshal.FreeHGlobal(ptr);
8845  return b;
8846  }
8854  public static bool GetWaveInName(int nWaveDeviceID,
8855  ref string szMixerName)
8856  {
8857  IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8858  bool b = TTDLL.TT_Mixer_GetWaveInName(nWaveDeviceID, ptr);
8859  if(b)
8860  szMixerName = Marshal.PtrToStringUni(ptr);
8861  Marshal.FreeHGlobal(ptr);
8862  return b;
8863  }
8871  public static bool GetWaveOutName(int nWaveDeviceID,
8872  ref string szMixerName)
8873  {
8874  IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8875  bool b = TTDLL.TT_Mixer_GetWaveOutName(nWaveDeviceID, ptr);
8876  if(b)
8877  szMixerName = Marshal.PtrToStringUni(ptr);
8878 
8879  Marshal.FreeHGlobal(ptr);
8880  return b;
8881  }
8882 
8893  public static bool SetWaveOutMute(int nWaveDeviceID, MixerControl nControl, bool bMute)
8894  {
8895  return TTDLL.TT_Mixer_SetWaveOutMute(nWaveDeviceID, nControl, bMute);
8896  }
8906  public static int GetWaveOutMute(int nWaveDeviceID, MixerControl nControl)
8907  {
8908  return TTDLL.TT_Mixer_GetWaveOutMute(nWaveDeviceID, nControl);
8909  }
8918  public static bool SetWaveOutVolume(int nWaveDeviceID, MixerControl nControl, int nVolume)
8919  {
8920  return TTDLL.TT_Mixer_SetWaveOutVolume(nWaveDeviceID, nControl, nVolume);
8921  }
8930  public static int GetWaveOutVolume(int nWaveDeviceID, MixerControl nControl)
8931  {
8932  return TTDLL.TT_Mixer_GetWaveOutVolume(nWaveDeviceID, nControl);
8933  }
8941  public static bool SetWaveInSelected(int nWaveDeviceID, MixerControl nControl)
8942  {
8943  return TTDLL.TT_Mixer_SetWaveInSelected(nWaveDeviceID, nControl);
8944  }
8953  public static int GetWaveInSelected(int nWaveDeviceID, MixerControl nControl)
8954  {
8955  return TTDLL.TT_Mixer_GetWaveInSelected(nWaveDeviceID, nControl);
8956  }
8965  public static bool SetWaveInVolume(int nWaveDeviceID, MixerControl nControl, int nVolume)
8966  {
8967  return TTDLL.TT_Mixer_SetWaveInVolume(nWaveDeviceID, nControl, nVolume);
8968  }
8977  public static int GetWaveInVolume(int nWaveDeviceID, MixerControl nControl)
8978  {
8979  return TTDLL.TT_Mixer_GetWaveInVolume(nWaveDeviceID, nControl);
8980  }
8987  public static bool SetWaveInBoost(int nWaveDeviceID, bool bEnable)
8988  {
8989  return TTDLL.TT_Mixer_SetWaveInBoost(nWaveDeviceID, bEnable);
8990  }
8997  public static int GetWaveInBoost(int nWaveDeviceID)
8998  {
8999  return TTDLL.TT_Mixer_GetWaveInBoost(nWaveDeviceID);
9000  }
9007  public static bool SetWaveInMute(int nWaveDeviceID, bool bEnable)
9008  {
9009  return TTDLL.TT_Mixer_SetWaveInMute(nWaveDeviceID, bEnable);
9010  }
9017  public static int GetWaveInMute(int nWaveDeviceID)
9018  {
9019  return TTDLL.TT_Mixer_GetWaveInMute(nWaveDeviceID);
9020  }
9029  public static int GetWaveInControlCount(int nWaveDeviceID)
9030  {
9031  return TTDLL.TT_Mixer_GetWaveInControlCount(nWaveDeviceID);
9032  }
9043  public static bool GetWaveInControlName(int nWaveDeviceID, int nControlIndex,
9044  ref string szDeviceName)
9045  {
9046  IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
9047  bool b = TTDLL.TT_Mixer_GetWaveInControlName(nWaveDeviceID, nControlIndex, ptr);
9048  if(b)
9049  szDeviceName = Marshal.PtrToStringUni(ptr);
9050  Marshal.FreeHGlobal(ptr);
9051  return b;
9052  }
9062  public static bool SetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
9063  {
9064  return TTDLL.TT_Mixer_SetWaveInControlSelected(nWaveDeviceID, nControlIndex);
9065  }
9075  public static bool GetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
9076  {
9077  return TTDLL.TT_Mixer_GetWaveInControlSelected(nWaveDeviceID, nControlIndex);
9078  }
9079  }
9088  public class WindowsFirewall
9089  {
9095  public static bool IsEnabled()
9096  {
9097  return TTDLL.TT_Firewall_IsEnabled();
9098  }
9108  public static bool Enable(bool bEnable)
9109  {
9110  return TTDLL.TT_Firewall_Enable(bEnable);
9111  }
9118  public static bool AppExceptionExists(string szExecutable)
9119  {
9120  return TTDLL.TT_Firewall_AppExceptionExists(szExecutable);
9121  }
9131  public static bool AddAppException(string szName, string szExecutable)
9132  {
9133  return TTDLL.TT_Firewall_AddAppException(szName, szExecutable);
9134  }
9144  public static bool RemoveAppException(string szExecutable)
9145  {
9146  return TTDLL.TT_Firewall_RemoveAppException(szExecutable);
9147  }
9148  }
9154  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
9155  public struct ShareWindow
9156  {
9158  public IntPtr hWnd;
9160  public int nWndX;
9162  public int nWndY;
9164  public int nWidth;
9166  public int nHeight;
9168  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
9169  public string szWindowTitle;
9170  }
9171 
9175  public class WindowsHelper
9176  {
9179  public static System.IntPtr GetDesktopActiveHWND()
9180  {
9181  return TTDLL.TT_Windows_GetDesktopActiveHWND();
9182  }
9183 
9185  public static System.IntPtr GetDesktopHWND()
9186  {
9187  return TTDLL.TT_Windows_GetDesktopHWND();
9188  }
9189 
9191  public static bool GetDesktopWindowHWND(int nIndex,
9192  ref System.IntPtr lpHWnd)
9193  {
9194  return TTDLL.TT_Windows_GetDesktopWindowHWND(nIndex, ref lpHWnd);
9195  }
9196 
9199  public static bool GetWindow(System.IntPtr hWnd,
9200  ref ShareWindow lpShareWindow)
9201  {
9202  return TTDLL.TT_Windows_GetWindow(hWnd, ref lpShareWindow);
9203  }
9204 
9224  public static int DesktopInputKeyTranslate(TTKeyTranslate nTranslate,
9225  DesktopInput[] lpDesktopInputs,
9226  out DesktopInput[] lpTranslatedDesktopInputs)
9227  {
9228  lpTranslatedDesktopInputs = new DesktopInput[lpDesktopInputs.Length];
9229  return TTDLL.TT_DesktopInput_KeyTranslate(nTranslate, lpDesktopInputs,
9230  lpTranslatedDesktopInputs,
9231  lpDesktopInputs.Length);
9232  }
9233 
9254  public static int DesktopInputExecute(DesktopInput[] lpDesktopInputs)
9255  {
9256  return TTDLL.TT_DesktopInput_Execute(lpDesktopInputs, lpDesktopInputs.Length);
9257  }
9258 
9259  }
9260 }
Class used to load TeamTalk5.dll and instantiate a TeamTalk client in TeamTalk 5 SDK Standard Edition...
Definition: TeamTalk.cs:8729
TeamTalk5(bool poll_based)
Simply calls TeamTalkBase.TeamTalkBase()
Definition: TeamTalk.cs:8734
const int DEFAULT_TCPPORT
Definition: TeamTalk.cs:8730
const int DEFAULT_UDPPORT
Definition: TeamTalk.cs:8731
Class used to load TeamTalk5Pro.dll and instantiate a TeamTalk client in TeamTalk 5 SDK Professional ...
Definition: TeamTalk.cs:8746
const int DEFAULT_UDPPORT
Definition: TeamTalk.cs:8748
const int DEFAULT_TCPPORT
Definition: TeamTalk.cs:8747
TeamTalk5Pro(bool poll_based)
Simply calls TeamTalkBase.TeamTalkBase()
Definition: TeamTalk.cs:8751
Abstract class which encapsulates the TeamTalk 5 client. Instantiate either BearWare....
Definition: TeamTalk.cs:4169
bool DBG_WriteAudioFileTone(MediaFileInfo lpMediaFileInfo, int nFrequency)
Definition: TeamTalk.cs:8219
bool DBG_SetSoundInputTone(StreamType uStreamTypes, int nFrequency)
Definition: TeamTalk.cs:8213
A wrapper for the Windows Firewall API.
Definition: TeamTalk.cs:9089
static bool Enable(bool bEnable)
Enable/disable the Windows Firewall.
Definition: TeamTalk.cs:9108
static bool RemoveAppException(string szExecutable)
Remove an application from the Windows Firewall exception list.
Definition: TeamTalk.cs:9144
static bool IsEnabled()
Check if the Windows Firewall is currently enabled.
Definition: TeamTalk.cs:9095
static bool AddAppException(string szName, string szExecutable)
Add an application to the Windows Firewall exception list.
Definition: TeamTalk.cs:9131
static bool AppExceptionExists(string szExecutable)
Check if an executable is already in the Windows Firewall exception list.
Definition: TeamTalk.cs:9118
Helper class for extracting Windows HWND handles and controlling mouse and keyboard.
Definition: TeamTalk.cs:9176
static bool GetWindow(System.IntPtr hWnd, ref ShareWindow lpShareWindow)
Get the properties of a window from its window handle (HWND).
Definition: TeamTalk.cs:9199
static bool GetDesktopWindowHWND(int nIndex, ref System.IntPtr lpHWnd)
Get the all the handles (HWND) of visible windows.
Definition: TeamTalk.cs:9191
static System.IntPtr GetDesktopActiveHWND()
Get the handle (HWND) of the window which is currently active (focused) on the Windows desktop.
Definition: TeamTalk.cs:9179
static int DesktopInputKeyTranslate(TTKeyTranslate nTranslate, DesktopInput[] lpDesktopInputs, out DesktopInput[] lpTranslatedDesktopInputs)
Translate platform key-code to and from TeamTalk's intermediate format.
Definition: TeamTalk.cs:9224
static int DesktopInputExecute(DesktopInput[] lpDesktopInputs)
Execute desktop (mouse or keyboard) input.
Definition: TeamTalk.cs:9254
static System.IntPtr GetDesktopHWND()
Get the handle (HWND) of the Windows desktop (full desktop).
Definition: TeamTalk.cs:9185
A wrapper for the Windows Mixer API.
Definition: TeamTalk.cs:8819
static bool SetWaveOutVolume(int nWaveDeviceID, MixerControl nControl, int nVolume)
Set the volume of a Windows Mixer Wave-Out device from the 'enum' of devices.
Definition: TeamTalk.cs:8918
static int GetWaveInVolume(int nWaveDeviceID, MixerControl nControl)
Get the volume of a Windows Mixer Wave-In device from the 'enum' of devices.
Definition: TeamTalk.cs:8977
static bool SetWaveOutMute(int nWaveDeviceID, MixerControl nControl, bool bMute)
Mute or unmute a Windows Mixer Wave-Out device from the 'enum' of devices.
Definition: TeamTalk.cs:8893
static bool GetWaveOutName(int nWaveDeviceID, ref string szMixerName)
Get the name of the mixer associated with a wave-out device.
Definition: TeamTalk.cs:8871
static bool SetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
Set the selected state of a Wave-In device in the Windows Mixer.
Definition: TeamTalk.cs:9062
static bool SetWaveInBoost(int nWaveDeviceID, bool bEnable)
Enable and disable microphone boost.
Definition: TeamTalk.cs:8987
static bool GetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
Get the selected state of a Wave-In device in the Windows Mixer.
Definition: TeamTalk.cs:9075
static bool GetWaveInName(int nWaveDeviceID, ref string szMixerName)
Get the name of the mixer associated with a wave-in device.
Definition: TeamTalk.cs:8854
static bool SetWaveInSelected(int nWaveDeviceID, MixerControl nControl)
Set the selected state of a Windows Mixer Wave-In device from the 'enum' of devices.
Definition: TeamTalk.cs:8941
static int GetWaveInBoost(int nWaveDeviceID)
See if microphone boost is enabled.
Definition: TeamTalk.cs:8997
static bool SetWaveInMute(int nWaveDeviceID, bool bEnable)
Mute/unmute microphone input.
Definition: TeamTalk.cs:9007
static int GetMixerCount()
Get the number of Windows Mixers available.
Definition: TeamTalk.cs:8826
static int GetWaveOutVolume(int nWaveDeviceID, MixerControl nControl)
Get the volume of a Windows Mixer Wave-Out device from the 'enum' of devices.
Definition: TeamTalk.cs:8930
static bool SetWaveInVolume(int nWaveDeviceID, MixerControl nControl, int nVolume)
Set the volume of a Windows Mixer Wave-In device from the 'enum' of devices.
Definition: TeamTalk.cs:8965
static int GetWaveInSelected(int nWaveDeviceID, MixerControl nControl)
Get the selected state of a Windows Mixer Wave-In device from the 'enum' of devices.
Definition: TeamTalk.cs:8953
static int GetWaveInMute(int nWaveDeviceID)
See if microphone is muted.
Definition: TeamTalk.cs:9017
static int GetWaveInControlCount(int nWaveDeviceID)
Get the number of Windows Mixer Wave-In devices.
Definition: TeamTalk.cs:9029
static int GetWaveOutMute(int nWaveDeviceID, MixerControl nControl)
Get the mute state of a Windows Mixer Wave-Out device from the 'enum' of devices.
Definition: TeamTalk.cs:8906
static bool GetWaveInControlName(int nWaveDeviceID, int nControlIndex, ref string szDeviceName)
Get the name of the Wave-In device with the specified index.
Definition: TeamTalk.cs:9043
static bool GetMixerName(int nMixerIndex, ref string szMixerName)
Get the name of a Windows Mixer based on its name.
Definition: TeamTalk.cs:8836
int GetRootChannelID()
Get the root channel's ID.
Definition: TeamTalk.cs:7532
const int TT_TRANSMITUSERS_STREAMTYPE_INDEX
Definition: TeamTalk.cs:4226
FileTransferStatus
Status of a file transfer.
Definition: TeamTalk.cs:2760
bool GetChannelFile(int nChannelID, int nFileID, ref RemoteFile lpRemoteFile)
Get information about a file which can be downloaded.
Definition: TeamTalk.cs:7627
const int TT_TRANSMITQUEUE_MAX
Definition: TeamTalk.cs:4270
int ChannelID
Same as GetMyChannelID().
Definition: TeamTalk.cs:7549
const int TT_CLASSROOM_STREAMTYPE_INDEX
Definition: TeamTalk.cs:4214
const int TT_CLASSROOM_FREEFORALL
Definition: TeamTalk.cs:4206
int GetChannelIDFromPath(string szChannelPath)
Get the channel ID of the supplied path. Channels are separated by '/'.
Definition: TeamTalk.cs:7582
const int TT_TRANSMITUSERS_USERID_INDEX
Definition: TeamTalk.cs:4222
ChannelType
The types of channels supported.
Definition: TeamTalk.cs:2531
bool IsChannelOperator(int nUserID, int nChannelID)
Check whether user is operator of a channel.
Definition: TeamTalk.cs:7637
int GetMyChannelID()
Get the channel which the local client instance is currently participating in.
Definition: TeamTalk.cs:7542
bool GetServerChannels(out Channel[] lpChannels)
Get all the channels on the server.
Definition: TeamTalk.cs:7647
bool GetChannelUsers(int nChannelID, out User[] lpUsers)
Get the IDs of all users in a channel.
Definition: TeamTalk.cs:7594
bool GetChannel(int nChannelID, ref Channel lpChannel)
Get the channel with a specific ID.
Definition: TeamTalk.cs:7557
const int TT_CLASSROOM_USERID_INDEX
Definition: TeamTalk.cs:4210
const int TT_TRANSMITUSERS_FREEFORALL
Definition: TeamTalk.cs:4218
bool GetChannelPath(int nChannelID, ref string szChannelPath)
Get the channel's path. Channels are separated by '/'.
Definition: TeamTalk.cs:7567
bool GetChannelFiles(int nChannelID, out RemoteFile[] lpRemoteFiles)
Get the list of the files in a channel which can be downloaded.
Definition: TeamTalk.cs:7611
const int TT_TRANSMITUSERS_MAX
The maximum number of users allowed to transmit when a BearWare.Channel is configured with ChannelTyp...
Definition: TeamTalk.cs:4197
bool CancelFileTranfer(int nTransferID)
Cancel an active file transfer.
Definition: TeamTalk.cs:8092
bool GetFileTransferInfo(int nTransferID, ref FileTransfer lpFileTransfer)
Get information about an active file transfer.
Definition: TeamTalk.cs:8079
@ 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:1544
AudioPreprocessorType
The types of supported audio preprocessors.
Definition: TeamTalk.cs:1452
@ 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:6997
int DoPing()
Ping server and wait for server to reply.
Definition: TeamTalk.cs:6623
int DoJoinChannel(Channel lpChannel)
Create a new channel and join it.
Definition: TeamTalk.cs:6734
int DoListBans(int nChannelID, int nIndex, int nCount)
Issue a command to list the banned users.
Definition: TeamTalk.cs:7425
int DoUnBanUser(string szIPAddress, int nChannelID)
Unban the user with the specified IP-address.
Definition: TeamTalk.cs:7386
int DoMoveUser(int nUserID, int nChannelID)
Issue command to move a user from one channel to another.
Definition: TeamTalk.cs:7170
int DoBanUser(int nUserID, int nChannelID)
Issue a ban command on a user in a specific channel.
Definition: TeamTalk.cs:7297
int DoChannelOpEx(int nUserID, int nChannelID, string szOpPassword, bool bMakeOperator)
Make another user operator of a channel using the szOpPassword of BearWare.Channel.
Definition: TeamTalk.cs:6897
int DoBanUserEx(int nUserID, BanType uBanTypes)
Ban the user with nUserID using the ban types specified.
Definition: TeamTalk.cs:7313
int DoChangeStatus(int nStatusMode, string szStatusMessage)
Change the client instance's currect status.
Definition: TeamTalk.cs:6828
int DoSendFile(int nChannelID, string szLocalFilePath)
Send a file to the specified channel.
Definition: TeamTalk.cs:6964
int DoLogin(string szNickname, string szUsername, string szPassword)
Same as DologinEx() but without the option to specify szClientName. Kept for backwards compatibility.
Definition: TeamTalk.cs:6639
int DoChannelOp(int nUserID, int nChannelID, bool bMakeOperator)
Make another user operator of a channel.
Definition: TeamTalk.cs:6874
int DoDeleteUserAccount(string szUsername)
Issue command to delete a user account on the server.
Definition: TeamTalk.cs:7266
int DoUnsubscribe(int nUserID, Subscription uSubscriptions)
Unsubscribe to user events/data. This can be used to ignore messages or voice data from a specific us...
Definition: TeamTalk.cs:7060
int DoQueryServerStats()
Get the server's current statistics.
Definition: TeamTalk.cs:7466
int DoMakeChannel(Channel lpChannel)
Make a new channel on the server.
Definition: TeamTalk.cs:7089
int DoKickUser(int nUserID, int nChannelID)
Kick user from either channel or server.
Definition: TeamTalk.cs:6926
int DoSaveConfig()
Save the server's current state to its settings file (typically the server's .xml file).
Definition: TeamTalk.cs:7446
int DoDeleteFile(int nChannelID, int nFileID)
Delete a file from a channel.
Definition: TeamTalk.cs:7023
int DoQuit()
Quit from server.
Definition: TeamTalk.cs:7482
int DoUpdateChannel(Channel lpChannel)
Update a channel's properties.
Definition: TeamTalk.cs:7125
int DoLeaveChannel()
Leave the current channel.
Definition: TeamTalk.cs:6784
int DoUnBanUserEx(BannedUser lpBannedUser)
Unban the properties specified in BearWare.BannedUser.
Definition: TeamTalk.cs:7400
int DoNewUserAccount(UserAccount lpUserAccount)
Issue command to create a new user account on the server.
Definition: TeamTalk.cs:7244
int DoSubscribe(int nUserID, Subscription uSubscriptions)
Subscribe to user events and/or data.
Definition: TeamTalk.cs:7041
int DoBanIPAddress(string szIPAddress, int nChannelID)
Issue a ban command on an IP-address user.
Definition: TeamTalk.cs:7361
int DoLoginEx(string szNickname, string szUsername, string szPassword, string szClientName)
Logon to a server.
Definition: TeamTalk.cs:6673
int DoBan(BannedUser lpBannedUser)
Ban the properties specified in lpBannedUser.
Definition: TeamTalk.cs:7336
int DoJoinChannelByID(int nChannelID, string szPassword)
Join an existing channel.
Definition: TeamTalk.cs:6761
int DoLogout()
Logout of the server.
Definition: TeamTalk.cs:6691
int DoChangeNickname(string szNewNick)
Change the client instance's nick name.
Definition: TeamTalk.cs:6805
int DoListUserAccounts(int nIndex, int nCount)
Issue command to list user accounts on the server.
Definition: TeamTalk.cs:7218
int DoUpdateServer(ServerProperties lpServerProperties)
Update server properties.
Definition: TeamTalk.cs:7190
int DoRemoveChannel(int nChannelID)
Remove a channel from a server.
Definition: TeamTalk.cs:7147
int DoTextMessage(TextMessage lpTextMessage)
Send a text message to either a user or a channel.
Definition: TeamTalk.cs:6850
bool Connect(string szHostAddress, int nTcpPort, int nUdpPort, int nLocalTcpPort, int nLocalUdpPort, bool bEncrypted)
Connect to a server.
Definition: TeamTalk.cs:6461
bool SetClientKeepAlive(ClientKeepAlive lpClientKeepAlive)
Update the client instance's default keep alive settings.
Definition: TeamTalk.cs:6586
bool ConnectSysID(string szHostAddress, int nTcpPort, int nUdpPort, int nLocalTcpPort, int nLocalUdpPort, bool bEncrypted, string szSystemID)
Same as Connect() but the option of providing a unique system-ID.
Definition: TeamTalk.cs:6495
bool GetClientStatistics(ref ClientStatistics lpClientStatistics)
Retrieve client statistics of bandwidth usage and response times.
Definition: TeamTalk.cs:6567
bool QueryMaxPayload(int nUserID)
Query the maximum size of UDP data packets to the user or server.
Definition: TeamTalk.cs:6558
bool ConnectEx(string szHostAddress, int nTcpPort, int nUdpPort, string szBindIPAddr, int nLocalTcpPort, int nLocalUdpPort, bool bEncrypted)
Bind to specific IP-address prior to connecting to server.
Definition: TeamTalk.cs:6528
bool SetEncryptionContext(EncryptionContext lpEncryptionContext)
Setup encryption properties prior to Connect().
Definition: TeamTalk.cs:6428
bool Disconnect()
Disconnect from the server.
Definition: TeamTalk.cs:6545
bool GetClientKeepAlive(ref ClientKeepAlive lpClientKeepAlive)
Get the client instance's current keep alive settings.
Definition: TeamTalk.cs:6597
const ushort DESKTOPINPUT_MOUSEPOS_IGNORE
Definition: TeamTalk.cs:864
DesktopWindow AcquireUserDesktopWindowEx(int nUserID, BitmapFormat nBitmapFormat)
Same as TeamTalkBase.AcquireUserDesktopWindow() except an extra option for converting bitmap to a dif...
Definition: TeamTalk.cs:6388
int SendDesktopWindow(DesktopWindow lpDesktopWindow, BitmapFormat nConvertBmpFormat)
Transmit a desktop window (bitmap) to users in the same channel.
Definition: TeamTalk.cs:6167
const uint DESKTOPINPUT_KEYCODE_IGNORE
Definition: TeamTalk.cs:855
TTKeyTranslate
Translate to and from TeamTalk's intermediate key-codes (TTKEYCODE).
Definition: TeamTalk.cs:8765
DesktopKeyState
The state of a key (or mouse button), i.e. if it's pressed or released.
Definition: TeamTalk.cs:791
DesktopWindow AcquireUserDesktopWindow(int nUserID)
Get a user's desktop window (bitmap image).
Definition: TeamTalk.cs:6372
bool PaintDesktopWindow(int nUserID, System.IntPtr hDC, int XDest, int YDest, int nDestWidth, int nDestHeight)
Paint user's desktop window using a Windows' DC (device context).
Definition: TeamTalk.cs:6244
int SendDesktopWindowFromHWND(System.IntPtr hWnd, BitmapFormat nBitmapFormat, DesktopProtocol nDesktopProtocol)
Transmit the specified window in a desktop session.
Definition: TeamTalk.cs:6223
const uint DESKTOPINPUT_KEYCODE_LMOUSEBTN
Definition: TeamTalk.cs:872
DesktopProtocol
The protocols supported for transferring a BearWare.DesktopWindow.
Definition: TeamTalk.cs:747
bool PaintDesktopWindowEx(int nUserID, System.IntPtr hDC, int XDest, int YDest, int nDestWidth, int nDestHeight, int XSrc, int YSrc, int nSrcWidth, int nSrcHeight)
Paint user's desktop window using a Windows' DC (device context).
Definition: TeamTalk.cs:6286
const uint DESKTOPINPUT_KEYCODE_RMOUSEBTN
Definition: TeamTalk.cs:880
bool CloseDesktopWindow()
Close the current desktop session.
Definition: TeamTalk.cs:6180
const int TT_DESKTOPINPUT_MAX
Definition: TeamTalk.cs:4280
bool SendDesktopInput(int nUserID, DesktopInput[] lpDesktopInputs)
Send a mouse or keyboard event to a shared desktop window.
Definition: TeamTalk.cs:6343
bool ReleaseUserDesktopWindow(DesktopWindow lpDesktopWindow)
Release memory allocated by the BearWare.DesktopWindow.
Definition: TeamTalk.cs:6401
BitmapFormat
The bitmap format used for a BearWare.DesktopWindow.
Definition: TeamTalk.cs:720
const uint DESKTOPINPUT_KEYCODE_MMOUSEBTN
Definition: TeamTalk.cs:888
bool SendDesktopCursorPosition(ushort nPosX, ushort nPosY)
Send the position of mouse cursor to users in the same channel.
Definition: TeamTalk.cs:6314
static System.Drawing.Color Palette_GetColorTable(BitmapFormat nBmpPalette, int nIndex)
Get RGB values of the palette for the bitmap format.
Definition: TeamTalk.cs:6201
@ 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:8107
ClientError
Errors which can occur either as a result of client commands or as a result of internal errors.
Definition: TeamTalk.cs:3029
@ 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:8553
UserUpdate OnCmdUserJoinedChannel
A user has joined a channel.
Definition: TeamTalk.cs:8406
CommandProcessing OnCmdProcessing
A command issued by Do* methods is being processed.
Definition: TeamTalk.cs:8293
HotKeyTest OnHotKeyTest
A button was pressed or released on the user's keyboard or mouse.
Definition: TeamTalk.cs:8643
delegate void NewAudioBlock(int nUserID, StreamType nStreamType)
Delegate for event OnUserAudioBlock.
Connection OnConnectionLost
Connection to server has been lost.
Definition: TeamTalk.cs:8256
DesktopTransferUpdate OnDesktopWindowTransfer
Used for tracking when a desktop window has been transmitted to the server.
Definition: TeamTalk.cs:8683
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:8309
MaxPayloadUpdate OnConnectionMaxPayloadUpdated
The maximum size of the payload put into UDP packets has been updated.
Definition: TeamTalk.cs:8272
delegate void StreamMediaFile(MediaFileInfo mediafileinfo)
Delegate for event OnStreamMediaFile.
UserUpdate OnCmdUserUpdate
User changed properties.
Definition: TeamTalk.cs:8400
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:8444
delegate void ErrorOccured(ClientErrorMsg clienterrormsg)
Delegate for event OnInternalError.
NewAudioBlock OnUserAudioBlock
A new audio block can be extracted.
Definition: TeamTalk.cs:8583
VoiceActivation OnVoiceActivation
Voice activation has triggered transmission.
Definition: TeamTalk.cs:8602
MyselfLoggedOut OnCmdMyselfLoggedOut
The client instance logged out of a server.
Definition: TeamTalk.cs:8351
MyselfLoggedIn OnCmdMyselfLoggedIn
The client instance successfully logged on to server.
Definition: TeamTalk.cs:8340
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:8619
delegate void MyselfKicked(User user)
Delegate for event OnCmdMyselfKicked.
LocalMediaFile OnLocalMediaFile
Media file is being played locally.
Definition: TeamTalk.cs:8701
delegate void MaxPayloadUpdate(int nPayloadSize)
Delegate for event OnConnectionMaxPayloadUpdated().
UserTextMessage OnCmdUserTextMessage
A user has sent a text-message.
Definition: TeamTalk.cs:8425
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:8710
Connection OnConnectionSuccess
Connected successfully to the server.
Definition: TeamTalk.cs:8240
UserUpdate OnCmdUserLoggedOut
A user logged out of the server.
Definition: TeamTalk.cs:8394
delegate void UserStreamUpdate(User user, int nStreamID)
Delegate for events OnUserFirstVoiceStreamPacket.
ErrorOccured OnInternalError
A internal error occured.
Definition: TeamTalk.cs:8592
CommandSuccess OnCmdSuccess
The server successfully processed a command issued by the local client instance.
Definition: TeamTalk.cs:8323
StreamMediaFile OnStreamMediaFile
Media file being streamed to a channel is processing.
Definition: TeamTalk.cs:8692
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:8364
UserVideoFrame OnUserMediaFileVideo
A new video frame was received from a user.
Definition: TeamTalk.cs:8523
UserVideoFrame OnUserVideoCapture
A new video frame was received from a user.
Definition: TeamTalk.cs:8517
ChannelUpdate OnCmdChannelNew
A new channel has been created.
Definition: TeamTalk.cs:8438
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:8490
UserStreamUpdate OnUserFirstVoiceStreamPacket
The first voice packet of a new voice stream has been received.
Definition: TeamTalk.cs:8503
FileUpdate OnCmdFileNew
A new file is added to a channel.
Definition: TeamTalk.cs:8477
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:8497
delegate void AudioInput(AudioInputProgress aip)
Delegate for event OnAudioInput.
ServerStats OnCmdServerStatistics
Server statistics available.
Definition: TeamTalk.cs:8468
UserUpdate OnUserStateChange
A user's state has been updated.
Definition: TeamTalk.cs:8508
delegate void ListBannedUser(BannedUser banneduser)
A delegate for event OnCmdUserAccount.
UserRecordMediaFile OnUserRecordMediaFile
An media file recording has changed status.
Definition: TeamTalk.cs:8569
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:3344
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:8543
UserUpdate OnCmdUserLoggedIn
A new user logged on to the server.
Definition: TeamTalk.cs:8384
FileUpdate OnCmdFileRemove
A file has been removed from a channel.
Definition: TeamTalk.cs:8483
ServerUpdate OnCmdServerUpdate
Server has updated its settings (server name, MOTD, etc.)
Definition: TeamTalk.cs:8459
UserUpdate OnCmdUserLeftChannel
User has left a channel.
Definition: TeamTalk.cs:8412
FileTransferUpdate OnFileTransfer
A file transfer is processing.
Definition: TeamTalk.cs:8661
Connection OnConnectionFailed
Failed to connect to server.
Definition: TeamTalk.cs:8248
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:8560
ChannelUpdate OnCmdChannelRemove
A channel has been removed. Event handler for ClientEvent.CLIENTEVENT_CMD_CHANNEL_REMOVE.
Definition: TeamTalk.cs:8449
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:8142
bool HotKey_GetKeyString(int nVKCode, ref string szKeyName)
Get a string description of the virtual-key code.
Definition: TeamTalk.cs:8202
int HotKey_IsActive(int nHotKeyID)
Check whether hotkey is active.
Definition: TeamTalk.cs:8160
bool HotKey_Unregister(int nHotKeyID)
Unregister a registered hotkey.
Definition: TeamTalk.cs:8151
bool HotKey_RemoveTestHook()
Remove the test hook again so the OnHotKeyTest event will no longer be notified.
Definition: TeamTalk.cs:8192
bool HotKey_InstallTestHook()
Install a test hook which calls the event OnHotKeyTest whenever a key or mouse button is pressed.
Definition: TeamTalk.cs:8173
bool GetMessage(ref TTMessage pMsg, int nWaitMs)
Poll for events in the client instance.
Definition: TeamTalk.cs:4422
const int TT_CHANNELID_MAX
The highest channel ID. Also used for TT_CLASSROOM_FREEFORALL.
Definition: TeamTalk.cs:4185
const int TT_LOCAL_USERID
User ID passed to TeamTalkBase.EnableAudioBlockEvent() in order to receive BearWare....
Definition: TeamTalk.cs:4241
BearWare.ClientFlag GetFlags()
Get a bitmask describing the client's current state.
Definition: TeamTalk.cs:4467
const int TT_MUXED_USERID
User ID used to identify muxed audio that has been mixed into a single stream.
Definition: TeamTalk.cs:4259
TeamTalkBase(bool poll_based)
Create a new TeamTalk client instance.
Definition: TeamTalk.cs:4306
ClientFlag
Flags used to describe the the client instance current state.
Definition: TeamTalk.cs:4068
bool PumpMessage(ClientEvent nClientEvent, int nIdentifier)
Cause client instance event thread to schedule an update event.
Definition: TeamTalk.cs:4453
const int TT_USERID_MAX
The highest user ID.
Definition: TeamTalk.cs:4181
const int TT_LOCAL_TX_USERID
User ID passed to TeamTalkBase.EnableAudioBlockEvent() in order to receive BearWare....
Definition: TeamTalk.cs:4250
void ProcessMsg(TTMessage msg)
Event handler for BearWare.TTMessage.
Definition: TeamTalk.cs:4498
static string GetVersion()
Get the DLL's version number.
Definition: TeamTalk.cs:4294
ClientFlag Flags
Same as GetFlags().
Definition: TeamTalk.cs:4476
static bool SetLicenseInformation(string szRegName, string szRegKey)
Set license information to disable trial mode.
Definition: TeamTalk.cs:4489
const int TT_STRLEN
The maximum length of all strings used in TeamTalkBase. This value includes the zero terminator,...
Definition: TeamTalk.cs:4178
@ 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:5981
bool StartStreamingMediaFileToChannel(string szMediaFilePath, VideoCodec lpVideoCodec)
Stream media file to channel, e.g. avi-, wav- or MP3-file.
Definition: TeamTalk.cs:5920
VideoFrame AcquireUserMediaVideoFrame(int nUserID, out Bitmap bmp)
Extract a user's media video frame for display.
Definition: TeamTalk.cs:6090
int InitLocalPlayback(string szMediaFilePath, MediaFilePlayback lpMediaFilePlayback)
Play media file using settings from TeamTalkBase instance.
Definition: TeamTalk.cs:6023
bool UpdateLocalPlayback(int nPlaybackSessionID, MediaFilePlayback lpMediaFilePlayback)
Definition: TeamTalk.cs:6039
bool StopLocalPlayback(int nPlaybackSessionID)
Definition: TeamTalk.cs:6053
bool StopStreamingMediaFileToChannel()
Stop streaming media file to channel.
Definition: TeamTalk.cs:5994
bool StartStreamingMediaFileToChannel(string szMediaFilePath, MediaFilePlayback lpMediaFilePlayback, VideoCodec lpVideoCodec)
Stream media file to channel, e.g. avi-, wav- or MP3-file.
Definition: TeamTalk.cs:5956
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:6065
bool ReleaseUserMediaVideoFrame(VideoFrame lpVideoFrame)
Delete a user's video frame, acquired through TeamTalkBase.AcquireUserMediaVideoFrame(),...
Definition: TeamTalk.cs:6112
const uint TT_MEDIAPLAYBACK_OFFSET_IGNORE
Definition: TeamTalk.cs:4290
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:8805
UserRight
The rights users have once they have logged on to the server.
Definition: TeamTalk.cs:1722
ServerLogEvent
Events that are logged by the server, i.e. written to server's log file.
Definition: TeamTalk.cs:1809
bool GetServerUsers(out User[] lpUsers)
Get all the users on the server.
Definition: TeamTalk.cs:7511
bool GetServerProperties(ref ServerProperties lpServerProperties)
Get the server's properties.
Definition: TeamTalk.cs:7497
BanType
Way to ban a user from either login or joining a channel.
Definition: TeamTalk.cs:2023
@ 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.
@ SERVERLOGEVENT_USER_MOVED
User was moved to another channel is logged to file by the server.
@ SERVERLOGEVENT_USER_LEFTCHANNEL
User left a channel is logged to file by the server.
@ SERVERLOGEVENT_USER_LOGGEDIN
User logged in is logged to file by the server.
@ SERVERLOGEVENT_USER_DISCONNECTED
User disconnected from server is logged to file by the server.
@ SERVERLOGEVENT_SERVER_SAVECONFIG
User saved server's configuration is logged to file by the server.
@ SERVERLOGEVENT_CHANNEL_REMOVED
User removed a channel is logged to file by the server.
@ SERVERLOGEVENT_FILE_DELETED
User deleted a file is logged to file by the server.
@ SERVERLOGEVENT_FILE_DOWNLOADED
User downloaded a file is logged to file by the server.
@ SERVERLOGEVENT_USER_KICKED
User was kicked is logged to file by the server.
@ SERVERLOGEVENT_USER_JOINEDCHANNEL
User joined a channel is logged to file by the server.
@ SERVERLOGEVENT_USER_TEXTMESSAGE_BROADCAST
User's broadcast text messages are logged to file by the server.
@ SERVERLOGEVENT_USER_TEXTMESSAGE_CHANNEL
User's channel text messages are logged to file by the server.
@ SERVERLOGEVENT_SERVER_UPDATED
User updated server's properties is logged to file by the server.
@ SERVERLOGEVENT_USER_CONNECTED
User's IP-address is logged to file by serer.
@ SERVERLOGEVENT_USER_TIMEDOUT
User disconnected due to connection timeout is logged to file by the server.
@ SERVERLOGEVENT_USER_LOGINFAILED
User failed to log in is logged to file by the server.
@ SERVERLOGEVENT_USER_LOGGEDOUT
User logged out is logged to file by the server.
@ SERVERLOGEVENT_NONE
Nothing is logged to file by server.
@ SERVERLOGEVENT_USER_TEXTMESSAGE_PRIVATE
User's private text messages are logged to file by the server.
@ SERVERLOGEVENT_CHANNEL_UPDATED
User updated a channel is logged to file by the server.
@ SERVERLOGEVENT_USER_BANNED
User was banned is logged to file by the server.
@ SERVERLOGEVENT_USER_UPDATED
User's status is logged to file by the server.
@ SERVERLOGEVENT_USER_UNBANNED
User was removed from ban list is logged to file by the server.
@ SERVERLOGEVENT_CHANNEL_CREATED
User created new channel is logged to file by the server.
@ SERVERLOGEVENT_FILE_UPLOADED
User uploaded a file is logged to file by the server.
@ SERVERLOGEVENT_USER_TEXTMESSAGE_CUSTOM
User's custom text messages are logged to file by the server.
@ 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:4750
bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars, AudioFileFormat uAFF)
Store user's audio to disk.
Definition: TeamTalk.cs:7947
bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars, AudioFileFormat uAFF, int nStopRecordingExtraDelayMSec)
Store user's audio to disk.
Definition: TeamTalk.cs:7977
bool Enable3DSoundPositioning(bool bEnable)
Enable automatically position users using 3D-sound.
Definition: TeamTalk.cs:5232
bool ReleaseUserAudioBlock(AudioBlock lpAudioBlock)
Release the shared memory of an BearWare.AudioBlock.
Definition: TeamTalk.cs:8056
bool SetSoundInputPreprocess(SpeexDSP lpSpeexDSP)
Enable sound preprocessor which should be used for processing audio recorded by the sound input devic...
Definition: TeamTalk.cs:5146
bool SetUserStereo(int nUserID, StreamType nStreamType, bool bLeftSpeaker, bool bRightSpeaker)
Set whether a user should speak in the left, right or both speakers. This function only works if Bear...
Definition: TeamTalk.cs:7908
bool EnableAudioBlockEvent(int nUserID, StreamType uStreamTypes, AudioFormat lpAudioFormat, bool bEnable)
Same as TeamTalkBase.EnableAudioBlockEvent() but option to specify audio output format.
Definition: TeamTalk.cs:5346
bool CloseSoundDuplexDevices()
Shut down sound devices running in duplex mode.
Definition: TeamTalk.cs:5030
bool AutoPositionUsers()
Automatically position users using 3D-sound.
Definition: TeamTalk.cs:5245
bool SetSoundOutputVolume(int nVolume)
Set master volume.
Definition: TeamTalk.cs:5197
bool GetSoundDeviceEffects(ref SoundDeviceEffects lpSoundDeviceEffect)
Get the audio effects that are currently enabled.
Definition: TeamTalk.cs:5077
int GetSoundInputLevel()
Get the volume level of the current recorded audio.
Definition: TeamTalk.cs:5097
bool SetUserPosition(int nUserID, StreamType nStreamType, float x, float y, float z)
Set the position of a user.
Definition: TeamTalk.cs:7892
bool SetUserStoppedPlaybackDelay(int nUserID, StreamType nStreamType, int nDelayMSec)
Set the delay of when a user should no longer be considered as playing audio (either voice or audio f...
Definition: TeamTalk.cs:7822
const int TT_SAMPLERATES_MAX
Definition: TeamTalk.cs:4274
bool SetUserAudioStreamBufferSize(int nUserID, StreamType uStreamType, int nMSec)
Change the amount of media data which can be buffered in the user's playback queue.
Definition: TeamTalk.cs:8007
static bool GetSoundDevices(out SoundDevice[] lpSoundDevices)
Retrieve list of sound devices for recording and playback.
Definition: TeamTalk.cs:4718
static bool GetDefaultSoundDevicesEx(SoundSystem nSndSystem, ref int lpnInputDeviceID, ref int lpnOutputDeviceID)
Get the default sound devices for the specified sound system.
Definition: TeamTalk.cs:4704
bool GetUserJitterControl(int nUserID, StreamType nStreamType, ref JitterConfig lpJitterConfig)
Get the de-jitter configuration for a user.
Definition: TeamTalk.cs:7870
bool GetSoundInputPreprocess(ref SpeexDSP lpSpeexDSP)
Get the sound preprocessor settings which are currently in use for recorded sound input device (voice...
Definition: TeamTalk.cs:5159
AudioBlock AcquireUserAudioBlock(StreamType uStreamTypes, int nUserID)
Extract the raw audio associated with the event TeamTalkBase.OnUserAudioBlock().
Definition: TeamTalk.cs:8031
bool SetSoundOutputMute(bool bMuteAll)
Set all users mute.
Definition: TeamTalk.cs:5218
bool InitSoundOutputSharedDevice(int nSampleRate, int nChannels, int nFrameSize)
Setup sample rate, channels and frame size of shared sound output device.
Definition: TeamTalk.cs:4938
bool InitSoundDuplexDevices(int nInputDeviceID, int nOutputDeviceID)
Enable duplex mode where multiple audio streams are mixed into a single stream using software.
Definition: TeamTalk.cs:4975
bool CloseSoundOutputDevice()
Shutdown the output sound device.
Definition: TeamTalk.cs:5020
bool InitSoundOutputDevice(int nOutputDeviceID)
Initialize the sound output device (for audio playback).
Definition: TeamTalk.cs:4904
int GetSoundInputGainLevel()
Get voice gain level of outgoing audio.
Definition: TeamTalk.cs:5126
static bool RestartSoundSystem()
Reinitialize sound system (in order to detect new/removed devices).
Definition: TeamTalk.cs:4742
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:7791
SoundDeviceFeature
Features available on a sound device. Checkout uSoundDeviceFeatures on BearWare.SoundDevice.
Definition: TeamTalk.cs:163
int GetSoundOutputVolume()
Get master volume.
Definition: TeamTalk.cs:5207
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:4789
bool SetSoundInputPreprocess(AudioPreprocessor lpAudioPreprocessor)
Enable sound preprocessor which should be used for processing audio recorded by the sound input devic...
Definition: TeamTalk.cs:5174
bool GetSoundInputPreprocess(ref AudioPreprocessor lpAudioPreprocessor)
Get the sound preprocessor settings which are currently in use for recorded sound input device (voice...
Definition: TeamTalk.cs:5186
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:5313
static bool GetDefaultSoundDevices(ref int lpnInputDeviceID, ref int lpnOutputDeviceID)
Get the default sound devices.
Definition: TeamTalk.cs:4695
bool SetUserJitterControl(int nUserID, StreamType nStreamType, JitterConfig lpJitterConfig)
Set the configuration for de-jitter measures for a user.
Definition: TeamTalk.cs:7853
static bool CloseSoundLoopbackTest(IntPtr lpTTSoundLoop)
Stop recorder and playback test.
Definition: TeamTalk.cs:4804
bool SetUserMute(int nUserID, StreamType nStreamType, bool bMute)
Mute a user.
Definition: TeamTalk.cs:7806
bool InitSoundInputDevice(int nInputDeviceID)
Initialize the sound input device (for recording audio).
Definition: TeamTalk.cs:4836
bool SetSoundInputGainLevel(int nLevel)
Set voice gaining of recorded audio.
Definition: TeamTalk.cs:5116
bool CloseSoundInputDevice()
Shutdown the input sound device.
Definition: TeamTalk.cs:4998
bool InitSoundInputSharedDevice(int nSampleRate, int nChannels, int nFrameSize)
Setup sample rate, channels and frame size of shared sound input device.
Definition: TeamTalk.cs:4871
bool SetSoundDeviceEffects(SoundDeviceEffects lpSoundDeviceEffect)
Set up audio effects on a sound device.
Definition: TeamTalk.cs:5069
@ 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:5542
int GetVoiceActivationLevel()
Get voice activation level.
Definition: TeamTalk.cs:5465
bool StopRecordingMuxedAudioFile(int nChannelID)
Stop recording conversations from a channel to a single file.
Definition: TeamTalk.cs:5643
bool StopVideoCaptureTransmission()
Stop transmitting from video capture device.
Definition: TeamTalk.cs:5679
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:5385
int GetVoiceActivationStopDelay()
Get the delay of when voice active state should be disabled.
Definition: TeamTalk.cs:5495
bool StopRecordingMuxedAudioFile()
Stop an active muxed audio recording.
Definition: TeamTalk.cs:5632
bool StartVideoCaptureTransmission(VideoCodec lpVideoCodec)
Start transmitting from video capture device.
Definition: TeamTalk.cs:5670
bool EnableVoiceTransmission(bool bEnable)
Start/stop transmitting of voice data from sound input.
Definition: TeamTalk.cs:5407
bool EnableVoiceActivation(bool bEnable)
Enable voice activation.
Definition: TeamTalk.cs:5437
bool StartRecordingMuxedAudioFile(int nChannelID, string szAudioFileName, AudioFileFormat uAFF)
Store audio conversations from a specific channel into a single file.
Definition: TeamTalk.cs:5571
bool SetVoiceActivationStopDelay(int nDelayMSec)
Set the delay of when voice activation should be stopped.
Definition: TeamTalk.cs:5481
bool StartRecordingMuxedStreams(StreamType uStreamTypes, AudioCodec lpAudioCodec, string szAudioFileName, AudioFileFormat uAFF)
Mix multiple BearWare.StreamType into a single audio file.
Definition: TeamTalk.cs:5613
bool SetVoiceActivationLevel(int nLevel)
Set voice activation level.
Definition: TeamTalk.cs:5455
@ 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:4265
bool GetUserStatistics(int nUserID, ref UserStatistics lpUserStatistics)
Get statistics for data and packet reception from a user.
Definition: TeamTalk.cs:7759
BearWare.UserRight GetMyUserRights()
Convenience method for TeamTalkBase.GetMyUserAccount()
Definition: TeamTalk.cs:7720
UserType
The types of users supported.
Definition: TeamTalk.cs:2067
int GetMyUserID()
Get the local client instance's user ID.
Definition: TeamTalk.cs:7669
bool GetMyUserAccount(ref UserAccount lpUserAccount)
Get the local client instance's BearWare.UserAccount.
Definition: TeamTalk.cs:7684
int UserID
Same as GetMyUserID().
Definition: TeamTalk.cs:7692
int UserData
Same as GetMyUserData().
Definition: TeamTalk.cs:7742
UserType GetMyUserType()
Get the client instance's user type.
Definition: TeamTalk.cs:7704
bool GetUser(int nUserID, ref User lpUser)
Get the user with the specified ID.
Definition: TeamTalk.cs:7750
bool GetUserByUsername(string szUsername, ref User lpUser)
Get the user with the specified username.
Definition: TeamTalk.cs:7771
Subscription
A user by default accepts audio, video and text messages from all users. Using subscribtions can,...
Definition: TeamTalk.cs:2182
UserState
The possible states for a user. Used for BearWare.User's uUserState variable.
Definition: TeamTalk.cs:2248
BearWare.UserRight UserRights
Same as GetMyUserRights().
Definition: TeamTalk.cs:7717
int GetMyUserData()
If an account was used in TeamTalkBase.DoLogin() then this value will return the nUserData from the B...
Definition: TeamTalk.cs:7734
TextMsgType
Text message types.
Definition: TeamTalk.cs:2475
@ 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:5750
bool InitVideoCaptureDevice(string szDeviceID, VideoFormat lpVideoFormat)
Initialize a video capture device.
Definition: TeamTalk.cs:5723
bool ReleaseUserVideoCaptureFrame(VideoFrame lpVideoFrame)
Delete a user's video frame, acquired through TeamTalkBase.AcquireUserVideoCaptureFrame(),...
Definition: TeamTalk.cs:5852
bool PaintVideoFrameEx(int nUserID, System.IntPtr hDC, int XDest, int YDest, int nDestWidth, int nDestHeight, int XSrc, int YSrc, int nSrcWidth, int nSrcHeight, ref VideoFrame lpVideoFrame)
Paint user's video frame using a Windows' DC (device context).
Definition: TeamTalk.cs:5793
VideoFrame AcquireUserVideoCaptureFrame(int nUserID, out Bitmap bmp)
Extract a user's video frame for display.
Definition: TeamTalk.cs:5828
static bool GetVideoCaptureDevices(out VideoCaptureDevice[] lpVideoDevices)
Get the list of devices available for video capture.
Definition: TeamTalk.cs:5695
bool CloseVideoCaptureDevice()
Close a video capture device.
Definition: TeamTalk.cs:5732
FourCC
The picture format used by a capture device.
Definition: TeamTalk.cs:597
const int TT_VIDEOFORMATS_MAX
Definition: TeamTalk.cs:4190
@ 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:2087
int nCommandsLimit
Limit number of commands a user can send to the server.
Definition: TeamTalk.cs:2097
int nCommandsIntervalMSec
Commands within given interval.
Definition: TeamTalk.cs:2099
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:1564
SpeexVBRCodec speex_vbr
Speex codec settings if nCodec is Codec.SPEEX_VBR_CODEC.
Definition: TeamTalk.cs:1576
SpeexCodec speex
Speex codec settings if nCodec is Codec.SPEEX_CODEC.
Definition: TeamTalk.cs:1572
Codec nCodec
Specifies whether the member speex, speex_vbr or opus holds the codec settings.
Definition: TeamTalk.cs:1568
OpusCodec opus
Opus codec settings if nCodec is OPUS_CODEC.
Definition: TeamTalk.cs:1580
Audio configuration for clients in a channel.
Definition: TeamTalk.cs:1598
AudioConfig(bool set_defaults)
Definition: TeamTalk.cs:1606
int nGainLevel
Reference gain level to be used by all users.
Definition: TeamTalk.cs:1604
bool bEnableAGC
Users should enable automatic gain control.
Definition: TeamTalk.cs:1601
Struct describing the audio format used by a media file.
Definition: TeamTalk.cs:577
AudioFileFormat nAudioFmt
The audio file format, e.g. wave or MP3.
Definition: TeamTalk.cs:579
int nSampleRate
Sample rate of media file.
Definition: TeamTalk.cs:581
int nChannels
Channels used by media file, mono = 1, stereo = 2.
Definition: TeamTalk.cs:583
The progress of the audio currently being processed as audio input.
Definition: TeamTalk.cs:1693
uint uElapsedMSec
The duration of the audio that has been transmitted.
Definition: TeamTalk.cs:1701
int nStreamID
The stream ID provided in the BearWare.AudioBlock.
Definition: TeamTalk.cs:1695
uint uQueueMSec
The duration of the audio currently queued for transmission.
Definition: TeamTalk.cs:1698
Configure the audio preprocessor specified by nPreprocessor.
Definition: TeamTalk.cs:1468
WebRTCAudioPreprocessor webrtc
Used when nPreprocessor is AudioPreprocessorType.WEBRTC_AUDIOPREPROCESSOR.
Definition: TeamTalk.cs:1480
SpeexDSP speexdsp
Used when nPreprocessor is AudioPreprocessorType.SPEEXDSP_AUDIOPREPROCESSOR.
Definition: TeamTalk.cs:1474
AudioPreprocessorType nPreprocessor
The audio preprocessor to use in the union of audio preprocessors.
Definition: TeamTalk.cs:1471
TTAudioPreprocessor ttpreprocessor
Used when nPreprocessor is AudioPreprocessorType.TEAMTALK_AUDIOPREPROCESSOR.
Definition: TeamTalk.cs:1477
A struct containing the properties of a banned user.
Definition: TeamTalk.cs:2042
string szIPAddress
IP-address of banned user.
Definition: TeamTalk.cs:2045
string szNickname
Nickname of banned user. Read-only property.
Definition: TeamTalk.cs:2054
string szChannelPath
Channel where user was located when banned.
Definition: TeamTalk.cs:2048
string szUsername
Username of banned user.
Definition: TeamTalk.cs:2057
BanType uBanTypes
The type of ban that applies to this banned user.
Definition: TeamTalk.cs:2059
string szBanTime
Date and time when user was banned. Read-only property.
Definition: TeamTalk.cs:2051
A struct containing the properties of a channel.
Definition: TeamTalk.cs:2579
int nTransmitUsersQueueDelayMSec
Delay for switching to next active voice user in transmitUsersQueue.
Definition: TeamTalk.cs:2690
int[] transmitUsersQueue
The users currently queued for voice or media file transmission.
Definition: TeamTalk.cs:2681
void AddTransmitUser(int nUserID, StreamType uStreamType)
Helper function for adding a user and BearWare.StreamType to transmitUsers.
Definition: TeamTalk.cs:2694
int GetTransmitUserCount()
Get the number of users who can currently transmit to the ChannelType.CHANNEL_CLASSROOM.
Definition: TeamTalk.cs:2721
AudioConfig audiocfg
The audio configuration which users who join the channel should use.
Definition: TeamTalk.cs:2618
void RemoveTransmitUser(int nUserID, StreamType uStreamType)
Helper function for removing a StreamType for a user in transmitUsers.
Definition: TeamTalk.cs:2732
bool bPassword
Whether password is required to join channel. Read-only property.
Definition: TeamTalk.cs:2599
string szPassword
Password to join the channel. When extracted through TeamTalkBase.GetChannel() the password will only...
Definition: TeamTalk.cs:2596
long nDiskQuota
Number of bytes available for file storage.
Definition: TeamTalk.cs:2607
int[] transmitUsers
List of users who can transmit in a channel.
Definition: TeamTalk.cs:2675
StreamType GetTransmitStreamTypes(int nUserID)
Helper function for getting the StreamType a user can transmit by querying transmitUsers.
Definition: TeamTalk.cs:2710
string szTopic
Topic of the channel.
Definition: TeamTalk.cs:2591
AudioCodec audiocodec
The audio codec used by users in the channel.
Definition: TeamTalk.cs:2615
int nUserData
User specific data which will be stored on persistent storage on the server if the channel type is Ch...
Definition: TeamTalk.cs:2605
string szOpPassword
Password to become channel operator.
Definition: TeamTalk.cs:2611
int nParentID
Parent channel ID. 0 means no parent channel, i.e. it's the root channel.
Definition: TeamTalk.cs:2582
int nChannelID
The channel's ID. A value from 1 - BearWare.TeamTalkBase.TT_CHANNELID_MAX.
Definition: TeamTalk.cs:2585
ChannelType uChannelType
A bitmask of the type of channel based on BearWare.ChannelType.
Definition: TeamTalk.cs:2601
int nMaxUsers
Max number of users in channel.
Definition: TeamTalk.cs:2613
string szName
Name of the channel.
Definition: TeamTalk.cs:2588
string szErrorMsg
Text message describing the error.
Definition: TeamTalk.cs:3331
int nErrorNo
Error number based on ClientError.
Definition: TeamTalk.cs:3328
Control timers for sending keep alive information to the server.
Definition: TeamTalk.cs:2890
int nUdpConnectTimeoutMSec
The duration before the client instance should give up trying to connect to the server on UDP....
Definition: TeamTalk.cs:2932
int nUdpKeepAliveRTXMSec
Client instance's interval for retransmitting UDP keep alive packets. If server hasn't responded to U...
Definition: TeamTalk.cs:2917
int nUdpConnectRTXMSec
Client instance's interval for retransmitting UDP connect packets. UDP connect packets are only sent ...
Definition: TeamTalk.cs:2924
int nTcpKeepAliveIntervalMSec
Client instance's interval between TeamTalkBase.DoPing() command. Read-only value....
Definition: TeamTalk.cs:2905
int nUdpKeepAliveIntervalMSec
Client instance's interval between sending UDP keep alive packets. The UDP keep alive packets are use...
Definition: TeamTalk.cs:2911
int nConnectionLostMSec
The duration before the TeamTalk instance should consider the client/server connection lost.
Definition: TeamTalk.cs:2901
Statistics of bandwidth usage and ping times in the local client instance.
Definition: TeamTalk.cs:2941
long nVoiceBytesRecv
Voice data received (on UDP).
Definition: TeamTalk.cs:2949
int nSoundInputDeviceDelayMSec
Delay of sound input device until the first audio frame is delivered (in msec).
Definition: TeamTalk.cs:2991
long nVideoCaptureBytesRecv
Video data received (on UDP).
Definition: TeamTalk.cs:2953
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:2973
int nUdpServerSilenceSec
The number of seconds nothing has been received by the client on UDP.
Definition: TeamTalk.cs:2979
long nMediaFileVideoBytesSent
Video from media file data sent (on UDP).
Definition: TeamTalk.cs:2959
long nMediaFileVideoBytesRecv
Video from media file data received (on UDP).
Definition: TeamTalk.cs:2961
long nMediaFileAudioBytesSent
Audio from media file data sent (on UDP).
Definition: TeamTalk.cs:2955
long nVoiceBytesSent
Voice data sent (on UDP).
Definition: TeamTalk.cs:2947
long nUdpBytesSent
Bytes sent on UDP.
Definition: TeamTalk.cs:2943
long nMediaFileAudioBytesRecv
Audio from media file data received (on UDP).
Definition: TeamTalk.cs:2957
long nVideoCaptureBytesSent
Video data sent (on UDP).
Definition: TeamTalk.cs:2951
int nTcpServerSilenceSec
The number of seconds nothing has been received by the client on TCP.
Definition: TeamTalk.cs:2976
long nUdpBytesRecv
Bytes received on UDP.
Definition: TeamTalk.cs:2945
long nDesktopBytesSent
Desktop data sent (on UDP).
Definition: TeamTalk.cs:2963
long nDesktopBytesRecv
Desktop data received (on UDP).
Definition: TeamTalk.cs:2965
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:2969
Constants for BearWare.DesktopInput.
Definition: TeamTalk.cs:847
A struct containing a mouse or keyboard event.
Definition: TeamTalk.cs:809
ushort uMousePosX
The X coordinate of the mouse. If used with WindowsHelper.Execute() and the mouse position should be ...
Definition: TeamTalk.cs:813
uint uKeyCode
The key-code (or mouse button) pressed. If used with TeamTalkBase.DesktopInput_Execute() and no key (...
Definition: TeamTalk.cs:823
DesktopInput(bool set_defaults)
When true initializes the desktop input to ignore mouse and key values.
Definition: TeamTalk.cs:828
ushort uMousePosY
The Y coordinate of the mouse. If used with TeamTalkBase.DesktopInput_Execute() and the mouse positio...
Definition: TeamTalk.cs:817
DesktopKeyState uKeyState
The state of the key (or mouse button) pressed, i.e. if it's up or down.
Definition: TeamTalk.cs:826
A struct containing the properties of a shared desktop window.
Definition: TeamTalk.cs:761
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:777
int nWidth
The width in pixels of the bitmap.
Definition: TeamTalk.cs:763
DesktopProtocol nProtocol
The desktop protocol used for transmitting the desktop window.
Definition: TeamTalk.cs:779
int nBytesPerLine
The number of bytes for each scan-line in the bitmap. Zero means 4-byte aligned.
Definition: TeamTalk.cs:770
IntPtr frameBuffer
A buffer pointing to the bitmap data (often refered to as Scan0).
Definition: TeamTalk.cs:781
int nFrameBufferSize
The size in bytes of the buffer allocate in frameBuffer. Typically nBytesPerLine * nHeight.
Definition: TeamTalk.cs:784
BitmapFormat bmpFormat
The format of the bitmap.
Definition: TeamTalk.cs:767
int nHeight
The height in pixels of the bitmap.
Definition: TeamTalk.cs:765
Configure peer verification for encrypted connection.
Definition: TeamTalk.cs:2832
string szCAFile
Path to Certificate Authority (CA) Certificate in PEM format.
Definition: TeamTalk.cs:2848
bool bVerifyClientOnce
Whether to only verify client's certificate once during initial connection.
Definition: TeamTalk.cs:2870
int nVerifyDepth
Set limit to depth in the certificate chain during the verification procedure.
Definition: TeamTalk.cs:2878
string szCertificateFile
Path to SSL certificate in PEM format.
Definition: TeamTalk.cs:2839
string szPrivateKeyFile
Path to certificate's private key.
Definition: TeamTalk.cs:2842
bool bVerifyPeer
Verify that peer (client or server) uses a certificate that has been generated by the Certificate Aut...
Definition: TeamTalk.cs:2859
string szCADir
Path to directory containing Certificate Authority (CA) Certificates in PEM format.
Definition: TeamTalk.cs:2852
A struct containing the properties of a file transfer.
Definition: TeamTalk.cs:2776
bool bInbound
TRUE if download and FALSE if upload.
Definition: TeamTalk.cs:2794
FileTransferStatus nStatus
Status of file transfer.
Definition: TeamTalk.cs:2778
string szRemoteFileName
The filename in the channel.
Definition: TeamTalk.cs:2788
string szLocalFilePath
The file path on local disk.
Definition: TeamTalk.cs:2785
long nTransferred
The number of bytes transferred so far.
Definition: TeamTalk.cs:2792
long nFileSize
The size of the file being transferred.
Definition: TeamTalk.cs:2790
int nTransferID
The ID identifying the file transfer.
Definition: TeamTalk.cs:2780
int nChannelID
The channel where the file is/will be located.
Definition: TeamTalk.cs:2782
Configuration parameters for the Jitter Buffer.
Definition: TeamTalk.cs:3001
int nMaxAdaptiveDelayMSec
A hard maximum delay on the adaptive delay. Only valid when higher than zero. Default = 0.
Definition: TeamTalk.cs:3008
int nActiveAdaptiveDelayMSec
The current adaptive delay. When used with TeamTalkBase.SetUserJitterControl(), this value is used as...
Definition: TeamTalk.cs:3015
bool bUseAdativeDejitter
Turns adaptive jitter buffering ON/OFF. Default is OFF.
Definition: TeamTalk.cs:3005
int nFixedDelayMSec
The fixed delay in milliseconds. Default = 0.
Definition: TeamTalk.cs:3003
Struct describing the audio and video format used by a media file.
Definition: TeamTalk.cs:1651
uint uElapsedMSec
The elapsed time of the media file in miliseconds.
Definition: TeamTalk.cs:1665
AudioFormat audioFmt
The audio properties of the media file.
Definition: TeamTalk.cs:1659
VideoFormat videoFmt
The video properties of the media file.
Definition: TeamTalk.cs:1661
string szFileName
Name of file.
Definition: TeamTalk.cs:1657
uint uDurationMSec
The duration of the media file in miliseconds.
Definition: TeamTalk.cs:1663
MediaFileStatus nStatus
Status of media file if it's being saved to disk.
Definition: TeamTalk.cs:1654
Properties for initializing or updating a file for media streaming.
Definition: TeamTalk.cs:1677
uint uOffsetMSec
Offset in milliseconds in the media file where to start playback. Pass BearWare.TeamTalkBase....
Definition: TeamTalk.cs:1682
AudioPreprocessor audioPreprocessor
Option to activate audio preprocessor on local media file playback.
Definition: TeamTalk.cs:1686
bool bPaused
Start or pause media file playback.
Definition: TeamTalk.cs:1684
OPUS audio codec settings. For detailed information about the OPUS codec check out http://www....
Definition: TeamTalk.cs:1038
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:1076
bool bFEC
Forward error correction. Corrects errors if there's packetloss.
Definition: TeamTalk.cs:1053
bool bVBR
Enable variable bitrate.
Definition: TeamTalk.cs:1062
int nComplexity
Complexity of encoding (affects CPU usage). Value from 0-10.
Definition: TeamTalk.cs:1050
bool bDTX
Discontinuous transmission. Enables "null" packets during silence.
Definition: TeamTalk.cs:1056
int nSampleRate
The sample rate to use. Sample rate must be 8000, 12000, 16000, 24000 or 48000 Hz.
Definition: TeamTalk.cs:1041
int nApplication
Application of encoded audio, VoIP or music.
Definition: TeamTalk.cs:1047
bool bVBRConstraint
Enable constrained VBR. bVBR must be enabled to enable this.
Definition: TeamTalk.cs:1065
int nTxIntervalMSec
Duration of audio before each transmission. Minimum is 2 msec. Recommended is 40 msec....
Definition: TeamTalk.cs:1072
int nBitRate
Bitrate for encoded audio. Should be between BearWare.OpusConstants.OPUS_MIN_BITRATE and BearWare....
Definition: TeamTalk.cs:1060
int nChannels
Mono = 1 or stereo = 2.
Definition: TeamTalk.cs:1043
OPUS constants for BearWare.OpusCodec.
Definition: TeamTalk.cs:1081
const bool DEFAULT_OPUS_FEC
Definition: TeamTalk.cs:1110
const int DEFAULT_OPUS_COMPLEXITY
Definition: TeamTalk.cs:1109
const bool DEFAULT_OPUS_VBR
Definition: TeamTalk.cs:1112
const bool DEFAULT_OPUS_VBRCONSTRAINT
Definition: TeamTalk.cs:1113
const int DEFAULT_OPUS_APPLICATION
Definition: TeamTalk.cs:1106
const int OPUS_MIN_FRAMESIZE
The minimum frame size for OPUS codec. Checkout nFrameSizeMSec of BearWare.OpusCodec.
Definition: TeamTalk.cs:1097
const int DEFAULT_OPUS_CHANNELS
Definition: TeamTalk.cs:1108
const bool DEFAULT_OPUS_DTX
Definition: TeamTalk.cs:1111
const int OPUS_MAX_BITRATE
The maximum bitrate for OPUS codec. Checkout nBitRate of BearWare.OpusCodec.
Definition: TeamTalk.cs:1093
const int DEFAULT_OPUS_DELAY
Definition: TeamTalk.cs:1115
const int OPUS_REALMAX_FRAMESIZE
The real maximum frame size for OPUS codec. Checkout nFrameSizeMSec of BearWare.OpusCodec....
Definition: TeamTalk.cs:1104
const int OPUS_MAX_FRAMESIZE
The maximum frame size for OPUS codec. Checkout nFrameSizeMSec of BearWare.OpusCodec.
Definition: TeamTalk.cs:1100
const int DEFAULT_OPUS_SAMPLERATE
Definition: TeamTalk.cs:1107
const int OPUS_APPLICATION_AUDIO
Audio encoding is for music. This value should be set as nApplicaton in BearWare.OpusCodec.
Definition: TeamTalk.cs:1087
const int OPUS_MIN_BITRATE
The minimum bitrate for OPUS codec. Checkout nBitRate of BearWare.OpusCodec.
Definition: TeamTalk.cs:1090
const int DEFAULT_OPUS_BITRATE
Definition: TeamTalk.cs:1114
const int OPUS_APPLICATION_VOIP
Audio encoding is for VoIP. This value should be set as nApplicaton in BearWare.OpusCodec.
Definition: TeamTalk.cs:1084
A struct containing the properties of a file in a BearWare.Channel.
Definition: TeamTalk.cs:2802
int nChannelID
The ID of the channel where the file is located.
Definition: TeamTalk.cs:2804
long nFileSize
The size of the file.
Definition: TeamTalk.cs:2811
string szUploadTime
Time when file was uploaded. Date/time is converted local time.
Definition: TeamTalk.cs:2818
string szFileName
The name of the file.
Definition: TeamTalk.cs:2809
int nFileID
The ID identifying the file.
Definition: TeamTalk.cs:2806
string szUsername
Username of the person who uploaded the files.
Definition: TeamTalk.cs:2814
A struct containing the properties of the server's settings.
Definition: TeamTalk.cs:1877
int nMaxMediaFileTxPerSecond
The maximum number of bytes per second which the server will allow for media file packets....
Definition: TeamTalk.cs:1916
int nUserTimeout
The number of seconds before a user who hasn't responded to keepalives will be kicked off the server.
Definition: TeamTalk.cs:1933
bool bAutoSave
Whether the server automatically saves changes.
Definition: TeamTalk.cs:1926
string szServerProtocolVersion
The version of the server's protocol.
Definition: TeamTalk.cs:1939
int nMaxLoginsPerIPAddress
The maximum number of users allowed to log in with the same IP-address. 0 means disabled.
Definition: TeamTalk.cs:1903
ServerLogEvent uServerLogEvents
The events that are logged on the server.
Definition: TeamTalk.cs:1959
string szAccessToken
A randomly generated 256 bit access token created by the server to identify the login session....
Definition: TeamTalk.cs:1953
int nMaxDesktopTxPerSecond
The maximum number of bytes per second which the server will allow for desktop packets....
Definition: TeamTalk.cs:1920
int nUdpPort
The server's UDP port.
Definition: TeamTalk.cs:1930
int nLoginDelayMSec
Number of msec before an IP-address can make another login attempt. If less than this amount then Tea...
Definition: TeamTalk.cs:1948
int nMaxTotalTxPerSecond
The amount of bytes per second which the server will allow for packet forwarding. If this value is ex...
Definition: TeamTalk.cs:1924
string szServerName
The server's name.
Definition: TeamTalk.cs:1880
int nMaxLoginAttempts
The maximum number of logins with wrong password before banning user's IP-address.
Definition: TeamTalk.cs:1900
string szMOTD
The message of the day. Read-only property. Use szMOTDRaw to update this property.
Definition: TeamTalk.cs:1884
string szMOTDRaw
The message of the day including variables. The result of the szMOTDRaw string will be displayed in s...
Definition: TeamTalk.cs:1894
int nMaxUsers
The maximum number of users allowed on the server. A user with admin account can ignore this.
Definition: TeamTalk.cs:1897
int nTcpPort
The server's TCP port.
Definition: TeamTalk.cs:1928
string szServerVersion
The server version.
Definition: TeamTalk.cs:1936
int nMaxVoiceTxPerSecond
The maximum number of bytes per second which the server will allow for voice packets....
Definition: TeamTalk.cs:1907
int nMaxVideoCaptureTxPerSecond
The maximum number of bytes per second which the server will allow for video input packets....
Definition: TeamTalk.cs:1912
A struct containing the server's statistics, i.e. bandwidth usage and user activity.
Definition: TeamTalk.cs:1971
long nMediaFileBytesTX
The number of bytes in media file packets sent from the server to clients.
Definition: TeamTalk.cs:1992
long nVideoCaptureBytesTX
The number of bytes in video packets sent from the server to clients.
Definition: TeamTalk.cs:1986
long nFilesRx
The number of bytes for file transmission received by the server.
Definition: TeamTalk.cs:2011
long nDesktopBytesTX
The number of bytes in desktop packets sent from the server to clients.
Definition: TeamTalk.cs:1998
long nFilesTx
The number of bytes for file transmission transmitted from the server.
Definition: TeamTalk.cs:2008
long nUptimeMSec
The server's uptime in msec.
Definition: TeamTalk.cs:2013
long nVoiceBytesRX
The number of bytes in audio packets received by the server from clients.
Definition: TeamTalk.cs:1983
int nUsersServed
The number of users who have logged on to the server.
Definition: TeamTalk.cs:2003
long nTotalBytesRX
The number of bytes received by the server from clients.
Definition: TeamTalk.cs:1977
long nTotalBytesTX
The number of bytes sent from the server to clients.
Definition: TeamTalk.cs:1974
long nVideoCaptureBytesRX
The number of bytes in video packets received by the server from clients.
Definition: TeamTalk.cs:1989
long nDesktopBytesRX
The number of bytes in desktop packets received by the server from clients.
Definition: TeamTalk.cs:2001
long nVoiceBytesTX
The number of bytes in audio packets sent from the server to clients.
Definition: TeamTalk.cs:1980
long nMediaFileBytesRX
The number of bytes in media file packets received by the server from clients.
Definition: TeamTalk.cs:1995
int nUsersPeak
The highest numbers of users online.
Definition: TeamTalk.cs:2005
A struct which describes the properties of a window which can be shared.
Definition: TeamTalk.cs:9156
IntPtr hWnd
The Windows handle of the window.
Definition: TeamTalk.cs:9158
string szWindowTitle
The title of the window.
Definition: TeamTalk.cs:9169
int nWndX
X coordinate of the window relative to the Windows desktop.
Definition: TeamTalk.cs:9160
int nHeight
The height in pixels of the window.
Definition: TeamTalk.cs:9166
int nWndY
Y coordinate of the window relative to the Windows desktop.
Definition: TeamTalk.cs:9162
int nWidth
The width in pixels of the window.
Definition: TeamTalk.cs:9164
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:905
int nQuality
A value from 1-10. As of DLL version 4.2 also 0 is supported.
Definition: TeamTalk.cs:913
int nTxIntervalMSec
Milliseconds of audio data before each transmission.
Definition: TeamTalk.cs:924
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:909
bool bStereoPlayback
Playback should be done in stereo. Doing so will disable 3d-positioning.
Definition: TeamTalk.cs:931
Speex constants for BearWare.SpeexCodec and BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:982
const int SPEEX_BANDMODE_UWIDE
Use BearWare.SpeexCodec or BearWare.SpeexVBRCodec as 32 KHz.
Definition: TeamTalk.cs:988
const bool DEFAULT_SPEEX_DTX
Default Speex DTX for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1031
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:998
const int SPEEX_QUALITY_MAX
The maximum quality for Speex codec.
Definition: TeamTalk.cs:992
const int SPEEX_QUALITY_MIN
The minimum quality for Speex codec.
Definition: TeamTalk.cs:990
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:1004
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:1001
const int DEFAULT_SPEEX_DELAY
Default Speex delay for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1019
const int SPEEX_BANDMODE_NARROW
Use BearWare.SpeexCodec or BearWare.SpeexVBRCodec as 8 KHz.
Definition: TeamTalk.cs:984
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:1007
const int DEFAULT_SPEEX_BITRATE
Default Speex bitrate for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1025
const int SPEEX_BANDMODE_WIDE
Use BearWare.SpeexCodec or BearWare.SpeexVBRCodec as 16 KHz.
Definition: TeamTalk.cs:986
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:1010
const int DEFAULT_SPEEX_MAXBITRATE
Default Speex max bitrate for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1028
const int DEFAULT_SPEEX_BANDMODE
Default Speex bandmode for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1013
const bool DEFAULT_SPEEX_SIMSTEREO
Default Speex stereo playback for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1022
const int DEFAULT_SPEEX_QUALITY
Default Speex quality for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1016
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:995
Default values for BearWare.SpeexDSP.
Definition: TeamTalk.cs:1485
const int DEFAULT_DENOISE_SUPPRESS
Definition: TeamTalk.cs:1492
const int DEFAULT_ECHO_SUPPRESS_ACTIVE
Definition: TeamTalk.cs:1495
const bool DEFAULT_AGC_ENABLE
Definition: TeamTalk.cs:1486
const int DEFAULT_ECHO_SUPPRESS
Definition: TeamTalk.cs:1494
const int DEFAULT_AGC_DEC_MAXDB
Definition: TeamTalk.cs:1489
const bool DEFAULT_ECHO_ENABLE
Definition: TeamTalk.cs:1493
const bool DEFAULT_DENOISE_ENABLE
Definition: TeamTalk.cs:1491
const int DEFAULT_AGC_INC_MAXDB
Definition: TeamTalk.cs:1488
const int DEFAULT_AGC_GAINMAXDB
Definition: TeamTalk.cs:1490
const int DEFAULT_AGC_GAINLEVEL
Definition: TeamTalk.cs:1487
Audio configuration specifying how recorded audio from sound input device should be preprocessed befo...
Definition: TeamTalk.cs:1137
SpeexDSP(bool set_defaults)
Definition: TeamTalk.cs:1207
int nMaxDecDBSec
Used so volume should not be attenuated too quickly (maximal gain decrease in dB/second)....
Definition: TeamTalk.cs:1161
bool bEnableDenoise
Whether clients who join the channel should automatically enable denoising.
Definition: TeamTalk.cs:1170
bool bEnableAGC
Whether clients who join a BearWare.Channel should enable AGC with the settings specified nGainLevel,...
Definition: TeamTalk.cs:1146
int nMaxIncDBSec
Used so volume should not be amplified too quickly (maximal gain increase in dB/second)....
Definition: TeamTalk.cs:1155
int nGainLevel
A value from 0 to 32768. Default is 8000. Value is ignored if bEnableAGC is FALSE.
Definition: TeamTalk.cs:1150
int nEchoSuppressActive
Set maximum attenuation of the residual echo in dB when near end is active (negative number)....
Definition: TeamTalk.cs:1205
int nEchoSuppress
Set maximum attenuation of the residual echo in dB (negative number). Default is -40....
Definition: TeamTalk.cs:1200
int nMaxGainDB
Ensure volume doesn't become too loud (maximal gain in dB). Default is 30. Value is ignored if bEnabl...
Definition: TeamTalk.cs:1166
bool bEnableEchoCancellation
Speex DSP is used for specifying how recorded audio from a sound input device should be preprocessed ...
Definition: TeamTalk.cs:1195
int nMaxNoiseSuppressDB
Maximum attenuation of the noise in dB. Negative value! Default value is -30. Value is ignored if bEn...
Definition: TeamTalk.cs:1175
Speex audio codec settings for Variable Bitrate mode (VBR).
Definition: TeamTalk.cs:941
int nTxIntervalMSec
Milliseconds of audio data before each transmission.
Definition: TeamTalk.cs:971
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:958
bool bDTX
Enable/disable discontinuous transmission. When enabled Speex will ignore silence,...
Definition: TeamTalk.cs:962
int nQuality
A value from 0-10. If nBitRate is non-zero it will override this value.
Definition: TeamTalk.cs:947
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:944
int nBitRate
The bitrate at which the audio codec should output encoded audio data. Dividing it by 8 gives roughly...
Definition: TeamTalk.cs:954
bool bStereoPlayback
Playback should be done in stereo. Doing so will disable 3d-positioning.
Definition: TeamTalk.cs:977
Use TeamTalk's internal audio preprocessor for gain audio. Same as used for TeamTalkBase....
Definition: TeamTalk.cs:1246
bool bMuteLeftSpeaker
Whether to mute left speaker in stereo playback.
Definition: TeamTalk.cs:1252
bool bMuteRightSpeaker
Whether to mute right speaker in stereo playback.
Definition: TeamTalk.cs:1254
int nGainLevel
Gain level between BearWare.SoundLevel.SOUND_GAIN_MIN and BearWare.SoundLevel.SOUND_GAIN_MAX....
Definition: TeamTalk.cs:1250
A struct containing the properties of an event.
Definition: TeamTalk.cs:3961
uint uReserved
Reserved. To preserve alignment.
Definition: TeamTalk.cs:3969
int nSource
The source of the event depends on wmMsg.
Definition: TeamTalk.cs:3965
ClientEvent nClientEvent
The event's message number.
Definition: TeamTalk.cs:3963
TTType ttType
Specifies which member to access in the union.
Definition: TeamTalk.cs:3967
object DataToObject()
Definition: TeamTalk.cs:3974
A struct containing the properties of a text message sent by a user.
Definition: TeamTalk.cs:2501
bool bMore
Whether this text message is to be merged with next text message.
Definition: TeamTalk.cs:2520
int nChannelID
Set to zero if nMsgType is TextMsgType TextMsgType.MSGTYPE_USER or TextMsgType TextMsgType....
Definition: TeamTalk.cs:2513
int nToUserID
Set to zero if channel message.
Definition: TeamTalk.cs:2510
string szMessage
The actual text message. The message can be multi-line (include EOL)
Definition: TeamTalk.cs:2517
int nFromUserID
Will be set automatically on outgoing message.
Definition: TeamTalk.cs:2505
string szFromUsername
The originators username.
Definition: TeamTalk.cs:2508
TextMsgType nMsgType
The type of text message.
Definition: TeamTalk.cs:2503
FileTransfer filetransfer
Definition: TeamTalk.cs:4026
ClientErrorMsg clienterrormsg
Definition: TeamTalk.cs:4020
DesktopInput desktopinput
Definition: TeamTalk.cs:4024
TextMessage textmessage
Definition: TeamTalk.cs:4034
ServerProperties serverproperties
Definition: TeamTalk.cs:4032
UserAccount useraccount
Definition: TeamTalk.cs:4038
MediaFileInfo mediafileinfo
Definition: TeamTalk.cs:4028
RemoteFile remotefile
Definition: TeamTalk.cs:4030
A struct containing the properties of a user account.
Definition: TeamTalk.cs:2112
string szNote
Additional notes about this user.
Definition: TeamTalk.cs:2131
int nUserData
A user data field which can be used for additional information. The nUserData field of the BearWare....
Definition: TeamTalk.cs:2128
string szInitChannel
User should (manually) join this channel after login. If an initial channel is specified in the user'...
Definition: TeamTalk.cs:2137
UserType uUserType
A bitmask of the type of user based on UserType.
Definition: TeamTalk.cs:2120
string szPassword
The account's password.
Definition: TeamTalk.cs:2118
UserRight uUserRights
A bitmask based on UserRight which specifies the rights the user have who logs onto the server....
Definition: TeamTalk.cs:2124
string szLastModified
Timestamp of last modification of user account. Date/time is converted local time.
Definition: TeamTalk.cs:2155
int[] autoOperatorChannels
Channels where this user will automatically become channel operator when joining. The channels must b...
Definition: TeamTalk.cs:2142
AbusePrevention abusePrevent
Properties which can be set to prevent abuse of a server, e.g. limit number of commands issued.
Definition: TeamTalk.cs:2151
string szUsername
The account's username.
Definition: TeamTalk.cs:2115
int nAudioCodecBpsLimit
Bandwidth restriction for audio codecs created by this user. This value will hold the highest bitrate...
Definition: TeamTalk.cs:2146
A struct containing the properties of a user.
Definition: TeamTalk.cs:2293
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:2369
int nStoppedDelayMediaFile
The delay of when a user should no longer be considered playing audio of a media file.
Definition: TeamTalk.cs:2383
int nChannelID
The channel which the user is currently participating in. 0 if none. This value can change as a resul...
Definition: TeamTalk.cs:2327
string szStatusMsg
The user's current status message. Invoke TeamTalkBase.DoChangeStatus() to change this value....
Definition: TeamTalk.cs:2356
int nActiveAdaptiveDelayMSec
The currently active adaptive jitter delay for received voice streams for this user.
Definition: TeamTalk.cs:2419
string szUsername
The szUsername of the user's BearWare.UserAccount. A user account is created by calling TeamTalkBase....
Definition: TeamTalk.cs:2303
int nStoppedDelayVoice
The delay of when a user should no longer be considered as talking.
Definition: TeamTalk.cs:2379
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:2375
bool[] stereoPlaybackMediaFile
Check what speaker a user is outputting to. If index 0 is TRUE then left speaker is playing....
Definition: TeamTalk.cs:2407
Subscription uPeerSubscriptions
A bitmask of what this user subscribes to from local client instance. Invoking TeamTalkBase....
Definition: TeamTalk.cs:2339
string szIPAddress
The user's IP-address. This value is set by the server.
Definition: TeamTalk.cs:2315
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:2297
string szMediaStorageDir
Store audio received from this user to this folder.
Definition: TeamTalk.cs:2363
uint uVersion
The user's client version. This property is set by the server and will not change after login....
Definition: TeamTalk.cs:2321
string szClientName
The name of the client application which the user is using. This is the value passed as szClientName ...
Definition: TeamTalk.cs:2424
int nBufferMSecVoice
The size of the buffer (in msec) to hold voice content.
Definition: TeamTalk.cs:2411
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:2389
UserState uUserState
A bitmask of the user's current state, e.g. talking, muted, etc.
Definition: TeamTalk.cs:2359
UserType uUserType
The uUserType of the user's BearWare.UserAccount. This property is set by the server and will not cha...
Definition: TeamTalk.cs:2312
int nStatusMode
The user's current status mode. Invoke TeamTalkBase.DoChangeStatus() to change this value....
Definition: TeamTalk.cs:2350
string szNickname
The user's nickname. Invoking TeamTalkBase.DoChangeNickname() changes this value. Event ClientEvent....
Definition: TeamTalk.cs:2345
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:2395
bool[] stereoPlaybackVoice
Check what speaker a user is outputting to. If index 0 is TRUE then left speaker is playing....
Definition: TeamTalk.cs:2401
int nUserData
The nUserData of the user's BearWare.UserAccount. This field can be use to denote e....
Definition: TeamTalk.cs:2308
Subscription uLocalSubscriptions
A bitmask of what the local user subscribes to from this user. Invoking TeamTalkBase....
Definition: TeamTalk.cs:2333
int nBufferMSecMediaFile
The size of the buffer (in msec) to hold media file content.
Definition: TeamTalk.cs:2415
Packet reception and data statistics for a user.
Definition: TeamTalk.cs:2433
long nMediaFileVideoPacketsRecv
Number of media file video packets received from user. A video frame can consist of several video pac...
Definition: TeamTalk.cs:2455
long nVoicePacketsLost
Number of voice packets lost from user.
Definition: TeamTalk.cs:2437
long nMediaFileAudioPacketsLost
Number of media file audio packets lost from user.
Definition: TeamTalk.cs:2452
long nVideoCaptureFramesLost
Video frames which couldn't be shown because packets were lost.
Definition: TeamTalk.cs:2445
long nMediaFileVideoFramesLost
Media file video frames which couldn't be shown because packets were lost.
Definition: TeamTalk.cs:2460
long nMediaFileVideoFramesDropped
Number of media file video frames dropped because user application didn't retrieve video frames in ti...
Definition: TeamTalk.cs:2463
long nVideoCaptureFramesDropped
Number of video frames dropped because user application didn't retrieve video frames in time.
Definition: TeamTalk.cs:2448
long nVideoCaptureFramesRecv
Number of video frames received from user.
Definition: TeamTalk.cs:2442
long nMediaFileVideoFramesRecv
Number of media file video frames received from user.
Definition: TeamTalk.cs:2457
long nVoicePacketsRecv
Number of voice packets received from user.
Definition: TeamTalk.cs:2435
long nMediaFileAudioPacketsRecv
Number of media file audio packets received from user.
Definition: TeamTalk.cs:2450
long nVideoCapturePacketsRecv
Number of video packets received from user. A video frame can consist of several video packets.
Definition: TeamTalk.cs:2440
A struct containing the properties of a video capture device.
Definition: TeamTalk.cs:683
string szCaptureAPI
The name of the API used to capture video.
Definition: TeamTalk.cs:703
int nVideoFormatsCount
The number of capture formats available in captureFormats array.
Definition: TeamTalk.cs:709
VideoFormat[] videoFormats
The supported capture formats.
Definition: TeamTalk.cs:706
string szDeviceID
A string identifying the device.
Definition: TeamTalk.cs:686
string szDeviceName
The name of the capture device.
Definition: TeamTalk.cs:689
Struct used for specifying the video codec to use.
Definition: TeamTalk.cs:1630
Codec nCodec
Specifies member holds the codec settings. So far there is only one video codec to choose from,...
Definition: TeamTalk.cs:1635
WebMVP8Codec webm_vp8
Definition: TeamTalk.cs:1637
A struct containing the properties of a video capture format.
Definition: TeamTalk.cs:619
int nFPS_Denominator
The denominator of the video capture device's video format. Divinding nFPS_Numerator with nFPS_Denomi...
Definition: TeamTalk.cs:633
FourCC picFourCC
Picture format for capturing.
Definition: TeamTalk.cs:635
int nHeight
The height in pixels of the video device supported video format.
Definition: TeamTalk.cs:625
int nFPS_Numerator
The numerator of the video capture device's video format. Divinding nFPS_Numerator with nFPS_Denomina...
Definition: TeamTalk.cs:629
int nWidth
The width in pixels of the video device supported video format.
Definition: TeamTalk.cs:622
A RGB32 image where the pixels can be accessed directly in an allocated imageBuffer.
Definition: TeamTalk.cs:647
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:664
int nFrameBufferSize
The size in bytes of the buffer allocate in frameBuffer.
Definition: TeamTalk.cs:669
int nHeight
The height in pixels of the image contained in imageBuffer.
Definition: TeamTalk.cs:653
int nStreamID
A unique identifier for the frames which are part of the same video sequence. If the stream ID change...
Definition: TeamTalk.cs:659
System.IntPtr frameBuffer
A buffer allocated internally by TeamTalkBase.
Definition: TeamTalk.cs:666
int nWidth
The width in pixels of the image contained in frameBuffer.
Definition: TeamTalk.cs:650
const int WEBM_VPX_DL_BEST_QUALITY
nEncodeDeadline value for best encoding.
Definition: TeamTalk.cs:1536
const int WEBM_VPX_DL_REALTIME
nEncodeDeadline value for fastest encoding.
Definition: TeamTalk.cs:1530
const int WEBM_VPX_DL_GOOD_QUALITY
nEncodeDeadline value for good encoding.
Definition: TeamTalk.cs:1533
WebM video codec settings.
Definition: TeamTalk.cs:1504
int nRcTargetBitrate
Same as rc_target_bitrate.
Definition: TeamTalk.cs:1507
uint nEncodeDeadline
Time that should be spent on encoding a frame.
Definition: TeamTalk.cs:1523
int rc_target_bitrate
Target bitrate in kbits/sec. This value must be greater than 0.
Definition: TeamTalk.cs:1514
Configuration of WebRTC's echo canceller. See also TT_SetSoundDeviceEffects()
Definition: TeamTalk.cs:1285
bool bEnable
Enable WebRTC echo canceller. The WebRTC echo canceller requires sound input and output devices are i...
Definition: TeamTalk.cs:1291
Gain level for AGC. Only active when bEnable is true.
Definition: TeamTalk.cs:1337
float fGainDB
Gain level in dB. Range: 0 <= x < 50. Default: 0.
Definition: TeamTalk.cs:1340
Configuration of WebRTC's gain controller 2 for AGC.
Definition: TeamTalk.cs:1329
bool bEnable
Enable WebRTC's fixed digital gain. WebRTC's automatic gain control (AGC)
Definition: TeamTalk.cs:1332
Configuration of WebRTC's level estimater.
Definition: TeamTalk.cs:1367
bool bEnable
Enable level estimater. When enabled TeamTalkBase.GetSoundInputLevel() will return a value based on W...
Definition: TeamTalk.cs:1373
Configuration of WebRTC's noise suppression. See also BearWare.SpeexDSP.
Definition: TeamTalk.cs:1299
int nLevel
Noise suppression level. 0 = Low, 1 = Moderate, 2 = High, 3 = VeryHigh. Default: 1.
Definition: TeamTalk.cs:1304
bool bEnable
Enable WebRTC noise suppression.
Definition: TeamTalk.cs:1301
Configuration of WebRTC pre-amplifier.
Definition: TeamTalk.cs:1272
bool bEnable
Enable pre-amplifier. Replacement for TT_SetSoundInputGainLevel()
Definition: TeamTalk.cs:1275
float fFixedGainFactor
Gain factor. Default: 1.
Definition: TeamTalk.cs:1277
Configuration of WebRTC's voice detection.
Definition: TeamTalk.cs:1311
bool bEnable
Use WebRTC's voice detection to trigger BearWare.TeamTalkBase.OnVoiceActivation.
Definition: TeamTalk.cs:1321
WebRTC's audio preprocessor.
Definition: TeamTalk.cs:1268
GainController2 gaincontroller2
Definition: TeamTalk.cs:1362
WebRTCAudioPreprocessor(bool set_defaults)
Definition: TeamTalk.cs:1377
NoiseSuppression noisesuppression
Definition: TeamTalk.cs:1306
LevelEstimation levelestimation
Definition: TeamTalk.cs:1375
Default values for BearWare.WebRTCAudioPreprocessor.
Definition: TeamTalk.cs:1430
const float DEFAULT_WEBRTC_EXTRA_SAT_MARGIN_DB
Definition: TeamTalk.cs:1439
const float DEFAULT_WEBRTC_MAXGAIN_DBSEC
Definition: TeamTalk.cs:1440
const float DEFAULT_WEBRTC_PREAMPLIFIER_GAINFACTOR
Definition: TeamTalk.cs:1432
const bool DEFAULT_WEBRTC_NOISESUPPRESS_ENABLE
Definition: TeamTalk.cs:1442
const bool DEFAULT_WEBRTC_VAD_ENABLE
Definition: TeamTalk.cs:1433
const bool DEFAULT_WEBRTC_PREAMPLIFIER_ENABLE
Definition: TeamTalk.cs:1431
const bool DEFAULT_WEBRTC_SAT_PROT_ENABLE
Definition: TeamTalk.cs:1437
const bool DEFAULT_WEBRTC_GAINCTL_ENABLE
Definition: TeamTalk.cs:1435
const float WEBRTC_GAINCONTROLLER2_FIXEDGAIN_MAX
Definition: TeamTalk.cs:1445
const float DEFAULT_WEBRTC_GAINDB
Definition: TeamTalk.cs:1436
const bool DEFAULT_WEBRTC_ECHO_CANCEL_ENABLE
Definition: TeamTalk.cs:1444
const bool DEFAULT_WEBRTC_LEVELESTIMATION_ENABLE
Definition: TeamTalk.cs:1434
const float DEFAULT_WEBRTC_INIT_SAT_MARGIN_DB
Definition: TeamTalk.cs:1438
const float DEFAULT_WEBRTC_MAX_OUT_NOISE
Definition: TeamTalk.cs:1441
const int DEFAULT_WEBRTC_NOISESUPPRESS_LEVEL
Definition: TeamTalk.cs:1443