impl fastrtc receive

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text

app.py

@@ -1,63 +1,216 @@
+from app.logger_config import logger as logging
+import numpy as np
+import gradio as gr
+import asyncio
+from fastrtc.webrtc import WebRTC
+from pydub import AudioSegment
+import time
+import threading
+import os # Added to check if file exists
+from gradio.utils import get_space
+
 from app.logger_config import logger as logging
 from app.utils import (
-    debug_current_device,
-    get_current_device
+    generate_coturn_config
 )
-import os
-import gradio as gr
-import spaces
-import torch
 
+# --- Constants and Global State ---
+EXAMPLE_FILES = ["data/bonjour.wav", "data/bonjour2.wav"]
+# The default file is the first in the list
+DEFAULT_FILE = EXAMPLE_FILES[0] 
+streaming_should_stop = threading.Event()
+
+def read_and_stream_audio(filepath_to_stream: str):
+    """
+    A synchronous generator that reads an audio file (via filepath_to_stream)
+    and streams it in 1-second chunks.
+    """
+    
+    if not filepath_to_stream or not os.path.exists(filepath_to_stream):
+        logging.error(f"Audio file not found or not specified: {filepath_to_stream}")
+        # Attempt to use the default file as a fallback
+        if os.path.exists(DEFAULT_FILE):
+            logging.warning(f"Using default file: {DEFAULT_FILE}")
+            filepath_to_stream = DEFAULT_FILE
+        else:
+            logging.error("Default file not found. Stopping stream.")
+            return
+
+    logging.info(f"Preparing audio segment from: {filepath_to_stream}")
+    streaming_should_stop.clear()
+    
+    try:
+        segment = AudioSegment.from_file(filepath_to_stream)
+        chunk_duree_ms = 1000
+        logging.info(f"Starting streaming in {chunk_duree_ms}ms chunks...")
+
+        for i, chunk in enumerate(segment[::chunk_duree_ms]):
+            iter_start_time = time.perf_counter()
+            logging.info(f"Sending chunk {i+1}...")
+
+            if streaming_should_stop.is_set():
+                logging.info("Stop signal received, breaking loop.")
+                break
+
+            output_chunk = (
+                chunk.frame_rate,
+                np.array(chunk.get_array_of_samples()).reshape(1, -1),
+            )
+
+            yield output_chunk
+
+            iter_end_time = time.perf_counter()
+            processing_duration_ms = (iter_end_time - iter_start_time) * 1000
+            
+            sleep_duration = (chunk_duree_ms / 1000.0) - (processing_duration_ms / 1000.0) - 0.1
+            if sleep_duration < 0:
+                sleep_duration = 0.01 # Avoid negative sleep time
+                
+            logging.debug(f"Processing time: {processing_duration_ms:.2f}ms, Sleep: {sleep_duration:.2f}s")
+
+            # Using wait() allows the thread to wake up if the signal is received
+            if streaming_should_stop.wait(timeout=sleep_duration):
+                logging.info("Stop signal received while waiting.")
+                break
+
+        logging.info("Streaming finished.")
+
+    except asyncio.CancelledError:
+        logging.info("Stream stopped by user (CancelledError).")
+        raise
+    except FileNotFoundError:
+        logging.error(f"Critical error: File not found: {filepath_to_stream}")
+    except Exception as e:
+        logging.error(f"Error during stream: {e}", exc_info=True)
+        raise
+    finally:
+        streaming_should_stop.clear()
+        logging.info("Stop signal cleared.")
+
+
+def stop_streaming():
+    """Activates the stop signal for the generator."""
+    logging.info("Stop button clicked: sending stop signal.")
+    streaming_should_stop.set()
+    return None
+
+# --- Gradio Interface ---
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        "## Application 'Streamer' WebRTC (Serveur -> Client)\n"
+        "Utilisez l'exemple fourni, uploadez un fichier ou enregistrez depuis votre micro, "
+        "puis cliquez sur 'Start' pour écouter le stream."
+    )
+
+    # 1. State to store the path of the file to be read
+    active_filepath = gr.State(value=DEFAULT_FILE)
 
+    with gr.Row():
+        with gr.Column():
+            main_audio = gr.Audio(
+                label="Source Audio",
+                sources=["upload", "microphone"], # Combine both sources
+                type="filepath",
+                value=DEFAULT_FILE, # Default to the first example
+            )
+        with gr.Column():
+            webrtc_stream = WebRTC(
+                label="Stream Audio",
+                mode="receive",
+                modality="audio",
+                rtc_configuration=generate_coturn_config(),
+                visible=True,
+                height = 200,
+            )
+    # 4. Control buttons
+    with gr.Row():
+        with gr.Column():
+            start_button = gr.Button("Start Streaming", variant="primary")
+            stop_button = gr.Button("Stop Streaming", variant="stop", interactive=False)
+        with gr.Column():
+            gr.Text()
 
-logging.info("-----------info------------")
-logging.debug("-----------debug------------")
+    def set_new_file(filepath):
+        """Updates the state with the new path, or reverts to default if None."""
+        if filepath is None:
+            logging.info("Audio cleared, reverting to default example file.")
+            new_path = DEFAULT_FILE
+        else:
+            logging.info(f"New audio source selected: {filepath}")
+            new_path = filepath
+        # Returns the value to be put in the gr.State
+        return new_path
 
-@spaces.GPU
-def gpu_compute(name):
-    logging.debug("=== Start of gpu_compute() ===")
-    debug_current_device()
-    tensor,device_name = compute(name)
-    logging.debug("=== End of gpu_compute() ===")
-    return f"Tensor: {tensor.cpu().numpy()} | Device: {device_name}"
+    # Update the path if the user uploads, clears, or changes the file
+    main_audio.change(
+        fn=set_new_file, 
+        inputs=[main_audio], 
+        outputs=[active_filepath]
+    )
+    
+    # Update the path if the user finishes a recording
+    main_audio.stop_recording(
+        fn=set_new_file, 
+        inputs=[main_audio], 
+        outputs=[active_filepath]
+    )
 
-def cpu_compute(name):
-    logging.debug("=== Start of cpu_compute() ===")
-    debug_current_device()
 
-    tensor,device_name = compute(name)
+    # Functions to update the interface state
+    def start_streaming_ui():
+        logging.info("UI: Starting stream. Disabling controls.")
+        return {
+            start_button: gr.Button(interactive=False),
+            stop_button: gr.Button(interactive=True),
+            main_audio: gr.Audio(visible=False), 
+        }
 
-    logging.debug("=== End of cpu_compute() ===")
-    return f"Tensor: {tensor.cpu().numpy()} | Device: {device_name}"
+    def stop_streaming_ui():
+        logging.info("UI: Stopping stream. Re-enabling controls.")
+        return {
+            start_button: gr.Button(interactive=True),
+            stop_button: gr.Button(interactive=False),
+            main_audio: gr.Audio(
+                label="Source Audio",
+                sources=["upload", "microphone"], # Combine both sources
+                type="filepath",
+                value=active_filepath.value,
+                visible=True
+        ), 
+            }
 
-def compute(name) :
-    # Get device info
-    device, device_name = get_current_device()
-    # Create a tensor
-    tensor = torch.tensor([len(name)], dtype=torch.float32, device=device)
-    logging.debug(f"Tensor created: {tensor}")
-    # Optional: free GPU memory
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
-        logging.debug("GPU cache cleared")
-    return tensor, device_name
 
+    ui_components = [
+        start_button, stop_button, 
+        main_audio, 
+    ]
 
-block = gr.Blocks()
+    stream_event = webrtc_stream.stream(
+        fn=read_and_stream_audio,
+        inputs=[active_filepath],  
+        outputs=[webrtc_stream],
+        trigger=start_button.click,
+        concurrency_id="audio_stream", # Concurrency ID
+        concurrency_limit=10
+    )
 
-with block as demo:
-     with gr.Row():
-         input_text = gr.Text()
-         output_text = gr.Text()
-     with gr.Row():
-        gpu_button = gr.Button("GPU compute")
-        cpu_button = gr.Button("CPU compute")
+    # Update the interface on START click
+    start_button.click(
+        fn=start_streaming_ui,
+        outputs=ui_components
+    )
 
-        gpu_button.click(fn=gpu_compute, inputs=[input_text],outputs=[output_text])
-        cpu_button.click(fn=cpu_compute, inputs=[input_text],outputs=[output_text])
+    # Fix: Ensure the stream is properly cancelled
+    stop_button.click(
+        fn=stop_streaming, 
+        outputs=[webrtc_stream], 
+    ).then(
+        fn=stop_streaming_ui, # THEN, update the interface
+        inputs=None,
+        outputs=ui_components
+    )
 
-with gr.Blocks() as demo:
-    block.render()
 
 if __name__ == "__main__":
-    demo.queue(max_size=10, api_open=False).launch(show_api=False)
+    demo.queue(max_size=10, api_open=False).launch(show_api=False, debug=True)

app/utils.py

@@ -1,40 +1,10 @@
 import torch
 from app.logger_config import logger as logging
-
-# def debug_current_device():
-#     """Logs detailed information about the current GPU or CPU device."""
-#     logging.debug("=== Debugging current device ===")
-
-#     if torch.cuda.is_available():
-#         device = torch.device("cuda")
-#         device_name = torch.cuda.get_device_name(0)
-#         memory_allocated = torch.cuda.memory_allocated(0) / (1024 ** 2)
-#         memory_reserved = torch.cuda.memory_reserved(0) / (1024 ** 2)
-#         memory_total = torch.cuda.get_device_properties(0).total_memory / (1024 ** 2)
-#         capability = torch.cuda.get_device_capability(0)
-#         current_device = torch.cuda.current_device()
-
-#         logging.debug(f"GPU name          : {device_name}")
-#         logging.debug(f"Current device ID : {current_device}")
-#         logging.debug(f"CUDA capability   : {capability}")
-#         logging.debug(f"Memory allocated  : {memory_allocated:.2f} MB")
-#         logging.debug(f"Memory reserved   : {memory_reserved:.2f} MB")
-#         logging.debug(f"Total memory      : {memory_total:.2f} MB")
-
-#     else:
-#         logging.debug("No GPU detected, using CPU")
-    
-# def get_current_device():
-#     if torch.cuda.is_available():
-#         device = torch.device("cuda")
-#         device_name = torch.cuda.get_device_name(0)
-#         return device, device_name
-#     else:
-#         return torch.device("cpu"), "CPU (no GPU detected)"
-
-
-
-import torch
+import hmac
+import hashlib
+import base64
+import os
+import time
 
 def debug_current_device():
     """Safely logs GPU or CPU information without crashing on stateless GPU."""
@@ -80,4 +50,40 @@ def get_current_device():
             device_name = "CPU (stateless GPU mode)"
         # else:
         #     raise
-    return device, device_name
+    return device, device_name
+
+
+
+def generate_coturn_config():
+    """
+    Génère une configuration Coturn complète avec authentification dynamique (use-auth-secret).
+    Returns:
+        dict: Objet coturn_config prêt à être utilisé côté client WebRTC.
+    """
+
+    secret_key = os.getenv("TURN_SECRET_KEY", "your_secret_key")
+    ttl = int(os.getenv("TURN_TTL", 3600))
+    turn_url = os.getenv("TURN_URL", "turn:*******")
+    turn_s_url = os.getenv("TURN_S_URL", "turns:*****")
+    user = os.getenv("TURN_USER", "client")
+
+    timestamp = int(time.time()) + ttl
+    username = f"{timestamp}:{user}"
+    password = base64.b64encode(
+        hmac.new(secret_key.encode(), username.encode(), hashlib.sha1).digest()
+    ).decode()
+ 
+    coturn_config = {
+        "iceServers": [
+            {
+                "urls": [
+                    f"{turn_url}",
+                    f"{turn_s_url}",
+                ],
+                "username": username,
+                "credential": password,
+            }
+        ]
+    }
+    print(coturn_config)
+    return coturn_config

gpu_compute.py

@@ -0,0 +1,61 @@
+from app.logger_config import logger as logging
+from app.utils import (
+    debug_current_device,
+    get_current_device
+)
+import os
+import gradio as gr
+import spaces
+import torch
+
+
+
+
+@spaces.GPU
+def gpu_compute(name):
+    logging.debug("=== Start of gpu_compute() ===")
+    debug_current_device()
+    tensor,device_name = compute(name)
+    logging.debug("=== End of gpu_compute() ===")
+    return f"Tensor: {tensor.cpu().numpy()} | Device: {device_name}"
+
+def cpu_compute(name):
+    logging.debug("=== Start of cpu_compute() ===")
+    debug_current_device()
+
+    tensor,device_name = compute(name)
+
+    logging.debug("=== End of cpu_compute() ===")
+    return f"Tensor: {tensor.cpu().numpy()} | Device: {device_name}"
+
+def compute(name) :
+    # Get device info
+    device, device_name = get_current_device()
+    # Create a tensor
+    tensor = torch.tensor([len(name)], dtype=torch.float32, device=device)
+    logging.debug(f"Tensor created: {tensor}")
+    # Optional: free GPU memory
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        logging.debug("GPU cache cleared")
+    return tensor, device_name
+
+
+block = gr.Blocks()
+
+with block as demo:
+     with gr.Row():
+         input_text = gr.Text()
+         output_text = gr.Text()
+     with gr.Row():
+        gpu_button = gr.Button("GPU compute")
+        cpu_button = gr.Button("CPU compute")
+
+        gpu_button.click(fn=gpu_compute, inputs=[input_text],outputs=[output_text])
+        cpu_button.click(fn=cpu_compute, inputs=[input_text],outputs=[output_text])
+
+with gr.Blocks() as demo:
+    block.render()
+
+if __name__ == "__main__":
+    demo.queue(max_size=10, api_open=False).launch(show_api=False)

requirements.txt

@@ -1,4 +1,5 @@
 gradio
 spaces
 torch
-python-dotenv
+python-dotenv
+fastrtc==0.0.33