init

src-tauri/src/domain/audio_client.rs

@@ -8,11 +8,11 @@ use crate::core::opus::{AudioOpus, AudioOpusDecoder};
 use crate::utils::ringbuf::{RingBufReader, RingBufWriter, RingBuffer};
 use crate::utils::shared_store::SharedArcMap;
 
-struct AudioClient {
+pub struct AudioClient {
     uuid: uuid::Uuid,
     decode_sender: mpsc::Sender<DecodeRequest>,
-    buffer_reader: RingBufReader<Vec<i16>>,
-    buffer_writer: RingBufWriter<Vec<i16>>
+    buffer_reader: RingBufReader<i16>,
+    buffer_writer: RingBufWriter<i16>
 }
 
 struct DecodeRequest {
@@ -21,21 +21,23 @@ struct DecodeRequest {
 }
 
 #[derive(Clone)]
-struct AudioClientManager {
+pub struct AudioClientManager {
     audio_clients: SharedArcMap<uuid::Uuid, AudioClient>,
 }
 
 impl AudioClient {
     pub fn new() -> Self {
-        let (writer, reader) = RingBuffer::<Vec<i16>>::new(1024).split();
+        let (writer, reader) = RingBuffer::<i16>::new(4096).split();
 
         let (decode_sender, mut decode_reader) = mpsc::channel::<DecodeRequest>(100);
+        let writer_clone = writer.clone();
         let decode_handle = tokio::spawn(async move {
-            let mut decoder = AudioOpus::new(44800, 1, "voip")
+            let mut decoder = AudioOpus::new(48000, 1, "voip")
                 .create_decoder().unwrap();
+
             let mut last_sequence: u16 = 0;
             while let Some(request) = decode_reader.recv().await {
-                // si la séquence est "trop vieille" on la drop. (voir plus tard pour un système de ratrapage si c'est possible)
+                // si la séquence est "trop vieille" on la drop. (voir plus tard pour un système de rattrapage si c'est possible)
                 if last_sequence < request.sequence {
                     // todo : si le décodage est trop long, voir pour le mettre dans un thread
                     //  avec let result = tokio::task::spawn_blocking({
@@ -50,7 +52,8 @@ impl AudioClient {
                     match result {
                         Ok(audio_frame) => {
                             // Pousser la frame complète dans le buffer
-                            writer.push(audio_frame);
+                            writer_clone.push_slice_overwrite(&audio_frame);
+                            println!("writed frame");
                         },
                         Err(e) => {
                             eprintln!("Erreur de décodage audio : {}", e);
@@ -69,8 +72,8 @@ impl AudioClient {
         }
     }
 
-    pub async fn write_audio(&self, sequence: u16, data: Bytes) {
-        let _ = self.decode_sender.send(DecodeRequest {
+    pub fn write_audio(&self, sequence: u16, data: Bytes) {
+        let _ = self.decode_sender.try_send(DecodeRequest {
             data,
             sequence
         });
@@ -79,9 +82,29 @@ impl AudioClient {
 
 
 impl AudioClientManager {
-    fn new() -> Self {
+    pub fn new() -> Self {
         Self {
             audio_clients: SharedArcMap::new()
         }
     }
+
+    pub fn audio_client_exists(&self, uuid: uuid::Uuid) -> bool {
+        self.audio_clients.contains_key(&uuid)
+    }
+
+    pub fn get_audio_client(&self, uuid: uuid::Uuid) -> Option<Arc<AudioClient>> {
+        self.audio_clients.get(&uuid)
+    }
+
+    pub fn add_audio_client(&self, uuid: uuid::Uuid, audio_client: AudioClient) {
+        self.audio_clients.insert(uuid, audio_client);
+    }
+
+    pub fn remove_audio_client(&self, uuid: uuid::Uuid) {
+        self.audio_clients.remove(&uuid);
+    }
+
+    pub fn write_audio_to_client(&self, uuid: uuid::Uuid, sequence: u16, data: Bytes) {
+        let _ = self.audio_clients.get(&uuid).unwrap().write_audio(sequence, data);
+    }
 }