Tahinli/radioxide
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: ✨ main server as a relay, support for streamer client

Browse source
This commit is contained in:
Ahmet Kaan GÜMÜŞ 2024-04-09 20:54:32 +03:00
parent e26b0b9fd1
commit a954dfce73
7 changed files with 188 additions and 126 deletions
Download patch file Download diff file Expand all files Collapse all files

4
streamer/src/lib.rs Normal file
View file

@ -0,0 +1,4 @@
pub mod recording;
pub mod streaming;
pub const BUFFER_LENGTH: usize = 1000000;

70
streamer/src/main.rs
View file

@ -1,70 +1,14 @@
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
use ringbuf::HeapRb;
use std::time::Duration;
use streamer::{recording::recording, streaming::start, BUFFER_LENGTH};
use tokio::sync::broadcast::channel;
#[tokio::main]
async fn main() {
println!("Hello, world!");
let host = cpal::default_host();
let input_device = host.default_input_device().unwrap();
let output_device = host.default_output_device().unwrap();
println!("Input Device: {}", input_device.name().unwrap());
println!("Output Device: {}", output_device.name().unwrap());
let config:cpal::StreamConfig = input_device.default_input_config().unwrap().into();
let latency_frames = 0.1*config.sample_rate.0 as f32;
let latency_samples = latency_frames as usize * config.channels as usize;
let ring = HeapRb::<f32>::new(latency_samples*2);
let (mut producer, mut consumer) = ring.split();
for _ in 0..latency_samples {
producer.push(0.0).unwrap();
}
let input_data_fn = move |data: &[f32], _:&cpal::InputCallbackInfo| {
let mut output_fell_behind = false;
for &sample in data {
if producer.push(sample).is_err() {
output_fell_behind = true;
}
}
if output_fell_behind {
eprintln!("Too fast friend");
}
};
let output_data_fn = move |data: &mut [f32], _:&cpal::OutputCallbackInfo| {
let mut input_fell_behind = false;
for sample in data {
*sample = match consumer.pop() {
Some(s) => s,
None => {
input_fell_behind = true;
0.0
}
};
}
if input_fell_behind {
eprintln!("Too fast");
}
};
let input_stream = input_device.build_input_stream(&config, input_data_fn, err_fn, None).unwrap();
let output_stream = output_device.build_output_stream(&config, output_data_fn, err_fn, None).unwrap();
println!("STREAMIN");
input_stream.play().unwrap();
output_stream.play().unwrap();
tokio::time::sleep(std::time::Duration::from_secs(10)).await;
//std::thread::sleep(std::time::Duration::from_secs(10));
println!("DONE I HOPE");
}
fn err_fn(err: cpal::StreamError) {
eprintln!("Something Happened: {}", err);
let (sound_stream_producer, sound_stream_consumer) = channel(BUFFER_LENGTH);
tokio::spawn(recording(sound_stream_producer));
tokio::spawn(start(sound_stream_consumer));
tokio::time::sleep(Duration::from_secs(1000000000)).await;
}

31
streamer/src/recording.rs Normal file
View file

@ -0,0 +1,31 @@
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
use tokio::sync::broadcast::Sender;
pub async fn recording(sound_stream_producer: Sender<f32>) {
let host = cpal::default_host();
let input_device = host.default_input_device().unwrap();
let config: cpal::StreamConfig = input_device.default_input_config().unwrap().into();
let input_data_fn = move |data: &[f32], _: &cpal::InputCallbackInfo| {
for &sample in data {
match sound_stream_producer.send(sample) {
Ok(_) => {}
Err(_) => {}
}
}
};
let input_stream = input_device
.build_input_stream(&config, input_data_fn, err_fn, None)
.unwrap();
println!("STREAMIN");
input_stream.play().unwrap();
std::thread::sleep(std::time::Duration::from_secs(1000000000));
println!("DONE I HOPE");
}
fn err_fn(err: cpal::StreamError) {
eprintln!("Something Happened: {}", err);
}

98
streamer/src/streaming.rs Normal file
View file

@ -0,0 +1,98 @@
use std::time::Duration;
use futures_util::SinkExt;
use ringbuf::HeapRb;
use tokio::sync::broadcast::{channel, Receiver, Sender};
use tokio_tungstenite::{tungstenite::Message, WebSocketStream};
use crate::BUFFER_LENGTH;
const MAX_TOLERATED_MESSAGE_COUNT: usize = 10;
pub async fn start(sound_stream_consumer: Receiver<f32>) {
let connect_addr = "ws://192.168.1.2:2525";
let ws_stream;
match tokio_tungstenite::connect_async(connect_addr).await {
Ok(ws_stream_connected) => ws_stream = ws_stream_connected.0,
Err(_) => {
return;
}
}
let (message_producer, message_consumer) = channel(BUFFER_LENGTH);
println!("Connected to: {}", connect_addr);
tokio::spawn(message_organizer(message_producer, sound_stream_consumer));
tokio::spawn(stream(ws_stream, message_consumer));
}
async fn message_organizer(message_producer: Sender<Message>, mut consumer: Receiver<f32>) {
loop {
let mut messages: Vec<u8> = Vec::new();
let mut iteration = consumer.len();
while iteration > 0 {
iteration -= 1;
match consumer.recv().await {
Ok(single_data) => {
let ring = HeapRb::<u8>::new(BUFFER_LENGTH);
let (mut producer, mut consumer) = ring.split();
let single_data_packet = single_data.to_string().as_bytes().to_vec();
let terminator = "#".as_bytes().to_vec();
for element in single_data_packet {
producer.push(element).unwrap();
}
for element in terminator {
producer.push(element).unwrap();
}
while !consumer.is_empty() {
messages.push(consumer.pop().unwrap());
}
}
Err(_) => {}
}
}
tokio::time::sleep(Duration::from_secs(1)).await;
if !messages.is_empty() {
match message_producer.send(messages.into()) {
Ok(_) => {}
Err(_) => {}
}
println!(
"Message Counter = {} | Receiver Count = {}",
message_producer.len(),
message_producer.receiver_count()
);
}
}
}
async fn stream(
mut ws_stream: WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>,
mut message_consumer: Receiver<Message>,
) {
while let Ok(message) = message_consumer.recv().await {
if message_consumer.len() > MAX_TOLERATED_MESSAGE_COUNT {
// println!(
// "{} Forced to Disconnect | Reason -> Slow Consumer",
// format!("{}:{}", listener.ip, listener.port)
// );
break;
}
match ws_stream.send(message).await {
Ok(_) => {
if let Err(_) = ws_stream.flush().await {
// println!(
// "{} is Disconnected",
// format!("{}:{}", listener.ip, listener.port)
// );
break;
}
}
Err(_) => {
// println!(
// "{} is Disconnected",
// format!("{}:{}", listener.ip, listener.port)
// );
break;
}
}
}
}