import gradio as gr import torch from transformers import pipeline from pydub import AudioSegment, effects, silence import os from langdetect import detect from langdetect.lang_detect_exception import LangDetectException # --- Configuration --- #LANG_MODEL_NAME = "openai/whisper-tiny" # modèle léger pour la détection de langue LANG_MODEL_NAME = "openai/whisper-base" # modèle medium pour une meilleure détection de langue device = 0 if torch.cuda.is_available() else "cpu" torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32 # Pipeline léger pour la détection de langue lang_pipe = pipeline( "automatic-speech-recognition", model=LANG_MODEL_NAME, torch_dtype=torch_dtype, device=device, ) # --- Fonctions utilitaires --- def convert_to_wav(audio_path): """Converte qualquer arquivo de áudio para WAV mono 16 kHz.""" try: audio = AudioSegment.from_file(audio_path) audio = audio.set_channels(1) audio = audio.set_frame_rate(16000) wav_path = os.path.splitext(audio_path)[0] + ".wav" audio.export(wav_path, format="wav") return wav_path except Exception as e: print(f"Erro ao converter para WAV: {e}") return None def make_speech_head_wav(input_wav_path, max_seconds=7): """ Version simplifiée et robuste : prend les premiers max_seconds après suppression du silence initial (avec protection contre les boucles). """ try: audio = AudioSegment.from_wav(input_wav_path) # Si l'audio est déjà très court, le retourner tel quel if len(audio) <= max_seconds * 1000: return input_wav_path # Normalisation simple normalized = effects.normalize(audio) # Tentative rapide de suppression du silence initial try: silence_thresh = normalized.dBFS - 20 # Limiter la recherche aux 30 premières secondes maximum search_audio = normalized[:30000] start_trim = silence.detect_leading_silence( search_audio, silence_threshold=silence_thresh, chunk_size=100 ) # Limiter le trim à 15 secondes max pour éviter les cas extrêmes start_trim = min(start_trim, 15000) trimmed = normalized[start_trim:] except: # En cas d'erreur, utiliser l'audio original trimmed = normalized # Si trop court après trim, utiliser l'original if len(trimmed) < 2000: # Moins de 2 secondes trimmed = normalized # Prendre simplement les premiers max_seconds clip = trimmed[:max_seconds * 1000] short_path = os.path.splitext(input_wav_path)[0] + f"_head_{max_seconds}s.wav" clip.export(short_path, format="wav") return short_path except Exception as e: print(f"Erro ao criar o trecho: {e}") # En cas d'erreur, retourner le fichier original return input_wav_path def detect_language_on_upload(filepath): """ Détection rapide et robuste de langue avec timeout et fallbacks. """ if filepath is None: return "auto" try: print(f"Début détection langue pour: {filepath}") wav_filepath = convert_to_wav(filepath) if not wav_filepath: print("Échec conversion WAV") return "auto" # Créer un extrait court (5 secondes max) short_wav = make_speech_head_wav(wav_filepath, max_seconds=7) if not short_wav: short_wav = wav_filepath print(f"Analyse du fichier: {short_wav}") # Transcrição avec paramètres conservateurs outputs = lang_pipe( short_wav, chunk_length_s=5, return_timestamps=False, generate_kwargs={"max_new_tokens": 50} # Limiter pour éviter les timeouts ) transcribed_text = outputs.get("text", "").strip() print(f"Texte transcrit: {transcribed_text[:100]}...") # Priorité au language détecté par Whisper whisper_lang = outputs.get("language") if whisper_lang and isinstance(whisper_lang, str) and len(whisper_lang) <= 5: print(f"Langue Whisper détectée: {whisper_lang}") return whisper_lang # Si texte trop court, retourner auto if len(transcribed_text) < 10: print("Texte trop court, retour auto") return "auto" # Fallback avec LangDetect detected_lang = detect(transcribed_text) print(f"Langue LangDetect: {detected_lang}") # Mapping des codes de langue lang_mapping = { 'fr': 'fr', 'en': 'en', 'es': 'es', 'de': 'de', 'it': 'it', 'pt': 'pt', 'nl': 'nl', 'pl': 'pl', 'ru': 'ru', 'ja': 'ja', 'ko': 'ko', 'zh-cn': 'zh', 'zh': 'zh' } result = lang_mapping.get(detected_lang, "auto") print(f"Résultat final: {result}") return result except Exception as e: print(f"Erreur détection langue: {e}") return "auto" def ensure_mp3_same_name_as_input(input_path, source_wav_path): """ Cria um arquivo MP3 com o mesmo nome base do arquivo de entrada. """ try: base, _ = os.path.splitext(os.path.basename(input_path)) mp3_path = f"{base}.mp3" audio = AudioSegment.from_wav(source_wav_path) audio.export(mp3_path, format="mp3", bitrate="192k") return mp3_path except Exception as e: print(f"Erro ao exportar MP3: {e}") return None # --- Fonction principale --- def make_output_mp3(filepath, language_choice): """ Conversion audio vers MP3 avec détection de langue optimisée. """ if filepath is None: return None, None, "" wav_filepath = convert_to_wav(filepath) if not wav_filepath: return None, None, "" mp3_path = ensure_mp3_same_name_as_input(filepath, wav_filepath) # Information sur la langue if language_choice == "auto": language_info = "Langue détectée automatiquement" else: language_info = f"Langue détectée: {language_choice}" return mp3_path, mp3_path, language_info # --- Interface Gradio --- with gr.Blocks() as demo: gr.HTML("

Conversion audio vers format MP3

") gr.Markdown("Uploadez un fichier audio. La sortie sera toujours un .mp3 avec le même nom de base, écoutable en ligne et téléchargeable.") gr.Markdown(""" ## ⚡ **Version optimisée** - **Détection rapide** : Analyse les 7 premières secondes (hors silence initial) - **Robuste** : Fonctionne avec tous types de fichiers - **Timeout protection** : Évite les blocages """) with gr.Row(): with gr.Column(): audio_input = gr.Audio(type="filepath", label="Envoyer un fichier audio") language_dropdown = gr.Dropdown( choices=["auto", "fr", "en", "es", "de", "it", "pt", "nl", "pl", "ru", "ja", "ko", "zh"], value="auto", label="Langue (auto = détection automatique)", info="Détection automatique rapide après upload" ) submit_btn = gr.Button("Générer MP3", variant="primary") reset_btn = gr.Button("Reset", variant="secondary") with gr.Column(): language_info_output = gr.Textbox(label="Information sur la langue", lines=1) mp3_download = gr.File(label="Télécharger la sortie (.mp3)") mp3_playback = gr.Audio(label="Écouter la sortie (.mp3)", type="filepath") # Détection automatique de langue lors de l'upload audio_input.change( fn=detect_language_on_upload, inputs=audio_input, outputs=language_dropdown ) submit_btn.click( fn=make_output_mp3, inputs=[audio_input, language_dropdown], outputs=[mp3_download, mp3_playback, language_info_output] ) def reset_fields(): return None, None, "auto", "" reset_btn.click( fn=reset_fields, inputs=[], outputs=[audio_input, mp3_download, language_dropdown, language_info_output] ) demo.launch(share=True)