sansenhoshi/ts-mobile-go
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 8 Wiki Activity
Files
53f286e407a46cd959ce03262ac678abbb218a7c
ts-mobile-go/docs/teamspeak-sdk-3.5.2/samples/source/client/main.c
T

1625 lines
60 KiB
C
Raw Normal View History

首次推送
2026-07-20 19:01:03 +08:00
/*
* TeamSpeak SDK client sample
*
* Copyright (c) TeamSpeak Systems GmbH
*/
#ifdef _WIN32
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable : 4996)
#include <Windows.h>
#include <conio.h>
#else
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <teamspeak/public_definitions.h>
#include <teamspeak/public_errors.h>
#include <teamspeak/clientlib.h>
#define DEFAULT_VIRTUAL_SERVER 1
#define NAME_BUFSIZE 1024
#define CHANNEL_PASSWORD_BUFSIZE 1024
#define CHECK_ERROR(x) if((error = x) != ERROR_ok) { goto on_error; }
#define IDENTITY_BUFSIZE 1024
#ifdef _WIN32
#define snprintf sprintf_s
#define SLEEP(x) Sleep(x)
#else
#define SLEEP(x) usleep(x*1000)
#endif
/* This is a global variable to indicate if sound needs to be recorded.
Normally one would have thread synchronization with locks etc. for
thread safety. In the intterest of simplicity, this sample uses the
most simple way to safely record, using this variable
*/
int recordSound = 0;
/* For voice activation detection demo */
uint64 vadTestscHandlerID;
int vadTestTalkStatus = 0;
/* Enable to use custom encryption */
/* #define USE_CUSTOM_ENCRYPTION
#define CUSTOM_CRYPT_KEY 123 */
/* Uncomment "#define CUSTOM_PASSWORDS" to try custom passwords.
* Please note that you have to do the same on the server demo too */
/* #define CUSTOM_PASSWORDS */
/* a struct used for sound recording */
struct WaveHeader {
/* Riff chunk */
char riffId[4];
unsigned int len;
char riffType[4];
/* Format chunk */
char fmtId[4]; // 'fmt '
unsigned int fmtLen;
unsigned short formatTag;
unsigned short channels;
unsigned int samplesPerSec;
unsigned int avgBytesPerSec;
unsigned short blockAlign;
unsigned short bitsPerSample;
/* Data chunk */
char dataId[4]; // 'data'
unsigned int dataLen;
};
/*
* Callback for connection status change.
* Connection status switches through the states STATUS_DISCONNECTED, STATUS_CONNECTING, STATUS_CONNECTED and STATUS_CONNECTION_ESTABLISHED.
*
* Parameters:
* serverConnectionHandlerID - Server connection handler ID
* newStatus - New connection status, see the enum ConnectStatus in clientlib_publicdefinitions.h
* errorNumber - Error code. Should be zero when connecting or actively disconnection.
* Contains error state when losing connection.
*/
void onConnectStatusChangeEvent(uint64 serverConnectionHandlerID, int newStatus, unsigned int errorNumber) {
printf("Connect status changed: %llu %d %d\n", (unsigned long long)serverConnectionHandlerID, newStatus, errorNumber);
/* Failed to connect ? */
if(newStatus == STATUS_DISCONNECTED && errorNumber == ERROR_failed_connection_initialisation) {
printf("Looks like there is no server running.\n");
}
}
/*
* Callback for current channels being announced to the client after connecting to a server.
*
* Parameters:
* serverConnectionHandlerID - Server connection handler ID
* channelID - ID of the announced channel
* channelParentID - ID of the parent channel
*/
void onNewChannelEvent(uint64 serverConnectionHandlerID, uint64 channelID, uint64 channelParentID) {
/* Query channel name from channel ID */
char* name;
unsigned int error;
printf("onNewChannelEvent: %llu %llu %llu\n", (unsigned long long)serverConnectionHandlerID, (unsigned long long)channelID, (unsigned long long)channelParentID);
if((error = ts3client_getChannelVariableAsString(serverConnectionHandlerID, channelID, CHANNEL_NAME, &name)) == ERROR_ok) {
printf("New channel: %llu %s \n", (unsigned long long)channelID, name);
ts3client_freeMemory(name); /* Release dynamically allocated memory only if function succeeded */
} else {
char* errormsg;
if(ts3client_getErrorMessage(error, &errormsg) == ERROR_ok) {
printf("Error getting channel name in onNewChannelEvent: %s\n", errormsg);
ts3client_freeMemory(errormsg);
}
}
}
/*
* Callback for just created channels.
*
* Parameters:
* serverConnectionHandlerID - Server connection handler ID
* channelID - ID of the announced channel
* channelParentID - ID of the parent channel
* invokerID - ID of the client who created the channel
* invokerName - Name of the client who created the channel
*/
void onNewChannelCreatedEvent(uint64 serverConnectionHandlerID, uint64 channelID, uint64 channelParentID, anyID invokerID, const char* invokerName, const char* invokerUniqueIdentifier) {
char* name;
/* Query channel name from channel ID */
if(ts3client_getChannelVariableAsString(serverConnectionHandlerID, channelID, CHANNEL_NAME, &name) != ERROR_ok)
return;
printf("New channel created: %s \n", name);
ts3client_freeMemory(name); /* Release dynamically allocated memory only if function succeeded */
}
/*
* Callback when a channel was deleted.
*
* Parameters:
* serverConnectionHandlerID - Server connection handler ID
* channelID - ID of the deleted channel
* invokerID - ID of the client who deleted the channel
* invokerName - Name of the client who deleted the channel
*/
void onDelChannelEvent(uint64 serverConnectionHandlerID, uint64 channelID, anyID invokerID, const char* invokerName, const char* invokerUniqueIdentifier) {
printf("Channel ID %llu deleted by %s (%u)\n", (unsigned long long)channelID, invokerName, invokerID);
}
/*
* Called when a client joins, leaves or moves to another channel.
*
* Parameters:
* serverConnectionHandlerID - Server connection handler ID
* clientID - ID of the moved client
* oldChannelID - ID of the old channel left by the client
* newChannelID - ID of the new channel joined by the client
* visibility - Visibility of the moved client. See the enum Visibility in clientlib_publicdefinitions.h
* Values: ENTER_VISIBILITY, RETAIN_VISIBILITY, LEAVE_VISIBILITY
*/
void onClientMoveEvent(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility, const char* moveMessage) {
printf("ClientID %u moves from channel %llu to %llu with message %s\n", clientID, (unsigned long long)oldChannelID, (unsigned long long)newChannelID, moveMessage);
}
/*
* Callback for other clients in current and subscribed channels being announced to the client.
*
* Parameters:
* serverConnectionHandlerID - Server connection handler ID
* clientID - ID of the announced client
* oldChannelID - ID of the subscribed channel where the client left visibility
* newChannelID - ID of the subscribed channel where the client entered visibility
* visibility - Visibility of the announced client. See the enum Visibility in clientlib_publicdefinitions.h
* Values: ENTER_VISIBILITY, RETAIN_VISIBILITY, LEAVE_VISIBILITY
*/
void onClientMoveSubscriptionEvent(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility) {
char* name;
/* Query client nickname from ID */
if(ts3client_getClientVariableAsString(serverConnectionHandlerID, clientID, CLIENT_NICKNAME, &name) != ERROR_ok)
return;
printf("New client: %s \n", name);
ts3client_freeMemory(name); /* Release dynamically allocated memory only if function succeeded */
}
/*
* Called when a client drops his connection.
*
* Parameters:
* serverConnectionHandlerID - Server connection handler ID
* clientID - ID of the moved client
* oldChannelID - ID of the channel the leaving client was previously member of
* newChannelID - 0, as client is leaving
* visibility - Always LEAVE_VISIBILITY
* timeoutMessage - Optional message giving the reason for the timeout
*/
void onClientMoveTimeoutEvent(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility, const char* timeoutMessage) {
printf("ClientID %u timeouts with message %s\n", clientID, timeoutMessage);
}
/*
* This event is called when a client starts or stops talking.
*
* Parameters:
* serverConnectionHandlerID - Server connection handler ID
* status - 1 if client starts talking, 0 if client stops talking
* isReceivedWhisper - 1 if this event was caused by whispering, 0 if caused by normal talking
* clientID - ID of the client who announced the talk status change
*/
void onTalkStatusChangeEvent(uint64 serverConnectionHandlerID, int status, int isReceivedWhisper, anyID clientID) {
char* name;
/* If we are currently in configure-microphone mode, remember the status and use it later in the loop in configureMicrophone() */
if(serverConnectionHandlerID == vadTestscHandlerID) {
vadTestTalkStatus = status;
return;
}
/* Query client nickname from ID */
if (ts3client_getClientVariableAsString(serverConnectionHandlerID, clientID, CLIENT_NICKNAME, &name) != ERROR_ok)
{
if (status == STATUS_TALKING) {
printf("Client \"%u\" starts talking.\n", clientID);
}
else {
printf("Client \"%u\" stops talking.\n", clientID);
}
return;
}
if(status == STATUS_TALKING) {
printf("Client \"%s\" starts talking.\n", name);
} else {
printf("Client \"%s\" stops talking.\n", name);
}
ts3client_freeMemory(name); /* Release dynamically allocated memory only if function succeeded */
}
/*
* This event is called when another client starts whispering to own client. Own client can decide to accept or deny
* receiving the whisper by adding the sending client to the whisper allow list. If not added, whispering is blocked.
*
* Parameters:
* serverConnectionHandlerID - Server connection handler ID
* clientID - ID of the whispering client
*/
void onIgnoredWhisperEvent(uint64 serverConnectionHandlerID, anyID clientID) {
unsigned int error;
/* Add sending client to whisper allow list so own client will hear the voice data.
* It is sufficient to add a clientID only once, not everytime this event is called. However it won't
* hurt to add the same clientID to the allow list repeatedly, but is is not necessary. */
if((error = ts3client_allowWhispersFrom(serverConnectionHandlerID, clientID)) != ERROR_ok) {
printf("Error setting client on whisper allow list: %u\n", error);
}
printf("Added client %d to whisper allow list\n", clientID);
}
void onServerErrorEvent(uint64 serverConnectionHandlerID, const char* errorMessage, unsigned int error, const char* returnCode, const char* extraMessage) {
printf("Error for server %llu: %s (%u) %s\n", (unsigned long long)serverConnectionHandlerID, errorMessage, error, extraMessage);
}
/*
* Callback for user-defined logging.
*
* Parameter:
* logMessage - Log message text
* logLevel - Severity of log message
* logChannel - Custom text to categorize the message channel
* logID - Virtual server ID giving the virtual server source of the log event
* logTime - String with the date and time the log entry occured
* completeLogString - Verbose log message including all previous parameters for convinience
*/
void onUserLoggingMessageEvent(const char* logMessage, int logLevel, const char* logChannel, uint64 logID, const char* logTime, const char* completeLogString) {
/* Your custom error display here... */
/* printf("LOG: %s\n", completeLogString); */
if(logLevel == LogLevel_CRITICAL) {
exit(1); /* Your custom handling of critical errors */
}
}
/*
* Callback allowing to apply custom encryption to outgoing packets.
* Using this function is optional. Do not implement if you want to handle the TeamSpeak SDK encryption.
*
* Parameters:
* dataToSend - Pointer to an array with the outgoing data to be encrypted
* sizeOfData - Pointer to an integer value containing the size of the data array
*
* Apply your custom encryption to the data array. If the encrypted data is smaller than sizeOfData, write
* your encrypted data into the existing memory of dataToSend. If your encrypted data is larger, you need
* to allocate memory and redirect the pointer dataToSend. You need to take care of freeing your own allocated
* memory yourself. The memory allocated by the SDK, to which dataToSend is originally pointing to, must not
* be freed.
*
*/
void onCustomPacketEncryptEvent(char** dataToSend, unsigned int* sizeOfData) {
#ifdef USE_CUSTOM_ENCRYPTION
unsigned int i;
for(i = 0; i < *sizeOfData; i++) {
(*dataToSend)[i] ^= CUSTOM_CRYPT_KEY;
}
#endif
}
/*
* Callback allowing to apply custom encryption to incoming packets
* Using this function is optional. Do not implement if you want to handle the TeamSpeak SDK encryption.
*
* Parameters:
* dataToSend - Pointer to an array with the received data to be decrypted
* sizeOfData - Pointer to an integer value containing the size of the data array
*
* Apply your custom decryption to the data array. If the decrypted data is smaller than dataReceivedSize, write
* your decrypted data into the existing memory of dataReceived. If your decrypted data is larger, you need
* to allocate memory and redirect the pointer dataReceived. You need to take care of freeing your own allocated
* memory yourself. The memory allocated by the SDK, to which dataReceived is originally pointing to, must not
* be freed.
*/
void onCustomPacketDecryptEvent(char** dataReceived, unsigned int* dataReceivedSize) {
#ifdef USE_CUSTOM_ENCRYPTION
unsigned int i;
for(i = 0; i < *dataReceivedSize; i++) {
(*dataReceived)[i] ^= CUSTOM_CRYPT_KEY;
}
#endif
}
/*
* Callback allowing access to voice data after it has been mixed by TeamSpeak
* This event can be used to alter/add to the voice data being played by TeamSpeak.
* But here we use it to record the voice data to a wave file.
*
* Parameters:
* serverConnectionHandlerID - Server connection handler ID
* samples - Pointer to a buffer containg 16 bit voice data samples at 48000 Hz. Channels are interleaved.
* sampleCount - The number of samples 1 channel of sample data contains.
* channels - The number of channels the sample data contains.
* channelSpeakerArray - A bitmask of the speakers for each channel.
* channelFillMask - A bitmask of channels that actually have valid data.
*
* -The size of the data "samples" points to is: sizeof(short)*sampleCount*channels
* -channelSpeakerArray uses SPEAKER_ defined in public_definitions.h
* -In the interrest of optimizations, a channel only contains data, if there is sound data for it. For example:
* in 5.1 or 7.1 we (almost) never have data for the subwoofer. Teamspeak then leaves the data in this channel
* undefined. This is more efficient for mixing.
* This implementation will record sound to a 2 channel (stereo) wave file. This sample assumes there is only
* 1 connection to a server
* Hint: Normally you would want to defer the writing to an other thread because this callback is very time sensitive
*/
void onEditMixedPlaybackVoiceDataEvent(uint64 serverConnectionHandlerID, short* samples, int sampleCount, int channels, const unsigned int* channelSpeakerArray, unsigned int* channelFillMask){
#define OUTPUTCHANNELS 2
static FILE *pfile = NULL;
static struct WaveHeader header = { {'R','I','F','F'}, 0, {'W','A','V','E'}, {'f','m','t',' '}, 16, 1, 2, 48000, 48000*(16/2)*2, (16/2)*2, 16, {'d','a','t','a'}, 0 };
int currentSampleMix[OUTPUTCHANNELS]; /*a per channel/sample mix buffer*/
int channelCount[OUTPUTCHANNELS] = {0,0}; /*how many input channels does the output channel contain */
int currentInChannel;
int currentOutChannel;
int currentSample;
/*for clipping*/
short shortval;
int intval;
short* outputBuffer;
int leftChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_CENTER | SPEAKER_BACK_LEFT | SPEAKER_FRONT_LEFT_OF_CENTER | SPEAKER_BACK_CENTER | SPEAKER_SIDE_LEFT | SPEAKER_TOP_CENTER | SPEAKER_TOP_FRONT_LEFT | SPEAKER_TOP_FRONT_CENTER | SPEAKER_TOP_BACK_LEFT | SPEAKER_TOP_BACK_CENTER;
int rightChannelMask = SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_BACK_RIGHT | SPEAKER_FRONT_RIGHT_OF_CENTER | SPEAKER_BACK_CENTER | SPEAKER_SIDE_RIGHT | SPEAKER_TOP_CENTER | SPEAKER_TOP_FRONT_RIGHT | SPEAKER_TOP_FRONT_CENTER | SPEAKER_TOP_BACK_RIGHT | SPEAKER_TOP_BACK_CENTER;
/*detect state changes*/
if (recordSound && (pfile == NULL)){
/*start recording*/
header.len = 0;
header.dataLen = 0;
if((pfile = fopen("recordedvoices.wav", "wb")) == NULL) return;
fwrite(&header, sizeof(struct WaveHeader), 1, pfile);
} else if (!recordSound && (pfile != NULL)){
/*stop recording*/
header.len = sizeof(struct WaveHeader)+header.dataLen - 8;
fseek (pfile, 0, SEEK_SET);
fwrite(&header, sizeof(struct WaveHeader), 1, pfile);
fclose(pfile);
pfile = NULL;
}
/*if there is nothing to do, quit*/
if (pfile == NULL || sampleCount == 0 || channels == 0) return;
/* initialize channel mixing */
currentInChannel = 0;
/*loop over all possible speakers*/
for (currentInChannel=0; currentInChannel < channels; ++currentInChannel) {
/*if the speaker has actual data*/
if ((*channelFillMask & (1<<currentInChannel)) != 0){
/*add to the outChannelSpeakerSet*/
if ((channelSpeakerArray[currentInChannel] & leftChannelMask) != 0) channelCount[0]++;
if ((channelSpeakerArray[currentInChannel] & rightChannelMask) != 0) channelCount[1]++;
}
}
/*get the outbut buffer*/
outputBuffer = (short*) malloc( sizeof(short)*sampleCount*2 /*output channels*/);
/* hint: if channelCount is 0 for all channels, we could write a zero buffer and quit here */
/*mix the samples*/
for (currentSample = 0; currentSample < sampleCount; currentSample++){
currentSampleMix[0] = currentSampleMix[1] = 0;
/*loop over all channels in this frame */
for(currentInChannel =0; currentInChannel < channels; currentInChannel++){
if ((channelSpeakerArray[currentInChannel] & leftChannelMask) != 0) currentSampleMix[0] += samples[ (currentSample*channels)+currentInChannel ];
if ((channelSpeakerArray[currentInChannel] & rightChannelMask) != 0) currentSampleMix[1] += samples[ (currentSample*channels)+currentInChannel ];
}
/*collected all samples, store mixed sample */
for (currentOutChannel = 0; currentOutChannel < OUTPUTCHANNELS; currentOutChannel++){
if (channelCount[currentOutChannel] == 0){
outputBuffer[ (currentSample*OUTPUTCHANNELS) + currentOutChannel] = 0;
} else {
/*clip*/
intval = currentSampleMix[currentOutChannel]/channelCount[currentOutChannel];
if (intval >= SHRT_MAX) shortval = SHRT_MAX;
else if (intval <= SHRT_MIN) shortval = SHRT_MIN;
else shortval = (short) intval;
/*store*/
outputBuffer[ (currentSample*OUTPUTCHANNELS) + currentOutChannel] = shortval;
}
}
}
/*write data & update header */
fwrite(outputBuffer, sampleCount*sizeof(short)*OUTPUTCHANNELS, 1, pfile);
header.dataLen += sampleCount*sizeof(short)*OUTPUTCHANNELS;
/*free buffer*/
free(outputBuffer);
}
#ifdef CUSTOM_PASSWORDS
/*
* Called to encrypt channel and server passwords
*
* In this example, we do not do any encryption. That way we have clear
* text passwords on the server.
*
* Parameters:
* serverConnectionHandlerID - Server connection handler ID.
* plaintext - the clear text password
* encryptedText - pointer to a buffer to store the encrypted password
* encryptedTextByteSize - the size of the encryptedText buffer
*/
void onClientPasswordEncrypt(uint64 serverConnectionHandlerID, const char* plaintext, char* encryptedText, int encryptedTextByteSize){
int pt_len;
printf("onClientPasswordEncrypt called\n");
pt_len = strlen(plaintext);
if (encryptedTextByteSize < pt_len-1) pt_len = encryptedTextByteSize-1;
memcpy(encryptedText, plaintext, pt_len);
encryptedText[pt_len]=0;
}
#endif
/*
* Optional event to further adjust 3D sound. Usually this is not needed, setting 3D position of own and other clients as shown
* setClient3DPosition is sufficient to configure 3D sound.
*/
void onCustom3dRolloffCalculationClientEvent(uint64 serverConnectionHandlerID, anyID clientID, float distance, float* volume)
{
printf("onCustom3dRolloffCalculationClientEvent: clientID=%hu distance=%f volume=%f\n", clientID, distance, *volume);
/* Volume can now be modified further to overwrite the value calculated by the SDK */
/* *volume *= 10.0f; */
}
/*
* Print all channels of the given virtual server
*/
void showChannels(uint64 serverConnectionHandlerID) {
uint64 *ids;
int i;
unsigned int error;
printf("\nList of channels on virtual server %llu:\n", (unsigned long long)serverConnectionHandlerID);
if((error = ts3client_getChannelList(serverConnectionHandlerID, &ids)) != ERROR_ok) { /* Get array of channel IDs */
printf("Error getting channel list: %d\n", error);
return;
}
if(!ids[0]) {
printf("No channels\n\n");
ts3client_freeMemory(ids);
return;
}
for(i=0; ids[i]; i++) {
char* name;
if((error = ts3client_getChannelVariableAsString(serverConnectionHandlerID, ids[i], CHANNEL_NAME, &name)) != ERROR_ok) { /* Query channel name */
printf("Error getting channel name: %d\n", error);
break;
}
printf("%llu - %s\n", (unsigned long long)ids[i], name);
ts3client_freeMemory(name);
}
printf("\n");
ts3client_freeMemory(ids); /* Release array */
}
/*
* Print all clients on the given virtual server in the specified channel
*/
void showChannelClients(uint64 serverConnectionHandlerID, uint64 channelID) {
anyID* ids;
anyID ownClientID;
int i;
unsigned int error;
printf("\nList of clients in channel %llu on virtual server %llu:\n", (unsigned long long)channelID, (unsigned long long)serverConnectionHandlerID);
if((error = ts3client_getChannelClientList(serverConnectionHandlerID, channelID, &ids)) != ERROR_ok) { /* Get array of client IDs */
printf("Error getting client list for channel %llu: %d\n", (unsigned long long)channelID, error);
return;
}
if(!ids[0]) {
printf("No clients\n\n");
ts3client_freeMemory(ids);
return;
}
/* Get own clientID as we need to call CLIENT_FLAG_TALKING with getClientSelfVariable for own client */
if((error = ts3client_getClientID(serverConnectionHandlerID, &ownClientID)) != ERROR_ok) {
printf("Error querying own client ID: %d\n", error);
return;
}
for(i=0; ids[i]; i++) {
char* name;
int talkStatus;
if((error = ts3client_getClientVariableAsString(serverConnectionHandlerID, ids[i], CLIENT_NICKNAME, &name)) != ERROR_ok) { /* Query client nickname... */
printf("Error querying client nickname: %d\n", error);
break;
}
if(ids[i] == ownClientID) { /* CLIENT_FLAG_TALKING must be queried with getClientSelfVariable for own client */
if((error = ts3client_getClientSelfVariableAsInt(serverConnectionHandlerID, CLIENT_FLAG_TALKING, &talkStatus)) != ERROR_ok) {
printf("Error querying own client talk status: %d\n", error);
break;
}
} else {
if((error = ts3client_getClientVariableAsInt(serverConnectionHandlerID, ids[i], CLIENT_FLAG_TALKING, &talkStatus)) != ERROR_ok) {
printf("Error querying client talk status: %d\n", error);
break;
}
}
printf("%u - %s (%stalking)\n", ids[i], name, (talkStatus == STATUS_TALKING ? "" : "not "));
ts3client_freeMemory(name);
}
printf("\n");
ts3client_freeMemory(ids); /* Release array */
}
/*
* Print all visible clients on the given virtual server
*/
void showClients(uint64 serverConnectionHandlerID) {
anyID *ids;
anyID ownClientID;
int i;
unsigned int error;
printf("\nList of all visible clients on virtual server %llu:\n", (unsigned long long)serverConnectionHandlerID);
if((error = ts3client_getClientList(serverConnectionHandlerID, &ids)) != ERROR_ok) { /* Get array of client IDs */
printf("Error getting client list: %d\n", error);
return;
}
if(!ids[0]) {
printf("No clients\n\n");
ts3client_freeMemory(ids);
return;
}
/* Get own clientID as we need to call CLIENT_FLAG_TALKING with getClientSelfVariable for own client */
if((error = ts3client_getClientID(serverConnectionHandlerID, &ownClientID)) != ERROR_ok) {
printf("Error querying own client ID: %d\n", error);
return;
}
for(i=0; ids[i]; i++) {
char* name;
int talkStatus;
if((error = ts3client_getClientVariableAsString(serverConnectionHandlerID, ids[i], CLIENT_NICKNAME, &name)) != ERROR_ok) { /* Query client nickname... */
printf("Error querying client nickname: %d\n", error);
break;
}
if(ids[i] == ownClientID) { /* CLIENT_FLAG_TALKING must be queried with getClientSelfVariable for own client */
if((error = ts3client_getClientSelfVariableAsInt(serverConnectionHandlerID, CLIENT_FLAG_TALKING, &talkStatus)) != ERROR_ok) {
printf("Error querying own client talk status: %d\n", error);
break;
}
} else {
if((error = ts3client_getClientVariableAsInt(serverConnectionHandlerID, ids[i], CLIENT_FLAG_TALKING, &talkStatus)) != ERROR_ok) {
printf("Error querying client talk status: %d\n", error);
break;
}
}
printf("%u - %s (%stalking)\n", ids[i], name, (talkStatus == STATUS_TALKING ? "" : "not "));
ts3client_freeMemory(name);
}
printf("\n");
ts3client_freeMemory(ids); /* Release array */
}
void emptyInputBuffer() {
int c;
while((c = getchar()) != '\n' && c != EOF);
}
uint64 enterChannelID() {
uint64 channelID;
int n;
printf("\nEnter channel ID: ");
n = scanf("%llu", (unsigned long long*)&channelID);
emptyInputBuffer();
if(n == 0) {
printf("Invalid input. Please enter a number.\n\n");
return 0;
}
return channelID;
}
void createDefaultChannelName(char *name) {
static int i = 1;
sprintf(name, "Channel_%d", i++);
}
void enterName(char *name) {
char *s;
printf("\nEnter name: ");
fgets(name, NAME_BUFSIZE, stdin);
s = strrchr(name, '\n');
if(s) {
*s = '\0';
}
}
void enterPassword(char *password) {
char *s;
printf("\nEnter password: ");
fgets(password, CHANNEL_PASSWORD_BUFSIZE, stdin);
s = strrchr(password, '\n');
if(s) {
*s = '\0';
}
}
void createChannel(uint64 serverConnectionHandlerID, const char *name, const char* password) {
unsigned int error;
/* Set data of new channel. Use channelID of 0 for creating channels. */
CHECK_ERROR(ts3client_setChannelVariableAsString(serverConnectionHandlerID, 0, CHANNEL_NAME, name));
CHECK_ERROR(ts3client_setChannelVariableAsString(serverConnectionHandlerID, 0, CHANNEL_TOPIC, "Test channel topic"));
CHECK_ERROR(ts3client_setChannelVariableAsString(serverConnectionHandlerID, 0, CHANNEL_DESCRIPTION, "Test channel description"));
CHECK_ERROR(ts3client_setChannelVariableAsInt (serverConnectionHandlerID, 0, CHANNEL_FLAG_PERMANENT, 1));
CHECK_ERROR(ts3client_setChannelVariableAsInt (serverConnectionHandlerID, 0, CHANNEL_FLAG_SEMI_PERMANENT, 0));
CHECK_ERROR(ts3client_setChannelVariableAsInt (serverConnectionHandlerID, 0, CHANNEL_CODEC_QUALITY, 10));
if(password && *password){
CHECK_ERROR(ts3client_setChannelVariableAsString(serverConnectionHandlerID, 0, CHANNEL_PASSWORD, password));
}
/* Flush changes to server */
CHECK_ERROR(ts3client_flushChannelCreation(serverConnectionHandlerID, 0, NULL));
printf("\nCreated channel\n\n");
return;
on_error:
printf("\nError creating channel: %d\n\n", error);
}
void deleteChannel(uint64 serverConnectionHandlerID) {
uint64 channelID;
unsigned int error;
/* Query channel ID from user */
channelID = enterChannelID();
/* Delete channel */
if((error = ts3client_requestChannelDelete(serverConnectionHandlerID, channelID, 0, NULL)) == ERROR_ok) {
printf("Deleted channel %llu\n\n", (unsigned long long)channelID);
} else {
char* errormsg;
if(ts3client_getErrorMessage(error, &errormsg) == ERROR_ok) {
printf("Error requesting channel delete: %s (%d)\n\n", errormsg, error);
ts3client_freeMemory(errormsg);
}
}
}
void renameChannel(uint64 serverConnectionHandlerID) {
uint64 channelID;
unsigned int error;
char name[NAME_BUFSIZE];
/* Query channel ID from user */
channelID = enterChannelID();
/* Query new channel name from user */
enterName(name);
/* Change channel name and flush changes */
CHECK_ERROR(ts3client_setChannelVariableAsString(serverConnectionHandlerID, channelID, CHANNEL_NAME, name));
CHECK_ERROR(ts3client_flushChannelUpdates(serverConnectionHandlerID, channelID, NULL));
printf("Renamed channel %llu\n\n", (unsigned long long)channelID);
return;
on_error:
printf("Error renaming channel: %d\n\n", error);
}
void switchChannel(uint64 serverConnectionHandlerID) {
unsigned int error;
char password[CHANNEL_PASSWORD_BUFSIZE];
#ifndef CUSTOM_PASSWORDS
int hasPassword;
#endif
/* Query channel ID from user */
uint64 channelID = enterChannelID();
/* Query own client ID */
anyID clientID;
if((error = ts3client_getClientID(serverConnectionHandlerID, &clientID)) != ERROR_ok) {
printf("Error querying own client ID: %d\n", error);
return;
}
#ifndef CUSTOM_PASSWORDS
/* Using standard password mechanism */
/* Check if channel has a password set */
if((error = ts3client_getChannelVariableAsInt(serverConnectionHandlerID, channelID, CHANNEL_FLAG_PASSWORD, &hasPassword)) != ERROR_ok) {
printf("Failed to get password flag: %d\n", error);
return;
}
/* Get channel password if channel is password protected */
if(hasPassword) {
enterPassword(password);
} else {
password[0] = '\0';
}
#else
/* Using custom password mechanism, always ask user for password */
enterPassword(password);
#endif
/* Request moving own client into given channel */
anyID ids_to_move[2];
ids_to_move[0] = clientID;
ids_to_move[1] = 0;
if((error = ts3client_requestClientMove(serverConnectionHandlerID, ids_to_move, channelID, password, NULL)) != ERROR_ok) {
printf("Error moving client into channel channel: %d\n", error);
return;
}
printf("Switching into channel %llu\n\n", (unsigned long long)channelID);
}
void setVadMode(uint64 serverConnectionHandlerID)
{
int vad_mode, n;
unsigned int error;
char s[100];
printf("Vad Mode:\n");
printf("0 - likelihood based (default)\n");
printf("1 - power based\n");
printf("2 - likelihood and power based\n\n");
printf("The Vad Level is tied to modes 2 and 3 - the modes using power.\n");
printf("\nEnter VAD mode: ");
n = scanf("%d", &vad_mode);
emptyInputBuffer();
if (n == 0) {
printf("Invalid input. Please enter a number in the range 0 - 2.\n\n");
return;
}
/* Adjust "vad_mode" preprocessor value */
snprintf(s, 100, "%d", vad_mode);
if ((error = ts3client_setPreProcessorConfigValue(serverConnectionHandlerID, "vad_mode", s)) != ERROR_ok) {
printf("Error setting VAD mode: %d\n", error);
return;
}
printf("\nSet VAD mode to %s.\n\n", s);
}
void toggleVAD(uint64 serverConnectionHandlerID) {
static short b = 0;
unsigned int error;
/* Adjust "vad" preprocessor value */
if((error = ts3client_setPreProcessorConfigValue(serverConnectionHandlerID, "vad", b ? "false" : "true")) != ERROR_ok) {
printf("Error toggling VAD: %d\n", error);
return;
}
b = !b;
printf("\nToggled VAD %s.\n\n", b ? "on" : "off");
}
void setVadLevel(uint64 serverConnectionHandlerID) {
int vad, n;
unsigned int error;
char s[100];
printf("\nEnter VAD level: ");
n = scanf("%d", &vad);
emptyInputBuffer();
if(n == 0) {
printf("Invalid input. Please enter a number.\n\n");
return;
}
/* Adjust "voiceactivation_level" preprocessor value */
snprintf(s, 100, "%d", vad);
if((error = ts3client_setPreProcessorConfigValue(serverConnectionHandlerID, "voiceactivation_level", s)) != ERROR_ok) {
printf("Error setting VAD level: %d\n", error);
return;
}
printf("\nSet VAD level to %s.\n\n", s);
}
void toggleDenoise(uint64 serverConnectionHandlerID) {
static short b = 1;
unsigned int error;
/* Adjust "vad" preprocessor value */
if ((error = ts3client_setPreProcessorConfigValue(serverConnectionHandlerID, "denoise", b ? "false" : "true")) != ERROR_ok) {
printf("Error toggling Denoiser: %d\n", error);
return;
}
b = !b;
printf("\nToggled Denoiser %s.\n\n", b ? "on" : "off");
}
void setDenoiserLevel(uint64 serverConnectionHandlerID) {
int denoiser_level, n;
unsigned int error;
char s[100];
printf("\nEnter Denoiser level: ");
n = scanf("%d", &denoiser_level);
emptyInputBuffer();
if (n == 0) {
printf("Invalid input. Please enter a number.\n\n");
return;
}
/* Adjust "voiceactivation_level" preprocessor value */
snprintf(s, 100, "%d", denoiser_level);
if ((error = ts3client_setPreProcessorConfigValue(serverConnectionHandlerID, "denoiser_level", s)) != ERROR_ok) {
printf("Error setting Denoiser level: %d\n", error);
return;
}
printf("\nSet Denoiser level to %s.\n\n", s);
}
void toggleTypingSuppression(uint64 serverConnectionHandlerID) {
static short b = 0;
unsigned int error;
/* Adjust "vad" preprocessor value */
if ((error = ts3client_setPreProcessorConfigValue(serverConnectionHandlerID, "typing_suppression", b ? "false" : "true")) != ERROR_ok) {
printf("Error toggling typing suppression: %d\n", error);
return;
}
b = !b;
printf("\nToggled typing suppression %s.\n\n", b ? "on" : "off");
}
void toggleAec(uint64 serverConnectionHandlerID)
{
static short b = 0;
unsigned int error;
/* Adjust "aec" preprocessor value */
if ((error = ts3client_setPreProcessorConfigValue(serverConnectionHandlerID, "aec", b ? "false" : "true")) != ERROR_ok) {
printf("Error toggling echo cancellation: %d\n", error);
return;
}
b = !b;
printf("\nToggled echo cancellation %s.\n\n", b ? "on" : "off");
}
void toggleAgc(uint64 serverConnectionHandlerID) {
static short b = 1;
unsigned int error;
/* Adjust "agc" preprocessor value */
if ((error = ts3client_setPlaybackConfigValue(serverConnectionHandlerID, "agc", b ? "false" : "true")) != ERROR_ok) {
printf("Error toggling Automatic Gain Control (AGC): %d\n", error);
return;
}
b = !b;
printf("\nToggled Automatic Gain Control (AGC) %s.\n\n", b ? "on" : "off");
}
void toggleEchoReductionDucking(uint64 serverConnectionHandlerID) {
int vad, n;
unsigned int error;
char s[100];
printf("\nEnter Ducking level (dB): ");
n = scanf("%d", &vad);
emptyInputBuffer();
if (n == 0) {
printf("Invalid input. Please enter a number.\n\n");
return;
}
/* Adjust "echo_reduction_ducking" preprocessor value */
snprintf(s, 100, "%d", vad);
if ((error = ts3client_setPlaybackConfigValue(serverConnectionHandlerID, "echo_reduction_ducking", s)) != ERROR_ok) {
printf("Error setting echo_reduction_ducking level: %d\n", error);
return;
}
printf("\nSet echo_reduction_ducking level to %s.\n\n", s);
}
void requestWhisperList(uint64 serverConnectionHandlerID) {
int n;
anyID clientID;
uint64 targetID;
unsigned int error;
uint64 targetChannels[2];
printf("\nEnter ID of the client whose whisper list should be modified (0 for own client): ");
n = scanf("%hu", &clientID);
emptyInputBuffer();
if(n == 0) {
printf("Invalid input. Please enter a number.\n\n");
return;
}
printf("\nEnter target channel ID: ");
n = scanf("%llu", (unsigned long long*)&targetID);
emptyInputBuffer();
if(n == 0) {
printf("Invalid input. Please enter a number.\n\n");
return;
}
targetChannels[0] = targetID;
targetChannels[1] = 0;
if((error = ts3client_requestClientSetWhisperList(serverConnectionHandlerID, clientID, targetChannels, NULL, NULL)) != ERROR_ok) {
char* errormsg;
if(ts3client_getErrorMessage(error, &errormsg) == ERROR_ok) {
printf("Error requesting whisperlist: %s\n", errormsg);
ts3client_freeMemory(errormsg);
}
return;
}
printf("Whisper list requested for client %d in channel %llu\n", clientID, (unsigned long long)targetID);
}
void requestClearWhisperList(uint64 serverConnectionHandlerID) {
int n;
anyID clientID;
unsigned int error;
printf("\nEnter ID of the client whose whisper list should be cleared (0 for own client): ");
n = scanf("%hu", &clientID);
emptyInputBuffer();
if(n == 0) {
printf("Invalid input. Please enter a number.\n\n");
return;
}
if((error = ts3client_requestClientSetWhisperList(serverConnectionHandlerID, clientID, NULL, NULL, NULL)) != ERROR_ok) {
char* errormsg;
if(ts3client_getErrorMessage(error, &errormsg) == ERROR_ok) {
printf("Error clearing whisperlist: %s\n", errormsg);
ts3client_freeMemory(errormsg);
}
return;
}
printf("Whisper list cleared for client %u\n", clientID);
}
void setClient3DPosition(uint64 serverConnectionHandlerID)
{
int i, n;
anyID clientID;
float pos[3];
TS3_VECTOR position = { 0 };
char* txt[] = { "x", "y", "z" };
/* Query ID of client whose 3D position we want to change */
printf("\nEnter ID of the client whose 3D position should be changed (0 for own client): ");
n = scanf("%hu", &clientID);
emptyInputBuffer();
if(n == 0)
{
printf("Invalid input. Please enter a number.\n\n");
return;
}
/* Query 3D position */
for(i = 0; i < 3; ++i)
{
printf("Enter %s coordinate: ", txt[i]);
n = scanf("%f", &pos[i]);
emptyInputBuffer();
if(n == 0)
{
printf("Invalid input. Please enter a number.\n\n");
return;
}
}
position.x = pos[0];
position.y = pos[1];
position.z = pos[2];
if(clientID == 0)
{
/* Own client */
TS3_VECTOR zero = { 0 };
unsigned int error = ts3client_systemset3DListenerAttributes(serverConnectionHandlerID, &position, &zero, &zero);
if(error != ERROR_ok)
{
printf("Failed to set 3D position for own client: %d\n", error);
return;
}
printf("Set 3D position for own client to %f, %f, %f\n", position.x, position.y, position.z);
}
else
{
/* Other client */
unsigned int error = ts3client_channelset3DAttributes(serverConnectionHandlerID, clientID, &position);
if(error != ERROR_ok)
{
printf("Failed to set 3D position for other client: %d\n", error);
return;
}
printf("Set 3D position for client %hu to %f, %f, %f\n", clientID, position.x, position.y, position.z);
}
}
int initLocalTestMode() {
unsigned int error;
/* spawn a new server connection handler used as local loopback device */
if((error = ts3client_spawnNewServerConnectionHandler(0, &vadTestscHandlerID)) != ERROR_ok) {
printf("Error spawning server connection handler: %d\n", error);
vadTestscHandlerID = 0;
return 1;
}
/* Open default capture device for the new server connection handler */
if((error = ts3client_openCaptureDevice(vadTestscHandlerID, "", "")) != ERROR_ok) {
printf("Error opening capture device: %d\n", error);
return 1;
}
/* Open default playback device for the new server connection handler */
if((error = ts3client_openPlaybackDevice(vadTestscHandlerID, "", "")) != ERROR_ok) {
printf("Error opening playback device: %d\n", error);
return 1;
}
/* Set the server connection handler as a local loopback device, so we can hear our own voice without connecting to a server. */
/* The original capture device for the current server is automatically deactivated. */
if((error = ts3client_setLocalTestMode(vadTestscHandlerID, 1)) != ERROR_ok){
printf("Error setting local test mode\n");
return 1;
}
return 0;
}
void destroyLocalTestMode(uint64 scHandlerID){
unsigned int error;
/* Close playback device */
if((ts3client_closePlaybackDevice(scHandlerID)) != ERROR_ok){
printf("Unable to close playback device\n");
}
/* Close capture device */
if((ts3client_closeCaptureDevice(scHandlerID)) != ERROR_ok) {
printf("Unable to close capture device\n");
}
/* Unset local test mode */
if((error = ts3client_setLocalTestMode(scHandlerID, 0)) != ERROR_ok) {
printf("Unable to stop local test mode\n");
}
/* Destroy schandlerid */
if((error = ts3client_destroyServerConnectionHandler(scHandlerID)) != ERROR_ok){
printf("Unable to destroy scHandler\n");
}
/* After closing the local loopback device, reactivate the microphone on our current server connection. */
if((error = ts3client_activateCaptureDevice(DEFAULT_VIRTUAL_SERVER)) != ERROR_ok){
printf("unable to reactivate capture device\n");
}
}
void printVadLevel() {
unsigned int error;
float result;
if((error = ts3client_getPreProcessorInfoValueFloat(vadTestscHandlerID, "decibel_last_period", &result)) != ERROR_ok) {
printf("Error getting vad level\n");
}
printf("%.2f - %s", result, (vadTestTalkStatus == STATUS_TALKING ? "talking" : "not talking"));
printf("\n");
}
/* Set the microphone voice activation detection level */
void configureMicrophone() {
unsigned int error;
int counter = 0;
/* Enable local loopback device */
if(initLocalTestMode() != 0) {
return;
}
/* Local loopback device is setup, now enter loop where the user can change the voice activation level while once per second the
* current volume level is printed. */
printf("\n**********************************\n");
printf("Entering configure microphone mode\n");
printf("[v] - set VAD level\n");
printf("[q] - quit microphone configuration\n\n");
for(;;) {
#ifdef _WIN32
if(_kbhit()) {
int c = _getche();
#else
{ int c = getc(stdin); // No kbhit on posix
#endif
switch(c) {
case 'v': {
int n;
float inputVadLevel;
char vad[128];
printf("Insert value to change voice activations level\n");
n = scanf("%f", &inputVadLevel);
emptyInputBuffer();
if(n == 0) {
printf("Invalid input. Please enter a number.\n\n");
continue;
}
sprintf(vad, "%f", inputVadLevel);
if((error = ts3client_setPreProcessorConfigValue(vadTestscHandlerID, "voiceactivation_level", vad)) != ERROR_ok) {
printf("unable to set vad value\n");
continue;
}
printf("new vad level: %s\n", vad);
continue;
}
case 'q':
destroyLocalTestMode(vadTestscHandlerID);
printf("\n**********************************\n");
printf("Left configure microphone mode\n\n");
vadTestscHandlerID = 0;
return;
}
}
#ifdef _WIN32 /* On Windows we print this once per second, on Unix only on each Return keyboard input due to lack of easy kbhit replacement on Unix */
if(++counter > 9)
#endif
{
printVadLevel();
counter = 0;
}
SLEEP(100);
}
}
void toggleRecordSound(uint64 serverConnectionHandlerID){
unsigned int error;
if (!recordSound){
recordSound = 1;
if((error = ts3client_startVoiceRecording(serverConnectionHandlerID)) != ERROR_ok){
char* errormsg;
if(ts3client_getErrorMessage(error, &errormsg) == ERROR_ok) {
printf("Error notifying server of startVoiceRecording: %s\n", errormsg);
ts3client_freeMemory(errormsg);
return;
}
}
printf("Started recording sound to wav\n");
} else {
recordSound = 0;
if((error = ts3client_stopVoiceRecording(serverConnectionHandlerID)) != ERROR_ok){
char* errormsg;
if(ts3client_getErrorMessage(error, &errormsg) == ERROR_ok) {
printf("Error notifying server of stopVoiceRecording: %s\n", errormsg);
ts3client_freeMemory(errormsg);
return;
}
}
printf("Stopped recording sound to wav\n");
}
}
unsigned int printMyConnectionInfo(uint64 serverConnectionHandlerID) {
anyID my_id;
unsigned int error = ts3client_getClientID(serverConnectionHandlerID, &my_id);
if (error != ERROR_ok) {
return error;
}
double pingResult;
if ((error = ts3client_getConnectionVariableAsDouble(serverConnectionHandlerID, my_id, CONNECTION_PING, &pingResult)) == ERROR_ok) {
double deviationResult;
if ((error = ts3client_getConnectionVariableAsDouble(serverConnectionHandlerID, my_id, CONNECTION_PING_DEVIATION, &deviationResult)) == ERROR_ok) {
printf("Ping: %f ms +/- %f\n", pingResult, deviationResult);
}
}
double loss;
if ((error = ts3client_getConnectionVariableAsDouble(serverConnectionHandlerID, my_id, CONNECTION_SERVER2CLIENT_PACKETLOSS_TOTAL, &loss)) == ERROR_ok) {
printf("Server to client packet loss (total): %f\n", loss);
}
return error;
}
int readIdentity(char* identity) {
FILE *file;
if((file = fopen("identity.txt", "r")) == NULL) {
printf("Could not open file 'identity.txt' for reading.\n");
return -1;
}
fgets(identity, IDENTITY_BUFSIZE, file);
if(ferror(file) != 0) {
fclose (file);
printf("Error reading identity from file 'identity.txt'.\n");
return -1;
}
fclose (file);
return 0;
}
int writeIdentity(const char* identity) {
FILE *file;
if((file = fopen("identity.txt", "w")) == NULL) {
printf("Could not open file 'identity.txt' for writing.\n");
return -1;
}
fputs(identity, file);
if(ferror(file) != 0) {
fclose (file);
printf("Error writing identity to file 'identity.txt'.\n");
return -1;
}
fclose (file);
return 0;
}
void showHelp() {
printf("\n[q] - Disconnect from server\n[h] - Show this help\n[c] - Show channels\n[s] - Switch to specified channel\n");
printf("[l] - Show all visible clients\n[L] - Show all clients in specific channel\n[n] - Create new channel with generated name\n[N] - Create new channel with custom name\n");
printf("[d] - Delete channel\n[r] - Rename channel\n[R] - Record sound to wav\n[v] - Toggle Voice Activity Detection / Continuous transmission \n[M] - Set Voice Activity Detection Mode\n[V] - Set Voice Activity Detection level\n");
printf("[b] - Toggle Denoiser\n[B] - Set Denoiser Level\n[t] - Toggle Typing Suppression\n[e] - Toggle Echo Reduction\n[a] - Toggle Echo Cancellation\n[A] - Toggle AGC\n");
printf("[w] - Set whisper list\n[W] - Clear whisper list\n[m] - Configure microphone\n[3] - Set 3D position of client\n[i] - Connection info\n\n");
}
char* programPath(char* programInvocation){
char* path;
char* end;
int length;
char pathsep;
if (programInvocation == NULL) return strdup("");
#ifdef _WIN32
pathsep = '\\';
#else
pathsep = '/';
#endif
end = strrchr(programInvocation, pathsep);
if (!end) return strdup("");
length = (end - programInvocation) + 2;
path = (char*)malloc(length);
strncpy(path, programInvocation, length - 1);
path[length - 1] = '\0';
return path;
}
struct ConnectInfo {
char* ip;
unsigned short port;
};
int main(int argc, char* argv[]) {
uint64 scHandlerID;
unsigned int error;
char* mode;
char** device;
char *version;
char identity[IDENTITY_BUFSIZE];
short abort = 0;
char* path;
/* Check for commandline parameters <ip> <port> */
struct ConnectInfo connect_info;
if (argc == 3) {
size_t sz = strlen(argv[1]) + 1;
connect_info.ip = (char*)malloc(sz * sizeof(char));
strcpy(connect_info.ip, argv[1]);
connect_info.ip[sz - 1] = '\0';
connect_info.port = atoi(argv[2]);
} else {
/* No commandline parameters given, use default ip "localhost" and port 9987 */
const char* default_ip = "localhost";
size_t sz = strlen(default_ip) + 1;
connect_info.ip = (char*)malloc(sz * sizeof(char));
strcpy(connect_info.ip, default_ip);
connect_info.port = 9987;
}
/* Create struct for callback function pointers */
struct ClientUIFunctions funcs;
/* Initialize all callbacks with NULL */
memset(&funcs, 0, sizeof(struct ClientUIFunctions));
/* Callback function pointers */
/* It is sufficient to only assign those callback functions you are using. When adding more callbacks, add those function pointers here. */
funcs.onConnectStatusChangeEvent = onConnectStatusChangeEvent;
funcs.onNewChannelEvent = onNewChannelEvent;
funcs.onNewChannelCreatedEvent = onNewChannelCreatedEvent;
funcs.onDelChannelEvent = onDelChannelEvent;
funcs.onClientMoveEvent = onClientMoveEvent;
funcs.onClientMoveSubscriptionEvent = onClientMoveSubscriptionEvent;
funcs.onClientMoveTimeoutEvent = onClientMoveTimeoutEvent;
funcs.onTalkStatusChangeEvent = onTalkStatusChangeEvent;
funcs.onIgnoredWhisperEvent = onIgnoredWhisperEvent;
funcs.onServerErrorEvent = onServerErrorEvent;
funcs.onUserLoggingMessageEvent = onUserLoggingMessageEvent;
funcs.onCustomPacketEncryptEvent = onCustomPacketEncryptEvent;
funcs.onCustomPacketDecryptEvent = onCustomPacketDecryptEvent;
funcs.onEditMixedPlaybackVoiceDataEvent = onEditMixedPlaybackVoiceDataEvent;
#ifdef CUSTOM_PASSWORDS
funcs.onClientPasswordEncrypt = onClientPasswordEncrypt;
#endif
funcs.onCustom3dRolloffCalculationClientEvent = onCustom3dRolloffCalculationClientEvent;
/* Initialize client lib with callbacks */
/* Resource path points to the SDK\bin directory to locate the soundbackends folder when running from Visual Studio. */
/* If you want to run directly from the SDK\bin directory, use an empty string instead to locate the soundbackends folder in the current directory. */
path = programPath(argv[0]);
error = ts3client_initClientLib(&funcs, NULL, LogType_FILE | LogType_CONSOLE | LogType_USERLOGGING, NULL, path);
free(path);
path = NULL;
if (error != ERROR_ok) {
char* errormsg;
if(ts3client_getErrorMessage(error, &errormsg) == ERROR_ok) {
printf("Error initializing clientlib: %s\n", errormsg);
ts3client_freeMemory(errormsg);
}
return 1;
}
/* Spawn a new server connection handler using the default port and store the server ID */
if((error = ts3client_spawnNewServerConnectionHandler(0, &scHandlerID)) != ERROR_ok) {
printf("Error spawning server connection handler: %d\n", error);
return 1;
}
/* Get default capture mode */
if((error = ts3client_getDefaultCaptureMode(&mode)) != ERROR_ok) {
printf("Error getting default capture mode: %d\n", error);
return 1;
}
printf("Default capture mode: %s\n", mode);
/* Get default capture device */
if((error = ts3client_getDefaultCaptureDevice(mode, &device)) != ERROR_ok) {
printf("Error getting default capture device: %d\n", error);
return 1;
}
printf("Default capture device: %s %s\n", device[0], device[1]);
/* Open default capture device */
/* Instead of passing mode and device[1], it would also be possible to pass empty strings to open the default device */
if((error = ts3client_openCaptureDevice(scHandlerID, mode, device[1])) != ERROR_ok) {
printf("Error opening capture device: %d\n", error);
}
/* Adjust "vad" preprocessor value to use vad by default */
if ((error = ts3client_setPreProcessorConfigValue(scHandlerID, "vad", "true")) != ERROR_ok) {
printf("Error toggling VAD: %d\n", error);
return 1;
}
/* Adjust "vad_mode" value to use hybrid by default */
if ((error = ts3client_setPreProcessorConfigValue(scHandlerID, "vad_mode", "2")) != ERROR_ok) {
printf("Error setting vad_mode value to hybrid: %d\n", error);
return 1;
}
/* Adjust "voiceactivation_level" value */
if ((error = ts3client_setPreProcessorConfigValue(scHandlerID, "voiceactivation_level", "-20")) != ERROR_ok) {
printf("Error setting voiceactivation_level: %d\n", error);
return 1;
}
/* Get default playback mode */
if((error = ts3client_getDefaultPlayBackMode(&mode)) != ERROR_ok) {
printf("Error getting default playback mode: %d\n", error);
return 1;
}
printf("Default playback mode: %s\n", mode);
/* Get default playback device */
if((error = ts3client_getDefaultPlaybackDevice(mode, &device)) != ERROR_ok) {
printf("Error getting default playback device: %d\n", error);
return 1;
}
printf("Default playback device: %s %s\n", device[0], device[1]);
/* Open default playback device */
/* Instead of passing mode and device[1], it would also be possible to pass empty strings to open the default device */
if((error = ts3client_openPlaybackDevice(scHandlerID, mode, device[1])) != ERROR_ok) {
printf("Error opening playback device: %d\n", error);
}
/* Try reading identity from file, otherwise create new identity */
if(readIdentity(identity) != 0) {
char* id;
if((error = ts3client_createIdentity(&id)) != ERROR_ok) {
printf("Error creating identity: %d\n", error);
return 0;
}
if(strlen(id) >= IDENTITY_BUFSIZE) {
printf("Not enough bufsize for identity string\n");
return 0;
}
strcpy(identity, id);
ts3client_freeMemory(id);
writeIdentity(identity);
}
printf("Using identity: %s\n", identity);
printf("Connecting to %s:%d\n", connect_info.ip, connect_info.port);
/* Connect to server on localhost:9987 with nickname "client", no default channel, no default channel password and server password "secret" */
error = ts3client_startConnection(scHandlerID, identity, connect_info.ip, connect_info.port, "client", NULL, "", "secret");
free(connect_info.ip);
connect_info.ip = NULL;
if (error != ERROR_ok) {
printf("Error connecting to server: %d\n", error);
return 1;
}
printf("Client lib initialized and running\n");
/* Query and print client lib version */
if((error = ts3client_getClientLibVersion(&version)) != ERROR_ok) {
printf("Failed to get clientlib version: %d\n", error);
return 1;
}
printf("Client lib version: %s\n", version);
ts3client_freeMemory(version); /* Release dynamically allocated memory */
version = NULL;
SLEEP(300);
/* Simple commandline interface */
printf("\nTeamSpeak 3 client commandline interface\n");
showHelp();
while(!abort) {
int c = getc(stdin);
switch(c) {
case 'q':
printf("\nDisconnecting from server...\n");
abort = 1;
break;
case 'h':
showHelp();
break;
case 'c':
showChannels(DEFAULT_VIRTUAL_SERVER);
break;
case 'l':
showClients(DEFAULT_VIRTUAL_SERVER);
break;
case 'L':
{
uint64 channelID = enterChannelID();
if(channelID > 0)
showChannelClients(DEFAULT_VIRTUAL_SERVER, channelID);
break;
}
case 'n':
{
char name[NAME_BUFSIZE];
createDefaultChannelName(name);
createChannel(DEFAULT_VIRTUAL_SERVER, name, NULL);
break;
}
case 'N':
{
char name[NAME_BUFSIZE];
char password[CHANNEL_PASSWORD_BUFSIZE];
emptyInputBuffer();
enterName(name);
enterPassword(password);
createChannel(DEFAULT_VIRTUAL_SERVER, name, password);
break;
}
case 'd':
deleteChannel(DEFAULT_VIRTUAL_SERVER);
break;
case 'r':
renameChannel(DEFAULT_VIRTUAL_SERVER);
break;
case 'R':
toggleRecordSound(DEFAULT_VIRTUAL_SERVER);
break;
case 's':
switchChannel(DEFAULT_VIRTUAL_SERVER);
break;
case 'v':
toggleVAD(DEFAULT_VIRTUAL_SERVER);
break;
case 'V':
setVadLevel(DEFAULT_VIRTUAL_SERVER);
break;
case 'M':
setVadMode(DEFAULT_VIRTUAL_SERVER);
break;
case 'b':
toggleDenoise(DEFAULT_VIRTUAL_SERVER);
break;
case 'B':
setDenoiserLevel(DEFAULT_VIRTUAL_SERVER);
break;
case 't':
toggleTypingSuppression(DEFAULT_VIRTUAL_SERVER);
break;
case 'e':
toggleEchoReductionDucking(DEFAULT_VIRTUAL_SERVER);
break;
case 'a':
toggleAec(DEFAULT_VIRTUAL_SERVER);
break;
case 'A':
toggleAgc(DEFAULT_VIRTUAL_SERVER);
break;
case 'w':
requestWhisperList(DEFAULT_VIRTUAL_SERVER);
break;
case 'W':
requestClearWhisperList(DEFAULT_VIRTUAL_SERVER);
break;
case 'm':
configureMicrophone();
showHelp(); /* Display main menu after leaving configure microphone mode */
break;
case '3':
setClient3DPosition(DEFAULT_VIRTUAL_SERVER);
break;
case 'i':
printMyConnectionInfo(scHandlerID);
break;
}
SLEEP(50);
}
/* Disconnect from server. ERROR_not_connected just means the peer is already
gone (e.g. the server was shut down) - nothing to do, so move on. */
if((error = ts3client_stopConnection(scHandlerID, "leaving")) != ERROR_ok && error != ERROR_not_connected)
printf("Error stopping connection: %d\n", error);
SLEEP(200);
/* Destroy server connection handler */
if((error = ts3client_destroyServerConnectionHandler(scHandlerID)) != ERROR_ok)
printf("Error destroying server connection handler: %d\n", error);
/* Shutdown client lib */
if((error = ts3client_destroyClientLib()) != ERROR_ok)
printf("Failed to destroy clientlib: %d\n", error);
/* This is a small hack, to close an open recording sound file */
recordSound = 0;
onEditMixedPlaybackVoiceDataEvent(DEFAULT_VIRTUAL_SERVER, NULL, 0, 0, NULL, NULL);
return 0;
}
Reference in New Issue Copy Permalink