add Global stop flag

app.py

@@ -5,31 +5,28 @@ 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
+import os
 import spaces
+import threading
+from app.utils import generate_coturn_config
 
-from app.logger_config import logger as logging
-from app.utils import (
-    generate_coturn_config
-)
 
-# --- Constants and Global State ---
+# --- Constants ---
 EXAMPLE_FILES = ["data/bonjour.wav", "data/bonjour2.wav"]
-# The default file is the first in the list
-DEFAULT_FILE = EXAMPLE_FILES[0] 
+DEFAULT_FILE = EXAMPLE_FILES[0]
+
+# --- Global stop flag ---
 streaming_should_stop = threading.Event()
+
+
+# --- Audio Stream Function ---
 @spaces.GPU
 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.
+    Stream an audio file in 1-second chunks until stop signal is received.
     """
-    
     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
@@ -39,92 +36,79 @@ def read_and_stream_audio(filepath_to_stream: str):
 
     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.")
+                logging.info("Stop flag detected, ending stream.")
                 break
 
+            iter_start = time.perf_counter()
+            logging.info(f"Sending chunk {i+1}...")
+
             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
+            processing_duration_ms = (time.perf_counter() - iter_start) * 1000
+            sleep_duration = max((chunk_duree_ms / 1000.0) - (processing_duration_ms / 1000.0) - 0.1, 0.01)
+            time.sleep(sleep_duration)
 
-        logging.info("Streaming finished.")
+        logging.info("Streaming finished successfully.")
 
     except asyncio.CancelledError:
-        logging.info("Stream stopped by user (CancelledError).")
+        logging.info("Stream cancelled by user.")
         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)
+        logging.error(f"Error during audio streaming: {e}", exc_info=True)
         raise
     finally:
         streaming_should_stop.clear()
-        logging.info("Stop signal cleared.")
+        logging.info("Stop flag cleared.")
 
 
+# --- Stop Function ---
 def stop_streaming():
-    """Activates the stop signal for the generator."""
-    logging.info("Stop button clicked: sending stop signal.")
+    """Set the stop flag to True."""
+    logging.info("Stop button clicked: setting stop flag.")
     streaming_should_stop.set()
     return None
 
-# --- Gradio Interface ---
 
+# --- 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."
+        "## Application 'Streamer' WebRTC (Serveur → Client)\n"
+        "Chargez un fichier, enregistrez depuis votre micro ou utilisez un exemple, "
+        "puis cliquez sur **Start Streaming** pour écouter le flux en direct."
     )
 
-    # 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
+                sources=["upload", "microphone"],
                 type="filepath",
-                value=DEFAULT_FILE, # Default to the first example
+                value=DEFAULT_FILE,
             )
         with gr.Column():
             webrtc_stream = WebRTC(
-                label="Stream Audio",
+                label="Flux Audio",
                 mode="receive",
                 modality="audio",
                 rtc_configuration=generate_coturn_config(),
                 visible=True,
-                height = 200,
+                height=200,
             )
-    # 4. Control buttons
+
     with gr.Row():
         with gr.Column():
             start_button = gr.Button("Start Streaming", variant="primary")
@@ -133,38 +117,21 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             gr.Text()
 
     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
-
-    # 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]
-    )
+            return DEFAULT_FILE
+        logging.info(f"New audio source selected: {filepath}")
+        return filepath
 
+    main_audio.change(fn=set_new_file, inputs=[main_audio], outputs=[active_filepath])
+    main_audio.stop_recording(fn=set_new_file, inputs=[main_audio], outputs=[active_filepath])
 
-    # 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), 
+            main_audio: gr.Audio(visible=False),
         }
 
     def stop_streaming_ui():
@@ -174,42 +141,38 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             stop_button: gr.Button(interactive=False),
             main_audio: gr.Audio(
                 label="Source Audio",
-                sources=["upload", "microphone"], # Combine both sources
+                sources=["upload", "microphone"],
                 type="filepath",
                 value=active_filepath.value,
-                visible=True
-        ), 
-            }
-
+                visible=True,
+            ),
+        }
 
-    ui_components = [
-        start_button, stop_button, 
-        main_audio, 
-    ]
+    ui_components = [start_button, stop_button, main_audio]
 
+    # --- Stream event ---
     stream_event = webrtc_stream.stream(
         fn=read_and_stream_audio,
-        inputs=[active_filepath],  
+        inputs=[active_filepath],
         outputs=[webrtc_stream],
         trigger=start_button.click,
-        concurrency_id="audio_stream", # Concurrency ID
-        concurrency_limit=10
+        concurrency_id="audio_stream",
+        concurrency_limit=10,
     )
 
-    # Update the interface on START click
+    # --- Button actions ---
     start_button.click(
         fn=start_streaming_ui,
-        outputs=ui_components
+        outputs=ui_components,
     )
 
-    # Fix: Ensure the stream is properly cancelled
+    # ✅ Stop streaming instantly (thread-safe flag)
     stop_button.click(
-        fn=stop_streaming, 
-        outputs=[webrtc_stream], 
+        fn=stop_streaming,
+        outputs=[webrtc_stream],
     ).then(
-        fn=stop_streaming_ui, # THEN, update the interface
-        inputs=None,
-        outputs=ui_components
+        fn=stop_streaming_ui,
+        outputs=ui_components,
     )