Add french ASR model

api/endpoints.py

@@ -10,7 +10,9 @@ from fastapi.responses import FileResponse, JSONResponse
 from core.connection_manager import ConnectionManager
 from core.asr_service import ASRService
 from core.audio_streamer import AudioStreamer
-from config import RADIO_URLS
+from config import RADIO_URLS, STATION_LANGUAGES, CURRENT_MODEL
+# Add to the imports
+from config import STATION_LANGUAGES
 
 logger = logging.getLogger(__name__)
 router = APIRouter()
@@ -20,6 +22,7 @@ manager = ConnectionManager()
 PCM_FOR_ASR_QUEUE = asyncio.Queue(maxsize=100)
 BACKGROUND_TASKS: dict[str, asyncio.Task | None] = {"audio": None, "asr": None}
 CURRENT_RADIO_URL = None
+CURRENT_LANGUAGE = "en"
 
 @router.get("/")
 async def get_root():
@@ -31,10 +34,11 @@ async def get_stations():
     """Returns the list of available radio stations."""
     return JSONResponse(content=RADIO_URLS)
 
+# Update the websocket_endpoint function to send language info
 @router.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket, station: str = Query(None)):
     """Handles the WebSocket connection for a single client."""
-    global CURRENT_RADIO_URL, BACKGROUND_TASKS
+    global CURRENT_RADIO_URL, BACKGROUND_TASKS, CURRENT_LANGUAGE
     
     # Determine the radio URL to use
     radio_url = RADIO_URLS.get(station) if station else None
@@ -46,8 +50,16 @@ async def websocket_endpoint(websocket: WebSocket, station: str = Query(None)):
         await websocket.close(code=1011, reason="No radio stations configured")
         return
     
-    # Check if we need to switch stations
-    if CURRENT_RADIO_URL != radio_url:
+    # Determine the language for this station
+    station_language = STATION_LANGUAGES.get(station, "en")
+    
+    # Check if we need to switch stations or languages
+    if CURRENT_RADIO_URL != radio_url or CURRENT_LANGUAGE != station_language:
+        # Update the current language in config
+        import config
+        config.CURRENT_MODEL = station_language
+        CURRENT_LANGUAGE = station_language
+        
         # Stop existing tasks if running
         if BACKGROUND_TASKS["audio"]:
             BACKGROUND_TASKS["audio"].cancel()
@@ -59,9 +71,15 @@ async def websocket_endpoint(websocket: WebSocket, station: str = Query(None)):
     
     await manager.connect(websocket)
 
+    # Send initial language info to the client
+    await websocket.send_json({
+        "type": "language", 
+        "payload": {"language": station_language, "station": station}
+    })
+
     # Start background tasks if this is the first client or if they were stopped
     if not BACKGROUND_TASKS["audio"] and not BACKGROUND_TASKS["asr"]:
-        logger.info(f"Starting background tasks for station: {station or 'default'}")
+        logger.info(f"Starting background tasks for station: {station or 'default'} (language: {station_language})")
         audio_streamer = AudioStreamer(PCM_FOR_ASR_QUEUE, manager, radio_url)
         asr_service = ASRService(PCM_FOR_ASR_QUEUE, manager)
         BACKGROUND_TASKS["audio"] = asyncio.create_task(audio_streamer.run_fetching_loop())

app.py

@@ -1,3 +1,4 @@
+# app.py
 """
 Main application file to initialize and run the FastAPI server.
 """
@@ -8,7 +9,10 @@ from fastapi.staticfiles import StaticFiles
 from huggingface_hub import snapshot_download
 
 from api import endpoints
-from config import MODEL_DIR, REPO_ID
+from config import (
+    MODEL_DIR_EN, REPO_ID_EN, 
+    MODEL_DIR_FR, REPO_ID_FR
+)
 
 # Setup basic logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -18,19 +22,34 @@ app = FastAPI(title="Live Radio Karaoke")
 
 @app.on_event("startup")
 async def download_model_if_needed():
-    """Check for and download the ASR model on startup."""
-    logger.info("Checking for ASR model...")
-    tokens_path = os.path.join(MODEL_DIR, "tokens.txt")
-    if not os.path.exists(tokens_path):
-        logger.warning(f"Model not found in {MODEL_DIR}. Downloading from Hugging Face Hub...")
+    """Check for and download the ASR models on startup."""
+    logger.info("Checking for ASR models...")
+    
+    # Check and download English model
+    tokens_path_en = os.path.join(MODEL_DIR_EN, "tokens.txt")
+    if not os.path.exists(tokens_path_en):
+        logger.warning(f"English model not found in {MODEL_DIR_EN}. Downloading from Hugging Face Hub...")
         try:
-            snapshot_download(repo_id=REPO_ID, local_dir=MODEL_DIR, local_dir_use_symlinks=False)
-            logger.info("Model download complete.")
+            snapshot_download(repo_id=REPO_ID_EN, local_dir=MODEL_DIR_EN, local_dir_use_symlinks=False)
+            logger.info("English model download complete.")
         except Exception as e:
-            logger.error(f"Failed to download model: {e}")
+            logger.error(f"Failed to download English model: {e}")
             raise
     else:
-        logger.info("Model found locally.")
+        logger.info("English model found locally.")
+    
+    # Check and download French model
+    tokens_path_fr = os.path.join(MODEL_DIR_FR, "tokens.txt")
+    if not os.path.exists(tokens_path_fr):
+        logger.warning(f"French model not found in {MODEL_DIR_FR}. Downloading from Hugging Face Hub...")
+        try:
+            snapshot_download(repo_id=REPO_ID_FR, local_dir=MODEL_DIR_FR, local_dir_use_symlinks=False)
+            logger.info("French model download complete.")
+        except Exception as e:
+            logger.error(f"Failed to download French model: {e}")
+            raise
+    else:
+        logger.info("French model found locally.")
 
 # Include the API router
 app.include_router(endpoints.router)
@@ -38,7 +57,6 @@ app.include_router(endpoints.router)
 # Mount the frontend directory to serve static files (HTML, CSS, JS)
 app.mount("/frontend", StaticFiles(directory="frontend"), name="frontend")
 
-
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)

config.py

@@ -5,76 +5,117 @@ Centralized configuration for the Live Radio Karaoke application.
 import os
 
 # ASR Model Configuration
-MODEL_DIR = "./sherpa-onnx-streaming-zipformer-en-20M-2023-02-17"
-REPO_ID = "csukuangfj/sherpa-onnx-streaming-zipformer-en-20M-2023-02-17"
+MODEL_DIR_EN = "./sherpa-onnx-streaming-zipformer-en-20M-2023-02-17"
+REPO_ID_EN = "csukuangfj/sherpa-onnx-streaming-zipformer-en-20M-2023-02-17"
+
+MODEL_DIR_FR = "./sherpa-onnx-streaming-zipformer-fr-kroko-2025-08-06"
+REPO_ID_FR = "csukuangfj/sherpa-onnx-streaming-zipformer-fr-kroko-2025-08-06"
+
+# Current model in use
+CURRENT_MODEL = "en"  # Default to English
+MODEL_DIRS = {
+    "en": MODEL_DIR_EN,
+    "fr": MODEL_DIR_FR
+}
+REPO_IDS = {
+    "en": REPO_ID_EN,
+    "fr": REPO_ID_FR
+}
 
 # Radio Station Configuration
 RADIO_URLS = {
     ## English
-
-    # Existing English stations
     "KEXP (Seattle, 64 kbps)": "https://kexp.streamguys1.com/kexp64.aac",
     "KEXP (Seattle, 160 kbps)": "https://kexp.streamguys1.com/kexp160.aac",
     "NPR": "https://npr-ice.streamguys1.com/live.mp3",
     "WYPR 88.1 FM (Baltimore)": "https://wtmd-ice.streamguys1.com/wypr-1-mp3",
     "WAMU 88.5 FM (Washington DC)": "https://wamu.cdnstream1.com/wamu.mp3",
     "BBC World Service": "http://stream.live.vc.bbcmedia.co.uk/bbc_world_service",
-
-    # BBC UK talk & news
     "BBC Radio 4 (UK)": "http://stream.live.vc.bbcmedia.co.uk/bbc_radio_fourfm",
     "BBC Radio 5 Live (UK)": "http://stream.live.vc.bbcmedia.co.uk/bbc_radio_five_live_online_nonuk",
     "BBC Radio 2 (UK)": "http://stream.live.vc.bbcmedia.co.uk/bbc_radio_two",
-
-    # US public radio / talk
     "KQED NPR (San Francisco)": "https://streams.kqed.org/kqedradio",
     "WNYC 93.9 FM (New York)": "http://stream.wnyc.org/wnycfm",
     "WBUR 90.9 FM (Boston)": "http://icecast.wbur.org/wbur",
     "KPCC 89.3 FM (Los Angeles)": "http://kpcclive.streamguys1.com/kpcc64.aac",
     "WHYY 90.9 FM (Philadelphia)": "http://whyy.streamguys1.com/whyy-mp3",
-
-    # International English news
     "ABC News Radio (Australia)": "http://live-radio01.mediahubaustralia.com/PBW/mp3/",
     "CBC Radio One (Toronto)": "http://cbc_r1_tor.akacast.akamaistream.net/7/15/451661/v1/rc.akacast.akamaistream.net/cbc_r1_tor",
     "Voice of America (VOA News Now)": "https://voa-18.akacast.akamaistream.net/7/983/437752/v1/ibb.akacast.akamaistream.net/voa-18",
-    "Al Jazeera English (Audio)": "https://live-hls-web-aje.getaj.net/AJE/01.m3u8",  # works with ffmpeg
-
-    # Extra talk / variety
+    "Al Jazeera English (Audio)": "https://live-hls-web-aje.getaj.net/AJE/01.m3u8",
     "PRI The World": "http://stream.pri.org:8000/pri.mp3",
-    "Radio Paradise (USA, Mix)": "http://stream.radioparadise.com/mp3-128",  # music + talk segments
+    "Radio Paradise (USA, Mix)": "http://stream.radioparadise.com/mp3-128",
     "KCRW 89.9 FM (Santa Monica)": "http://kcrw.streamguys1.com/kcrw_192",
 
     ## French
-
-    "France Inter", "https://direct.franceinter.fr/live/franceinter-midfi.mp3",
+    "France Inter": "https://direct.franceinter.fr/live/franceinter-midfi.mp3",
+    "France Info": "https://direct.franceinfo.fr/live/franceinfo-midfi.mp3",
+    "France Culture": "https://direct.franceculture.fr/live/franceculture-midfi.mp3",
+    "FIP": "https://direct.fip.fr/live/fip-midfi.mp3",
+    "Radio Classique": "https://radioclassique.ice.infomaniak.ch/radioclassique-high.mp3",
 }
 
+# Map stations to languages
+STATION_LANGUAGES = {
+    "France Inter": "fr",
+    "France Info": "fr",
+    "France Culture": "fr",
+    "FIP": "fr",
+    "Radio Classique": "fr",
+}
 
+# Default to English for all other stations
+for station in RADIO_URLS:
+    if station not in STATION_LANGUAGES:
+        STATION_LANGUAGES[station] = "en"
 
-# Default station (can be changed)
+# Default station
 DEFAULT_RADIO_URL = RADIO_URLS["NPR"]
 
 # Audio Processing Configuration
-# 6400 bytes = 3200 samples (s16le) = 0.2 seconds of audio
 CHUNK_SIZE = 6400
 SAMPLE_RATE = 16000
 BYTES_PER_SAMPLE = 2  # s16le format is 16-bit -> 2 bytes
 
+def get_current_model_dir():
+    """Returns the current model directory based on CURRENT_MODEL setting."""
+    return MODEL_DIRS.get(CURRENT_MODEL, MODEL_DIR_EN)
+
+def get_current_repo_id():
+    """Returns the current repo ID based on CURRENT_MODEL setting."""
+    return REPO_IDS.get(CURRENT_MODEL, REPO_ID_EN)
+
 def get_asr_config() -> dict:
     """
     Returns the configuration dictionary for the sherpa-onnx ASR model.
     Checks for the existence of model files.
     """
-    if not os.path.exists(os.path.join(MODEL_DIR, "tokens.txt")):
+    model_dir = get_current_model_dir()
+    
+    if not os.path.exists(os.path.join(model_dir, "tokens.txt")):
         raise FileNotFoundError(
-            f"ASR model not found in {MODEL_DIR}. "
+            f"ASR model not found in {model_dir}. "
             "Please run the download script or ensure the path is correct."
         )
 
+    # Use int8 models if available, otherwise fallback to regular models
+    encoder_path = os.path.join(model_dir, "encoder-epoch-99-avg-1.int8.onnx")
+    decoder_path = os.path.join(model_dir, "decoder-epoch-99-avg-1.int8.onnx")
+    joiner_path = os.path.join(model_dir, "joiner-epoch-99-avg-1.int8.onnx")
+    
+    # Fallback to non-int8 models if int8 versions don't exist
+    if not os.path.exists(encoder_path):
+        encoder_path = os.path.join(model_dir, "encoder.onnx")
+    if not os.path.exists(decoder_path):
+        decoder_path = os.path.join(model_dir, "decoder.onnx")
+    if not os.path.exists(joiner_path):
+        joiner_path = os.path.join(model_dir, "joiner.onnx")
+
     return {
-        "tokens": os.path.join(MODEL_DIR, "tokens.txt"),
-        "encoder": os.path.join(MODEL_DIR, "encoder-epoch-99-avg-1.int8.onnx"),
-        "decoder": os.path.join(MODEL_DIR, "decoder-epoch-99-avg-1.int8.onnx"),
-        "joiner": os.path.join(MODEL_DIR, "joiner-epoch-99-avg-1.int8.onnx"),
+        "tokens": os.path.join(model_dir, "tokens.txt"),
+        "encoder": encoder_path,
+        "decoder": decoder_path,
+        "joiner": joiner_path,
         "enable_endpoint_detection": True,
         "num_threads": os.cpu_count() or 1,
         "rule3_min_utterance_length": 300,

core/asr_service.py

@@ -1,3 +1,4 @@
+# core/asr_service.py
 """
 Handles the real-time speech-to-text transcription using sherpa-onnx.
 """
@@ -6,7 +7,7 @@ import logging
 from typing import Tuple
 import numpy as np
 import sherpa_onnx
-from config import get_asr_config, SAMPLE_RATE
+from config import get_asr_config, SAMPLE_RATE, CURRENT_MODEL
 from core.connection_manager import ConnectionManager
 
 logger = logging.getLogger(__name__)
@@ -20,7 +21,8 @@ class ASRService:
         self.asr_config = get_asr_config()
         self.recognizer = sherpa_onnx.OnlineRecognizer.from_transducer(**self.asr_config)
         self.stream = self.recognizer.create_stream()
-        logger.info("ASR Service initialized.")
+        self.current_model = CURRENT_MODEL
+        logger.info(f"ASR Service initialized with {self.current_model} model.")
 
     def _process_chunk(self, pcm_chunk: bytes) -> dict | None:
         """Processes a single PCM chunk with the ASR recognizer."""
@@ -53,6 +55,23 @@ class ASRService:
 
         try:
             while True:
+                # Check if model needs to be switched
+                from config import CURRENT_MODEL
+                if CURRENT_MODEL != self.current_model:
+                    logger.info(f"Switching ASR model from {self.current_model} to {CURRENT_MODEL}")
+                    # Release old model
+                    if self.stream:
+                        del self.stream
+                    if self.recognizer:
+                        del self.recognizer
+                    
+                    # Load new model
+                    self.asr_config = get_asr_config()
+                    self.recognizer = sherpa_onnx.OnlineRecognizer.from_transducer(**self.asr_config)
+                    self.stream = self.recognizer.create_stream()
+                    self.current_model = CURRENT_MODEL
+                    logger.info(f"ASR model switched to {self.current_model}")
+
                 pcm_chunk, chunk_start_time = await self.pcm_queue.get()
 
                 if current_utterance_abs_start_time is None:

frontend/index.html

@@ -14,6 +14,10 @@
                 <option value="">Loading stations...</option>
             </select>
         </div>
+        <div class="settings-bar">
+            <label>Language:</label>
+            <span id="language-indicator">English</span>
+        </div>
         <div class="controls">
             <button id="playBtn" onclick="play()">▶️ PLAY</button>
             <button id="stopBtn" onclick="stop()">⏹️ STOP</button>

frontend/js/main.js

@@ -29,7 +29,12 @@ const syncSlider = document.getElementById('sync-offset-slider');
 const syncValueSpan = document.getElementById('sync-offset-value');
 const stationSelector = document.getElementById('station-selector');
 
+// Add to the global variables section
+let currentLanguage = 'en';
+const languageIndicator = document.getElementById('language-indicator');
+
 // Fetch available stations from the backend
+// Update the loadStations function to include language info
 async function loadStations() {
     try {
         const response = await fetch('/api/stations');
@@ -62,6 +67,7 @@ async function loadStations() {
     }
 }
 
+// Update the play function to detect language from station
 function play() {
     if (status === 'CONNECTING' || status === 'PLAYING') return;
 
@@ -70,6 +76,11 @@ function play() {
     // Get selected station
     currentStation = stationSelector.value;
     
+    // Update language indicator
+    const stationLanguage = getStationLanguage(currentStation);
+    currentLanguage = stationLanguage;
+    updateLanguageIndicator();
+    
     status = 'CONNECTING';
     updateUI();
     const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
@@ -89,8 +100,17 @@ function play() {
             handleAudio(new Uint8Array(event.data));
         } else {
             const msg = JSON.parse(event.data);
-            if (msg.type === 'config') { handleConfig(msg.payload); }
-            else if (msg.type === 'asr') { handleAsr(msg.payload); }
+            if (msg.type === 'config') { 
+                handleConfig(msg.payload); 
+            }
+            else if (msg.type === 'asr') { 
+                handleAsr(msg.payload); 
+            }
+            else if (msg.type === 'language') {
+                // Update language indicator when receiving language info from backend
+                currentLanguage = msg.payload.language;
+                updateLanguageIndicator();
+            }
         }
     };
 
@@ -177,6 +197,7 @@ function initializePlayer() {
     mediaSource.addEventListener('sourceopen', setupBuffer, { once: true });
 }
 
+// Update the handleConfig function
 function handleConfig(payload) {
     console.log(`MIME type received: ${payload.mime}`);
     mime = payload.mime;
@@ -273,6 +294,7 @@ function renderAllUtterances() {
     utteranceHistory.forEach(utterance => renderNewUtterance(utterance));
 }
 
+// Update the handleAsr function to include language info
 function handleAsr(asrPayload) {
     if (!audio || audio.readyState < 1) return;
 
@@ -384,6 +406,29 @@ function updateUI() {
     stationSelector.disabled = status !== 'STOPPED';
 }
 
+// Add new function to determine station language
+function getStationLanguage(stationName) {
+    // This would normally come from the backend
+    const frenchStations = [
+        "France Inter", "France Info", "France Culture", 
+        "FIP", "Radio Classique"
+    ];
+    
+    return frenchStations.includes(stationName) ? 'fr' : 'en';
+}
+
+// Add new function to update language indicator
+function updateLanguageIndicator() {
+    const languageNames = {
+        'en': 'English',
+        'fr': 'French'
+    };
+    
+    languageIndicator.textContent = languageNames[currentLanguage] || 'Unknown';
+    languageIndicator.style.color = currentLanguage === 'fr' ? '#1DB954' : '#4A90E2';
+}
+
+
 // Load stations when the page loads
 document.addEventListener('DOMContentLoaded', loadStations);
 
@@ -400,4 +445,20 @@ stationSelector.addEventListener('change', () => {
 window.addEventListener('resize', function() {
     // Maintain scroll position to bottom when resizing
     setTimeout(scrollToLastUtterance, 100);
+});
+
+
+// Handle station change
+stationSelector.addEventListener('change', () => {
+    // Update language indicator immediately when station changes
+    const selectedStation = stationSelector.value;
+    const stationLanguage = getStationLanguage(selectedStation);
+    currentLanguage = stationLanguage;
+    updateLanguageIndicator();
+    
+    if (status === 'PLAYING') {
+        stop();
+        // Brief delay to ensure cleanup before restarting
+        setTimeout(play, 500);
+    }
 });