Discord -> teamspeak pipe without audio hearable

Teamspeak bot displays "talking" but nothing can be heard.
Just piping opus 1:1 from discord to ts.
Won't work for >1 person in a channel.

Signed-off-by: Aron Heinecke <aron.heinecke@t-online.de>
This commit is contained in:
Aron Heinecke 2021-05-10 14:01:35 +02:00
parent ac9d4932d7
commit a23b9f121b
2 changed files with 231 additions and 16 deletions

View file

@ -1,11 +1,13 @@
use std::env; use std::{env, sync::Arc, time::Duration};
use serde::Deserialize; use serde::Deserialize;
use tokio::sync::mpsc;
use tsclientlib::{ClientId, Connection, DisconnectOptions, Identity, StreamItem}; use tsclientlib::{ClientId, Connection, DisconnectOptions, Identity, StreamItem};
use tsproto_packets::packets::{AudioData, CodecType, OutAudio, OutPacket}; use tsproto_packets::packets::{AudioData, CodecType, Direction, OutAudio, OutPacket};
use audiopus::coder::Encoder; use audiopus::coder::Encoder;
use futures::prelude::*; use futures::prelude::*;
use sdl2::audio::{AudioCallback, AudioDevice, AudioSpec, AudioSpecDesired, AudioStatus}; use sdl2::audio::{AudioCallback, AudioDevice, AudioSpec, AudioSpecDesired, AudioStatus};
use sdl2::AudioSubsystem; use sdl2::AudioSubsystem;
use serenity::prelude::Mentionable;
// This trait adds the `register_songbird` and `register_songbird_with` methods // This trait adds the `register_songbird` and `register_songbird_with` methods
// to the client builder below, making it easy to install this voice client. // to the client builder below, making it easy to install this voice client.
@ -28,6 +30,17 @@ use serenity::{
model::{channel::Message, gateway::Ready}, model::{channel::Message, gateway::Ready},
Result as SerenityResult, Result as SerenityResult,
}; };
use songbird::{
driver::{Config as DriverConfig, DecodeMode},
model::payload::{ClientConnect, ClientDisconnect, Speaking},
CoreEvent,
Event,
EventContext,
EventHandler as VoiceEventHandler,
Songbird,
};
use crate::ListenerHolder;
pub(crate) struct Handler; pub(crate) struct Handler;
@ -105,7 +118,51 @@ async fn join(ctx: &Context, msg: &Message) -> CommandResult {
let manager = songbird::get(ctx).await let manager = songbird::get(ctx).await
.expect("Songbird Voice client placed in at initialisation.").clone(); .expect("Songbird Voice client placed in at initialisation.").clone();
let _handler = manager.join(guild_id, connect_to).await; let (handler_lock, conn_result) = manager.join(guild_id, connect_to).await;
if let Ok(_) = conn_result {
// NOTE: this skips listening for the actual connection result.
let channel: Arc<mpsc::Sender<OutPacket>>;
{
let data_read = ctx.data.read().await;
channel = data_read.get::<ListenerHolder>().expect("Expected CommandCounter in TypeMap.").clone();
}
let mut handler = handler_lock.lock().await;
handler.add_global_event(
CoreEvent::SpeakingStateUpdate.into(),
Receiver::new(channel.clone()),
);
handler.add_global_event(
CoreEvent::SpeakingUpdate.into(),
Receiver::new(channel.clone()),
);
handler.add_global_event(
CoreEvent::VoicePacket.into(),
Receiver::new(channel.clone()),
);
handler.add_global_event(
CoreEvent::RtcpPacket.into(),
Receiver::new(channel.clone()),
);
handler.add_global_event(
CoreEvent::ClientConnect.into(),
Receiver::new(channel.clone()),
);
handler.add_global_event(
CoreEvent::ClientDisconnect.into(),
Receiver::new(channel),
);
check_msg(msg.channel_id.say(&ctx.http, &format!("Joined {}", connect_to.mention())).await);
} else {
check_msg(msg.channel_id.say(&ctx.http, "Error joining the channel").await);
}
Ok(()) Ok(())
} }
@ -273,3 +330,123 @@ fn check_msg(result: SerenityResult<Message>) {
println!("Error sending message: {:?}", why); println!("Error sending message: {:?}", why);
} }
} }
struct Receiver{
sink: Arc<mpsc::Sender<OutPacket>>,
}
impl Receiver {
pub fn new(voice_receiver: Arc<mpsc::Sender<OutPacket>>) -> Self {
// You can manage state here, such as a buffer of audio packet bytes so
// you can later store them in intervals.
Self {
sink: voice_receiver,
}
}
}
#[async_trait]
impl VoiceEventHandler for Receiver {
#[allow(unused_variables)]
async fn act(&self, ctx: &EventContext<'_>) -> Option<Event> {
use EventContext as Ctx;
match ctx {
Ctx::SpeakingStateUpdate(
Speaking {speaking, ssrc, user_id, ..}
) => {
// Discord voice calls use RTP, where every sender uses a randomly allocated
// *Synchronisation Source* (SSRC) to allow receivers to tell which audio
// stream a received packet belongs to. As this number is not derived from
// the sender's user_id, only Discord Voice Gateway messages like this one
// inform us about which random SSRC a user has been allocated. Future voice
// packets will contain *only* the SSRC.
//
// You can implement logic here so that you can differentiate users'
// SSRCs and map the SSRC to the User ID and maintain this state.
// Using this map, you can map the `ssrc` in `voice_packet`
// to the user ID and handle their audio packets separately.
println!(
"Speaking state update: user {:?} has SSRC {:?}, using {:?}",
user_id,
ssrc,
speaking,
);
},
Ctx::SpeakingUpdate {ssrc, speaking} => {
// You can implement logic here which reacts to a user starting
// or stopping speaking.
println!(
"Source {} has {} speaking.",
ssrc,
if *speaking {"started"} else {"stopped"},
);
},
Ctx::VoicePacket {audio, packet, payload_offset, payload_end_pad} => {
// An event which fires for every received audio packet,
// containing the decoded data.
let data: &[u8] = &packet.payload.as_slice()[*payload_offset..(packet.payload.len()-payload_end_pad)];
let packet = OutAudio::new(&AudioData::C2S { id: 0, codec: CodecType::OpusMusic, data });
if let Err(e) = self.sink.send_timeout(packet, Duration::from_millis(10)).await {
eprint!("Can't send voice to sender: {}",e);
}
if let Some(audio) = audio {
// println!("Audio packet's first 5 samples: {:?}", audio.get(..5.min(audio.len())));
// // println!(
// // "Audio packet sequence {:05} has {:04} bytes (decompressed from {}), SSRC {}",
// // packet.sequence.0,
// // audio.len() * std::mem::size_of::<i16>(),
// // packet.payload.len(),
// // packet.ssrc,
// // );
// let mut values_converted = Vec::with_capacity(2*audio.len());
// for value in audio {
// // maybe "be" ?
// // TODO: we could optimize this, data isn't directly used
// values_converted.extend(&value.to_le_bytes());
// }
// let packet =
// OutAudio::new(&AudioData::C2S { id: 0, codec: CodecType::OpusMusic, data: &values_converted });
// if let Err(e) = self.sink.send_timeout(packet, Duration::from_millis(10)).await {
// eprint!("Can't send voice to sender: {}",e);
// }
} else {
println!("RTP packet, but no audio. Driver may not be configured to decode.");
}
},
Ctx::RtcpPacket {packet, payload_offset, payload_end_pad} => {
// An event which fires for every received rtcp packet,
// containing the call statistics and reporting information.
println!("RTCP packet received: {:?}", packet);
},
Ctx::ClientConnect(
ClientConnect {audio_ssrc, video_ssrc, user_id, ..}
) => {
// You can implement your own logic here to handle a user who has joined the
// voice channel e.g., allocate structures, map their SSRC to User ID.
println!(
"Client connected: user {:?} has audio SSRC {:?}, video SSRC {:?}",
user_id,
audio_ssrc,
video_ssrc,
);
},
Ctx::ClientDisconnect(
ClientDisconnect {user_id, ..}
) => {
// You can implement your own logic here to handle a user who has left the
// voice channel e.g., finalise processing of statistics etc.
// You will typically need to map the User ID to their SSRC; observed when
// speaking or connecting.
println!("Client disconnected: user {:?}", user_id);
},
_ => {
// We won't be registering this struct for any more event classes.
unimplemented!()
}
}
None
}
}

View file

@ -1,4 +1,4 @@
use std::env; use std::{collections::HashMap, env, sync::Arc};
use serde::Deserialize; use serde::Deserialize;
use tsclientlib::{ClientId, Connection, DisconnectOptions, Identity, StreamItem}; use tsclientlib::{ClientId, Connection, DisconnectOptions, Identity, StreamItem};
use tsproto_packets::packets::{AudioData, CodecType, OutAudio, OutPacket}; use tsproto_packets::packets::{AudioData, CodecType, OutAudio, OutPacket};
@ -20,10 +20,11 @@ struct ConnectionId(u64);
// This trait adds the `register_songbird` and `register_songbird_with` methods // This trait adds the `register_songbird` and `register_songbird_with` methods
// to the client builder below, making it easy to install this voice client. // to the client builder below, making it easy to install this voice client.
// The voice client can be retrieved in any command using `songbird::get(ctx).await`. // The voice client can be retrieved in any command using `songbird::get(ctx).await`.
use songbird::SerenityInit; use songbird::{SerenityInit, Songbird};
use songbird::driver::{Config as DriverConfig, DecodeMode};
// Import the `Context` to handle commands. // Import the `Context` to handle commands.
use serenity::client::Context; use serenity::{client::Context, prelude::{RwLock, TypeMapKey}};
use serenity::{ use serenity::{
async_trait, async_trait,
@ -52,6 +53,12 @@ struct Config {
volume: f32, volume: f32,
} }
struct ListenerHolder;
impl TypeMapKey for ListenerHolder {
type Value = Arc<mpsc::Sender<OutPacket>>;
}
#[tokio::main] #[tokio::main]
async fn main() -> Result<()> { async fn main() -> Result<()> {
tracing_subscriber::fmt::init(); tracing_subscriber::fmt::init();
@ -71,13 +78,35 @@ async fn main() -> Result<()> {
.prefix("~")) .prefix("~"))
.group(&discord::GENERAL_GROUP); .group(&discord::GENERAL_GROUP);
// Here, we need to configure Songbird to decode all incoming voice packets.
// If you want, you can do this on a per-call basis---here, we need it to
// read the audio data that other people are sending us!
let songbird = Songbird::serenity();
songbird.set_config(
DriverConfig::default()
.decode_mode(DecodeMode::Decode)
);
let mut client = Client::builder(&config.discord_token) let mut client = Client::builder(&config.discord_token)
.event_handler(discord::Handler) .event_handler(discord::Handler)
.framework(framework) .framework(framework)
.register_songbird() .register_songbird_with(songbird.into())
.await .await
.expect("Err creating client"); .expect("Err creating client");
let (tx,mut rx) = mpsc::channel(50);
let voice_pipes: Arc<mpsc::Sender<OutPacket>> = Arc::new(tx);
{
// Open the data lock in write mode, so keys can be inserted to it.
let mut data = client.data.write().await;
// The CommandCounter Value has the following type:
// Arc<RwLock<HashMap<String, u64>>>
// So, we have to insert the same type to it.
data.insert::<ListenerHolder>(voice_pipes);
}
tokio::spawn(async move { tokio::spawn(async move {
let _ = client.start().await.map_err(|why| println!("Client ended: {:?}", why)); let _ = client.start().await.map_err(|why| println!("Client ended: {:?}", why));
}); });
@ -107,13 +136,13 @@ async fn main() -> Result<()> {
r?; r?;
} }
let (send, mut recv) = mpsc::channel(5); // let (send, mut recv) = mpsc::channel(5);
{ // {
let mut a2t = audiodata.a2ts.lock().unwrap(); // let mut a2t = audiodata.a2ts.lock().unwrap();
a2t.set_listener(send); // a2t.set_listener(send);
a2t.set_volume(config.volume); // a2t.set_volume(config.volume);
a2t.set_playing(true); // a2t.set_playing(true);
} // }
loop { loop {
let t2a = audiodata.ts2a.clone(); let t2a = audiodata.ts2a.clone();
@ -134,7 +163,15 @@ async fn main() -> Result<()> {
// Wait for ctrl + c // Wait for ctrl + c
tokio::select! { tokio::select! {
send_audio = recv.recv() => { // send_audio = recv.recv() => {
// if let Some(packet) = send_audio {
// con.send_audio(packet)?;
// } else {
// info!(logger, "Audio sending stream was canceled");
// break;
// }
// }
send_audio = rx.recv() => {
if let Some(packet) = send_audio { if let Some(packet) = send_audio {
con.send_audio(packet)?; con.send_audio(packet)?;
} else { } else {
@ -149,9 +186,10 @@ async fn main() -> Result<()> {
} }
}; };
} }
println!("Disconnecting");
// Disconnect // Disconnect
con.disconnect(DisconnectOptions::new())?; con.disconnect(DisconnectOptions::new())?;
con.events().for_each(|_| future::ready(())).await; con.events().for_each(|_| future::ready(())).await;
println!("Disconnected");
Ok(()) Ok(())
} }