TeaSpeak/Teaspeak-Server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Video now has to be manually activated in order to watch it

Browse Source
This commit is contained in:
WolverinDEV 2020-12-10 13:33:09 +01:00
parent 0d976ec0b8
commit 99e68cd5c4
7 changed files with 112 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
rtclib

@ -1 +1 @@
Subproject commit ca4ed0aba377f235e5bf643be3d74c7deb5f4d94
Subproject commit d9150b3af8e5f57f0cd4cd2996b05495dc361bd1

41
server/src/client/SpeakingClient.cpp
View File

@ -639,6 +639,10 @@ command_result SpeakingClient::handleCommand(Command &command) {
return this->handleCommandRtcBroadcast(command);
} else if(command.command() == "rtcsessionreset") {
return this->handleCommandRtcSessionReset(command);
} else if(command.command() == "broadcastvideojoin") {
return this->handleCommandBroadcastVideoJoin(command);
} else if(command.command() == "broadcastvideoleave") {
return this->handleCommandBroadcastVideoLeave(command);
}
}
return ConnectedClient::handleCommand(command);
@ -747,4 +751,41 @@ command_result SpeakingClient::handleCommandRtcBroadcast(Command &command) {
}
}
return ts::command_result{std::move(result)};
}
command_result SpeakingClient::handleCommandBroadcastVideoJoin(Command &cmd) {
CMD_REQ_SERVER;
CMD_CHK_AND_INC_FLOOD_POINTS(25);
auto broadcast_type = (rtc::VideoBroadcastType) cmd["bt"].as<uint8_t>();
auto broadcast_id = cmd["bid"].as<uint32_t>();
using VideoBroadcastJoinResult = rtc::VideoBroadcastJoinResult;
switch(this->server->rtc_server().join_video_broadcast(this->rtc_client_id, broadcast_id, broadcast_type)) {
case VideoBroadcastJoinResult::Success:
return ts::command_result{error::ok};
case VideoBroadcastJoinResult::InvalidBroadcast:
return ts::command_result{error::broadcast_invalid_id};
case VideoBroadcastJoinResult::InvalidBroadcastType:
return ts::command_result{error::broadcast_invalid_type};
case VideoBroadcastJoinResult::InvalidClient:
return ts::command_result{error::client_invalid_id};
case VideoBroadcastJoinResult::UnknownError:
default:
return ts::command_result{error::vs_critical};
}
}
command_result SpeakingClient::handleCommandBroadcastVideoLeave(Command &cmd) {
CMD_REQ_SERVER;
auto broadcast_type = (rtc::VideoBroadcastType) cmd["bt"].as<uint8_t>();
auto broadcast_id = cmd["bid"].as<uint32_t>();
this->server->rtc_server().leave_video_broadcast(this->rtc_client_id, broadcast_id, broadcast_type);
return ts::command_result{error::ok};
}

2
server/src/client/SpeakingClient.h
View File

@ -71,6 +71,8 @@ namespace ts::server {
virtual command_result handleCommandRtcSessionReset(Command &command);
virtual command_result handleCommandRtcIceCandidate(Command &);
virtual command_result handleCommandRtcBroadcast(Command &);
virtual command_result handleCommandBroadcastVideoJoin(Command &);
virtual command_result handleCommandBroadcastVideoLeave(Command &);
void triggerVoiceEnd();
inline void updateSpeak(bool onlyUpdate, const std::chrono::system_clock::time_point &time);

9
server/src/rtc/imports.h
View File

@ -5,6 +5,12 @@
extern "C" {
#endif
struct BroadcastInfo {
uint32_t broadcasting_client_id;
const void* broadcasting_client_data;
uint8_t broadcast_type;
};
/* Attention: Do not call any librtc functions within being in the callback, only librtc_destroy_client is allowed */
struct NativeCallbacks {
uint32_t version;
@ -21,6 +27,7 @@ struct NativeCallbacks {
void(*client_stream_start)(const void* /* callback data */, uint32_t /* stream id */, const void* /* source callback data */);
void(*client_stream_stop)(const void* /* callback data */, uint32_t /* stream id */, const void* /* source callback data */);
void(*client_video_broadcast_info)(const void* const* /* callback data array */, uint32_t /* callback data length */, const BroadcastInfo* /* broadcasts */, uint32_t /* broadcast count */);
void(*client_audio_sender_data)(const void* /* callback data */, const void* /* source callback data */, uint8_t /* mode */, uint16_t /* seq. no. */, uint8_t /* codec */, const void* /* data */, uint32_t /* length */);
void(*client_whisper_session_reset)(const void* /* callback data */);
@ -71,6 +78,8 @@ extern void librtc_destroy_audio_source_supplier(void* /* sender */);
extern uint32_t librtc_create_channel(void* /* server */);
extern uint32_t librtc_assign_channel(void* /* server */, uint32_t /* client id */, uint32_t /* channel id */);
extern uint32_t librtc_client_broadcast(void* /* server */, uint32_t /* client id */, uint8_t /* broadcast type */, uint32_t /* stream id */);
extern uint32_t librtc_video_broadcast_join(void* /* server */, uint32_t /* client id */, uint32_t /* target client id */, uint8_t /* broadcast type */);
extern void librtc_video_broadcast_leave(void* /* server */, uint32_t /* client id */, uint32_t /* target client id */, uint8_t /* broadcast type */);
extern void librtc_destroy_channel(void* /* server */, uint32_t /* channel */);
extern const char* librtc_whisper_configure(void* /* server */, uint32_t /* client id */, uint32_t /* source stream id */, uint32_t* /* client ids */, uint32_t /* client id count */);

44
server/src/rtc/lib.cpp
View File

@ -165,6 +165,31 @@ void librtc_callback_client_audio_start(const void* callback_data_ptr, uint32_t
target_client->sendCommand(notify);
}
void librtc_callback_client_video_broadcast_info(const void* const* callback_data_array, uint32_t callback_data_length, const BroadcastInfo* broadcasts, uint32_t broadcast_count) {
ts::command_builder notify{"notifybroadcastvideo", 32, broadcast_count};
size_t bulk_index{0};
for(size_t index{0}; index < broadcast_count; index++) {
auto& broadcast = broadcasts[index];
auto source_data = (LibCallbackData*) broadcast.broadcasting_client_data;
auto source_client = source_data->weak_ref.lock();
if(!source_client) { continue; }
auto bulk = notify.bulk(bulk_index++);
bulk.put_unchecked("bt", broadcast.broadcast_type);
bulk.put_unchecked("bid", broadcast.broadcasting_client_id);
bulk.put_unchecked("sclid", source_client->getClientId());
}
for(size_t index{0}; index < callback_data_length; index++) {
auto client_data = (LibCallbackData*) callback_data_array[index];
auto client = client_data->weak_ref.lock();
if(!client) { continue; }
client->sendCommand(notify);
}
}
void librtc_callback_client_audio_stop(const void* callback_data_ptr, uint32_t stream_id, const void* source_data_ptr) {
auto callback_data = (LibCallbackData*) callback_data_ptr;
auto source_data = (LibCallbackData*) source_data_ptr;
@ -223,7 +248,7 @@ void librtc_client_whisper_session_reset(const void* callback_data_ptr) {
}
static NativeCallbacks native_callbacks{
.version = 5,
.version = 6,
.log = librtc_callback_log,
.free_client_data = librtc_callback_free_client_data,
@ -237,6 +262,8 @@ static NativeCallbacks native_callbacks{
.client_stream_start = librtc_callback_client_audio_start,
.client_stream_stop = librtc_callback_client_audio_stop,
.client_video_broadcast_info = librtc_callback_client_video_broadcast_info,
.client_audio_sender_data = librtc_callback_client_audio_sender_data,
.client_whisper_session_reset = librtc_client_whisper_session_reset
};
@ -359,6 +386,21 @@ BroadcastStartResult Server::start_broadcast(uint32_t client_id, uint8_t btype,
}
}
VideoBroadcastJoinResult Server::join_video_broadcast(RTCClientId client_id, RTCClientId target_client_id, VideoBroadcastType video_broadcast_type) {
auto result = librtc_video_broadcast_join(this->server_ptr, client_id, target_client_id, (uint8_t) video_broadcast_type);
switch(result) {
case 0x00: return VideoBroadcastJoinResult::Success;
case 0x01: return VideoBroadcastJoinResult::InvalidBroadcastType;
case 0x02: return VideoBroadcastJoinResult::InvalidClient;
case 0x03: return VideoBroadcastJoinResult::InvalidBroadcast;
default: return VideoBroadcastJoinResult::UnknownError;
}
}
void Server::leave_video_broadcast(RTCClientId client_id, RTCClientId target_client_id, VideoBroadcastType video_broadcast_type) {
librtc_video_broadcast_leave(this->server_ptr, client_id, target_client_id, (uint8_t) video_broadcast_type);
}
std::optional<NativeAudioSourceSupplier> Server::create_audio_source_supplier_sender(uint32_t client_id, uint32_t stream_id) {
auto result = librtc_create_audio_source_supplier(this->server_ptr, client_id, stream_id);
if(!result) { return std::nullopt; }

15
server/src/rtc/lib.h
View File

@ -32,6 +32,19 @@ namespace ts::rtc {
UnknownError
};
enum struct VideoBroadcastType {
Camera = 0,
Screen = 1
};
enum struct VideoBroadcastJoinResult {
Success,
InvalidClient,
InvalidBroadcast,
InvalidBroadcastType,
UnknownError
};
class NativeAudioSourceSupplier;
class Server {
public:
@ -57,6 +70,8 @@ namespace ts::rtc {
uint32_t create_channel();
ChannelAssignResult assign_channel(RTCClientId /* client id */, RTCChannelId /* channel id */);
BroadcastStartResult start_broadcast(RTCClientId /* client id */, uint8_t /* broadcast type */, RTCStreamId /* stream id */);
VideoBroadcastJoinResult join_video_broadcast(RTCClientId /* client id */, RTCClientId /* target id */, VideoBroadcastType /* broadcast type */);
void leave_video_broadcast(RTCClientId /* client id */, RTCClientId /* target id */, VideoBroadcastType /* broadcast type */);
void destroy_channel(RTCChannelId /* channel id */);
/* whisper actions */

2
shared

@ -1 +1 @@
Subproject commit 83023f2fa668c99d968dba5525a4284dfd656611
Subproject commit 1ae3b59e1459fddf49f7f468f51e977c70286596