fix: 🐛 sound glitch & delay

feat: ✨ buffering

back/src/lib.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 pub mod routing;
 pub mod streaming;
+pub mod utils;
 
 #[derive(Debug, Clone)]
 pub struct AppState{

back/src/streaming.rs

@@ -1,39 +1,58 @@
-use std::{mem::MaybeUninit, sync::Arc};
+use std::{mem::MaybeUninit, sync::Arc, time::Duration};
 
 use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
 use ringbuf::{Consumer, HeapRb, Producer, SharedRb};
-use tokio::net::{TcpListener, TcpStream};
+use tokio::{net::{TcpListener, TcpStream}, time::Instant};
 use futures_util::SinkExt;
 use tokio_tungstenite::WebSocketStream;
 
+
 pub async fn start() {
-    let socket = TcpListener::bind("127.0.0.1:2424").await.unwrap();
+    let socket = TcpListener::bind("192.168.1.2:2424").await.unwrap();
     while let Ok((tcp_stream, _)) = socket.accept().await {
         println!("Dude Someone Triggered");
         let ring = HeapRb::<f32>::new(1000000);
         let (producer, consumer) = ring.split();
         let ws_stream = tokio_tungstenite::accept_async(tcp_stream).await.unwrap();
-        
+
+        let timer = Instant::now();
+
+
         tokio::spawn(record(producer));
-        std::thread::sleep(std::time::Duration::from_secs(3));
-        tokio::spawn(stream(ws_stream, consumer));
+        tokio::spawn(stream(timer, ws_stream, consumer));
     }
 }
 
-pub async fn stream(mut ws_stream:WebSocketStream<TcpStream>, mut consumer: Consumer<f32, Arc<SharedRb<f32, Vec<MaybeUninit<f32>>>>>) {
+pub async fn stream(timer:Instant, mut ws_stream:WebSocketStream<TcpStream>, mut consumer: Consumer<f32, Arc<SharedRb<f32, Vec<MaybeUninit<f32>>>>>) {
     println!("Waiting");
     loop {
-        if !consumer.is_empty() {
+        tokio::time::sleep(Duration::from_secs(2)).await;
+        let mut data:Vec<u8> = Vec::new();
+        let now = timer.elapsed().as_secs();
+        while !consumer.is_empty() && (timer.elapsed().as_secs()+2) > now{
             match consumer.pop() {
-                Some(data) => {
-                    ws_stream.send(data.to_string().into()).await.unwrap();       
+                Some(single_data) => {                    
+                    let ring = HeapRb::<u8>::new(1000000);
+                    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() {
+                        data.push(consumer.pop().unwrap());
+                    }
                 }
                 None => {
-                    //ws_stream.send(0.0.to_string().into()).await.unwrap();
+
                 }
             }
-            ws_stream.flush().await.unwrap();
-        }           
+        }
+        ws_stream.send(data.into()).await.unwrap();
+        ws_stream.flush().await.unwrap();
     }
 }