Flux de Production Karaoké Haute Fidélité

Cette documentation détaille le processus de création de vidéos karaoké professionnelles en combinant l’intelligence artificielle pour la séparation des sources Ultimate Vocal Remover (UVR) et la génération automatisée de sous-titres synchronisés (Script Python).

L’idée de base est de convertir automatiquement un fichier MP3 en fichier karaoké MP4.

Les tests ont été réalisés avec succès sous Windows 11.

1. Phase d’Extraction : Ultimate Vocal Remover (UVR)

La qualité d’un karaoké dépend avant tout de la propreté de la séparation entre la voix et l’instrumentale. UVR est l’outil de référence utilisant des modèles de réseaux de neurones profonds.

Choix des Modèles Recommandés

Pour obtenir les meilleurs résultats, nous préconisons l’utilisation de l’architecture MDX-NET avec les modèles suivants :

Pour l’Instrumentale : UVR-MDX-NET Inst HQ3
- Pourquoi : Ce modèle est optimisé pour préserver la dynamique musicale et minimiser les artefacts « fantômes » de voix dans la piste musicale.
Pour les Voix : UVR-MDX-NET-Voc_FT
- Pourquoi : Le « Voc_FT » (Fine-Tuned) offre une clarté exceptionnelle sur les fréquences vocales, ce qui est crucial pour que l’IA de transcription (Whisper) puisse analyser précisément chaque syllabe.

L’importance du format WAV

Il est impératif d’exporter vos fichiers depuis UVR au format WAV (PCM 16/24-bit) plutôt qu’en MP3 :

Absence de compression : Le MP3 élimine des fréquences subtiles dont l’IA a besoin pour une synchronisation parfaite.
Précision temporelle : Les fichiers WAV garantissent qu’aucun décalage (jitter) n’est introduit lors du rendu FFmpeg.

2. Phase de Génération : Karaoké Generator Pro

Une fois vos fichiers .wav extraits (une piste vocal.wav et une piste instru.wav), le script prend le relais pour transformer ces données en une vidéo finale.

Pourquoi utiliser ce script après UVR ?

Transcription Automatisée : Utilise stable-whisper pour une détection ultra-précise du texte à partir de la piste vocale isolée.
Synchronisation Syllabique : Le script calcule le timing exact de chaque mot pour créer l’effet de remplissage progressif (balises \k) typique du karaoké professionnel.
Rendu Tout-en-Un : Il fusionne automatiquement l’audio instrumental, les sous-titres ASS et une vidéo de fond via FFmpeg.

3. Guide d’utilisation du Script

Interface et Paramètres

Sélection des fichiers :
- Vocal : Indiquez la piste voix extraite par UVR (sert à l’analyse du texte).
- Instru : Indiquez la piste musique (sera l’audio de la vidéo finale).
- Fond : Optionnel. Si vide, le fond sera noir.
Configuration IA :
- Modèle : large est recommandé pour une précision maximale, medium pour plus de rapidité.
- Mots par segment : Ajustez (entre 5 et 10) pour contrôler la densité de texte à l’écran.
Paramètres Vidéo :
- Offset : Permet d’ajuster la synchronisation globale (ex: 0.1s) pour compenser la latence naturelle de l’IA.
- Mode Progressif : Active l’animation de couleur sur les lettres au fur et à mesure du chant.

Gestion des Profils

Le script permet de sauvegarder vos réglages (résolution, FPS, modèle) sous forme de Profils. Cela est idéal pour basculer rapidement entre un format « YouTube » (1920×1080) et un format « TikTok/Shorts » (1080×1920).

4. Conseils pour un rendu optimal

Nettoyage préalable : Si la chanson comporte des choeurs très forts, UVR peut parfois hésiter. N’hésitez pas à utiliser le modèle UVR-MDX-NET-Voc_FT une seconde fois sur la piste vocale extraite pour l’épurer davantage.
Vérification des Logs : La console intégrée au script affiche en temps réel le temps de transcription et de rendu. Si FFmpeg échoue, vérifiez que les chemins de fichiers ne contiennent pas de caractères spéciaux exotiques.
Hardware : La génération avec le modèle large de Whisper est gourmande. Une carte graphique (GPU) compatible CUDA accélérera considérablement le processus.

Pour faire fonctionner le script Karaoké Generator Pro et l’intégration avec UVR, vous devez configurer un environnement Python avec plusieurs bibliothèques spécifiques.

Voici la liste des commandes à exécuter dans votre terminal pour installer les dépendances nécessaires :

5. Installation des dépendances Python (Pip)

Ouvrez votre terminal (ou invite de commande) et exécutez la commande suivante :

Shell

pip install customtkinter stable-whisper torch torchvision torchaudio

6. Dépendance Système : FFmpeg (Indispensable)

Le script utilise subprocess pour appeler FFmpeg, l’outil qui fusionne l’audio, la vidéo et les sous-titres. Il ne s’installe pas via pip.

Téléchargement : Allez sur ffmpeg.org.
Configuration : Assurez-vous que le dossier bin de FFmpeg est ajouté à votre PATH système (variables d’environnement).
Vérification : Tapez ffmpeg -version dans un terminal. Si une description s’affiche, le script fonctionnera.

7. Configuration pour l’accélération GPU (Optionnel)

Si vous possédez une carte graphique NVIDIA, l’extraction et la transcription seront beaucoup plus rapides. Pour cela, vous devez installer une version de PyTorch compatible avec CUDA.

Rendez-vous sur pytorch.org pour obtenir la ligne de commande spécifique à votre version de CUDA, qui ressemble généralement à ceci :

Shell

pip install torch torchvision torchaudio –index-url https://download.pytorch.org/whl/cu118

8. Structure des dossiers

Le script s’attend à pouvoir créer et lire dans certains répertoires spécifiques. Assurez-vous d’avoir les droits d’écriture dans le dossier du script. Il créera automatiquement :

uvr/ : Pour stocker les fichiers .ass.
uvr/mp4/ : Pour les vidéos finales.

9. Vidéos de fonds

Pour parfaire l’aspect visuel de vos créations, le choix du fond vidéo est crucial. Voici comment optimiser cette étape pour obtenir un rendu professionnel avec votre script.

Choix des fonds : Vidéos en boucle (Loops)

L’utilisation de boucles vidéo permet de maintenir une dynamique visuelle sans détourner l’attention des paroles du karaoké.

Où trouver des fonds de qualité ?

Par exemple, le site Pixabay est une ressource excellente pour télécharger des contenus libres de droits. Pour des vidéos qui s’adaptent parfaitement au rythme de la musique, nous vous recommandons d’effectuer la recherche suivante :

Lien direct : Pixabay – Abstract Motion Graphics Loop
Mots-clés suggérés : « abstract motion graphics loop song », « VJ loop », « particle background » ou « geometric rhythm ».

Pourquoi privilégier ces termes de recherche ?

Neutralité visuelle : Les graphismes abstraits ne contiennent pas d’éléments narratifs qui pourraient entrer en conflit avec le sens de la chanson.
Adaptabilité : Ces vidéos n’ont généralement pas de « haut » ou de « bas » marqué, ce qui facilite leur utilisation en format paysage (16:9) ou portrait (9:16 pour TikTok/Shorts).
Fluidité : Le terme « loop » garantit que le script peut répéter la vidéo indéfiniment sans saut d’image visible si la chanson est plus longue que le clip.

Intégration technique dans le script

Votre script gère intelligemment ces fichiers grâce à l’argument -stream_loop -1 de FFmpeg.

Fonctionnement de la boucle

Répétition infinie : Même si vous téléchargez une boucle de 10 secondes sur Pixabay, le script la répétera automatiquement pour couvrir toute la durée de votre piste audio instrumentale.
Ajustement automatique : Le script applique un filtre de mise à l’échelle (scale) et de recadrage (crop) pour s’assurer que la vidéo de fond remplit parfaitement la résolution choisie (ex: 1920×1080), évitant ainsi les bandes noires.

Conseil pratique

Lors du téléchargement sur Pixabay, privilégiez le format MP4 en résolution 1080p (HD). Une fois le fichier récupéré, renseignez simplement son emplacement dans le champ « Vidéo de fond » de l’interface KaraokeApp avant de lancer la génération.

Conclusion : Vers une Création de Karaoké Semi-Automatisée et Professionnelle

L’alliance entre la puissance de séparation des sources de Ultimate Vocal Remover et l’automatisation de la synchronisation syllabique via Karaoké Generator Pro offre un flux de travail complet, rapide et de haute fidélité. En exploitant des modèles spécialisés comme UVR-MDX-NET Inst HQ3 pour l’instrumentale et UVR-MDX-NET-Voc_FT pour l’analyse vocale, l’utilisateur s’assure d’une base technique solide. L’utilisation du format WAV et l’intégration de fonds visuels dynamiques provenant de plateformes comme Pixabay permettent de transformer de simples fichiers audio en vidéos prêtes pour la diffusion.

Possibilités d’améliorations et d’extensions

Bien que le script fourni soit robuste, plusieurs axes peuvent être explorés pour enrichir l’expérience utilisateur et la qualité esthétique :

Personnalisation Avancée des Styles ASS :
- Modifier le script pour permettre à l’utilisateur de choisir ses propres polices, couleurs et effets de bordure directement depuis l’interface graphique.
- Ajouter des animations de transition pour l’apparition et la disparition des segments de texte.
Optimisation du Rendu Vidéo :
- Assombrissement automatique : Intégrer un filtre FFmpeg (ex: drawbox ou overlay) pour appliquer un voile noir transparent sur le fond vidéo, améliorant ainsi le contraste et la lisibilité des paroles.
- Prévisualisation en direct : Ajouter un lecteur vidéo léger dans le script pour vérifier la synchronisation sans attendre le rendu complet.
Intelligence Artificielle et Post-traitement :
- Détection automatique de la langue : Laisser Whisper détecter la langue source pour automatiser encore davantage le processus.
- Nettoyage automatique des fichiers : Intégrer un script de post-traitement audio pour normaliser le volume de la piste instrumentale avant le rendu final.
Extensions Multi-plateformes :
- Ajouter des préréglages de résolution spécifiques pour les réseaux sociaux, comme le format 9:16 (1080×1920) avec un recadrage intelligent du fond vidéo pour les Shorts ou TikTok.

Source

gui_kar Télécharger

Python

import customtkinter as ctk
from tkinter import filedialog, messagebox
import threading
import json
import os
import subprocess
import time  # Importé pour le chronométrage
from pathlib import Path
from datetime import timedelta
import stable_whisper

# — CONFIGURATION —
PROFILES_FILE = "karaoke_profiles.json"
CONFIG_FILE = "app_settings.json"  # Fichier pour la position et les réglages courants

def format_duration(seconds: float) -> str:
    """Formate une durée en mm:ss"""
    seconds = int(round(seconds))
    minutes = seconds // 60
    secs = seconds % 60
    return f"{minutes:02d}:{secs:02d}"

def render_karaoke_mp4(instrumental_wav: Path, ass_file: Path, output_mp4: Path, bg_video_path: Path = None, 
    resolution="1920×1080", fps=30, audio_bitrate="256k"):
    
    ass_filter_path = str(ass_file).replace("\\", "/").replace(":", "\\:")

    if bg_video_path and bg_video_path.exists():
        input_bg = ["-stream_loop", "-1", "-i", str(bg_video_path)]
    else:
        input_bg = ["-f", "lavfi", "-i", f"color=size={resolution}:rate={fps}:color=black"]
    
    cmd = [
        "ffmpeg", "-y",
    ] + input_bg + [
        "-i", str(instrumental_wav),
        "-vf", f"scale={resolution.replace('x', ':')}:force_original_aspect_ratio=increase,crop={resolution.replace('x', ':')},ass='{ass_filter_path}'",
        "-c:v", "libx264",
        "-preset", "slow",
        "-crf", "18",
        "-pix_fmt", "yuv420p",
        "-c:a", "aac",
        "-b:a", audio_bitrate,
        "-shortest",
        str(output_mp4)
    ]
    
    subprocess.run(cmd, check=True)

def format_ass_time(seconds):
    if seconds < 0: seconds = 0
    td = timedelta(seconds=seconds)
    total_seconds = int(td.total_seconds())
    hours = total_seconds // 3600
    minutes = (total_seconds % 3600) // 60
    secs = total_seconds % 60
    cs = int(td.microseconds / 10000)
    return f"{hours}:{minutes:02d}:{secs:02d}.{cs:02d}"

def decouper_segments(segments, max_mots=8):
    nouveaux_segments = []
    for seg in segments:
        mots = seg.words
        if len(mots) <= max_mots:
            nouveaux_segments.append(seg)
        else:
            for i in range(0, len(mots), max_mots):
                sous_groupe = mots[i:i + max_mots]
                nouveaux_segments.append({
                    'start': sous_groupe[0].start,
                    'end': sous_groupe[-1].end,
                    'words': sous_groupe,
                    'text': "".join([m.word for m in sous_groupe]).strip()
                })
    return nouveaux_segments

def generer_karaoke(chemin_audio, chemin_resultat_ass, max_mots=8, decalage_manuel=0.1, progressif=True, langage="fr", model_name="large"):
    model = stable_whisper.load_model(model_name)
    result = model.transcribe(chemin_audio, language=langage)
    segments_optimises = decouper_segments(result.segments, max_mots=max_mots)
    
    ass_header = """[Script Info]
ScriptType: v4.00+
PlayResX: 1280
PlayResY: 720

[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Actif,Arial,48,&H00FFFFFF,&H0000FF00,&H00000000,&H00000000,-1,0,0,0,100,100,0,0,1,3,0,2,20,20,180,1
Style: Suivant,Arial,40,&H80FFFFFF,&H00FFFFFF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,0,2,20,20,80,1

[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
"""
    with open(chemin_resultat_ass, 'w', encoding='utf-8') as f:
        f.write(ass_header)
        num_segments = len(segments_optimises)
        for i in range(num_segments):
            current = segments_optimises[i]
            
            # Gestion accès dictionnaire ou objet
            c_start = current.start if hasattr(current, 'start') else current['start']
            c_end = current.end if hasattr(current, 'end') else current['end']
            c_words = current.words if hasattr(current, 'words') else current['words']
            c_text = current.text if hasattr(current, 'text') else current['text']

            if i > 0:
                prev = segments_optimises[i-1]
                start_display_raw = prev.end if hasattr(prev, 'end') else prev['end']
            else:
                start_display_raw = c_start
            
            end_display_raw = c_end
            
            if not progressif:
                karaoke_text = c_text
            else:
                first_word_start = c_words[0].start + decalage_manuel
                silence_initial = int(max(0, (first_word_start – start_display_raw) * 100))
                karaoke_text = f"{{\\k{silence_initial}}}" if silence_initial > 0 else ""
                for word in c_words:
                    duration = int(max(1, (word.end – word.start) * 100))
                    karaoke_text += f"{{\\k{duration}}}{word.word}"
            
            start_t = format_ass_time(start_display_raw)
            end_t = format_ass_time(end_display_raw)
            f.write(f"Dialogue: 1,{start_t},{end_t},Actif,,0,0,0,,{karaoke_text}\n")
            
            if i + 1 < num_segments:
                next_seg = segments_optimises[i+1]
                next_text = next_seg.text.strip() if hasattr(next_seg, 'text') else next_seg['text'].strip()
                f.write(f"Dialogue: 0,{start_t},{end_t},Suivant,,0,0,0,,{next_text}\n")

class KaraokeApp(ctk.CTk):
    def __init__(self):
        super().__init__()

        self.title("Karaoké Generator Pro")
        self.geometry("1000×920")
        ctk.set_appearance_mode("dark")

        # — État interne —
        self.current_process = None
        self.stop_requested = False

        # — Variables —
        self.vocal_path = ctk.StringVar()
        self.instru_path = ctk.StringVar()
        self.bg_path = ctk.StringVar()
        self.model_var = ctk.StringVar(value="large")
        self.lang_var = ctk.StringVar(value="fr")
        self.res_var = ctk.StringVar(value="1920×1080")
        self.fps_var = ctk.IntVar(value=30)
        self.offset_var = ctk.DoubleVar(value=0.1)
        self.prog_var = ctk.BooleanVar(value=True)

        self.setup_ui()
        self.load_profiles_list()
        
        # Charger les réglages précédents
        self.load_app_settings()

        # Intercepter la fermeture de la fenêtre
        self.protocol("WM_DELETE_WINDOW", self.on_closing)

    def setup_ui(self):
        self.grid_columnconfigure(0, weight=1)

        # — SECTION : PROFILS —
        prof_frame = ctk.CTkFrame(self)
        prof_frame.pack(fill="x", padx=20, pady=(15, 5))
        ctk.CTkLabel(prof_frame, text="Profil :", font=("", 12, "bold")).pack(side="left", padx=10)
        self.profile_menu = ctk.CTkComboBox(prof_frame, values=["Par défaut"], command=self.apply_profile)
        self.profile_menu.pack(side="left", padx=10, fill="x", expand=True)
        ctk.CTkButton(prof_frame, text="Sauver", width=80, command=self.save_profile).pack(side="left", padx=5)
        ctk.CTkButton(prof_frame, text="Supprimer", width=80, fg_color="#A12222", command=self.delete_profile).pack(side="left", padx=5)

        # — SECTION : FICHIERS —
        file_frame = ctk.CTkFrame(self)
        file_frame.pack(fill="x", padx=20, pady=10)
        ctk.CTkLabel(file_frame, text="Sélection des fichiers sources", font=("", 14, "bold")).pack(pady=5)
        self.add_file_row(file_frame, "Vocal (Analyse) :", self.vocal_path)
        self.add_file_row(file_frame, "Instru (Sortie) :", self.instru_path)
        self.add_file_row(file_frame, "Vidéo de fond :", self.bg_path)

        # — CONTENEUR PARAMÈTRES —
        param_container = ctk.CTkFrame(self, fg_color="transparent")
        param_container.pack(fill="x", padx=20, pady=5)
        
        # Section IA
        self.ia_box = ctk.CTkFrame(param_container)
        self.ia_box.pack(side="left", fill="both", expand=True, padx=(0, 5))
        self.ia_box.grid_columnconfigure(1, weight=1)
        ctk.CTkLabel(self.ia_box, text="Paramètres IA", font=("", 13, "bold")).grid(row=0, column=0, columnspan=2, pady=10)
        self.add_grid_row(self.ia_box, 1, "Modèle :", ctk.CTkComboBox(self.ia_box, values=["tiny", "base", "small", "medium", "large"], variable=self.model_var))
        self.add_grid_row(self.ia_box, 2, "Langue :", ctk.CTkEntry(self.ia_box, textvariable=self.lang_var))
        self.word_label = ctk.CTkLabel(self.ia_box, text="Mots par segment : 8")
        self.word_label.grid(row=3, column=0, columnspan=2, pady=(10,0))
        self.word_slider = ctk.CTkSlider(self.ia_box, from_=3, to=15, command=self.update_word_text)
        self.word_slider.set(8)
        self.word_slider.grid(row=4, column=0, columnspan=2, padx=10, pady=(0,10), sticky="ew")

        # Section Vidéo
        self.vid_box = ctk.CTkFrame(param_container)
        self.vid_box.pack(side="left", fill="both", expand=True, padx=(5, 0))
        self.vid_box.grid_columnconfigure(1, weight=1)
        ctk.CTkLabel(self.vid_box, text="Paramètres Vidéo", font=("", 13, "bold")).grid(row=0, column=0, columnspan=2, pady=10)
        self.add_grid_row(self.vid_box, 1, "Résolution :", ctk.CTkComboBox(self.vid_box, values=["1920×1080", "1280×720", "1080×1920"], variable=self.res_var))
        self.add_grid_row(self.vid_box, 2, "FPS :", ctk.CTkEntry(self.vid_box, textvariable=self.fps_var))
        self.add_grid_row(self.vid_box, 3, "Offset (s) :", ctk.CTkEntry(self.vid_box, textvariable=self.offset_var))
        ctk.CTkCheckBox(self.vid_box, text="Mode Progressif", variable=self.prog_var).grid(row=4, column=0, columnspan=2, pady=10)

        # — LOGS & ACTIONS —
        action_frame = ctk.CTkFrame(self, fg_color="transparent")
        action_frame.pack(fill="x", padx=20, pady=10)
        self.start_btn = ctk.CTkButton(action_frame, text="Lancer la génération", height=45, fg_color="#1f6aa5", font=("", 14, "bold"), command=self.start_thread)
        self.start_btn.pack(side="left", fill="x", expand=True, padx=(0, 5))
        self.cancel_btn = ctk.CTkButton(action_frame, text="Annuler", height=45, fg_color="grey", state="disabled", command=self.request_stop)
        self.cancel_btn.pack(side="left", fill="x", expand=True, padx=(5, 0))

        self.log_box = ctk.CTkTextbox(self, height=250, font=("Consolas", 12))
        self.log_box.pack(fill="both", expand=True, padx=20, pady=(0, 20))

    # — PERSISTANCE —
    def save_app_settings(self):
        """Sauvegarde la position et les réglages actuels"""
        settings = {
            "geometry": self.geometry(),
            "vocal": self.vocal_path.get(),
            "instru": self.instru_path.get(),
            "bg": self.bg_path.get(),
            "model": self.model_var.get(),
            "lang": self.lang_var.get(),
            "res": self.res_var.get(),
            "fps": self.fps_var.get(),
            "offset": self.offset_var.get(),
            "words": self.word_slider.get(),
            "prog": self.prog_var.get()
        }
        with open(CONFIG_FILE, "w") as f:
            json.dump(settings, f)

    def load_app_settings(self):
        """Restaure la position et les réglages"""
        if os.path.exists(CONFIG_FILE):
            try:
                with open(CONFIG_FILE, "r") as f:
                    s = json.load(f)
                    self.geometry(s.get("geometry", "1000×920"))
                    self.vocal_path.set(s.get("vocal", ""))
                    self.instru_path.set(s.get("instru", ""))
                    self.bg_path.set(s.get("bg", ""))
                    self.model_var.set(s.get("model", "large"))
                    self.lang_var.set(s.get("lang", "fr"))
                    self.res_var.set(s.get("res", "1920×1080"))
                    self.fps_var.set(s.get("fps", 30))
                    self.offset_var.set(s.get("offset", 0.1))
                    self.word_slider.set(s.get("words", 8))
                    self.update_word_text(s.get("words", 8))
                    self.prog_var.set(s.get("prog", True))
            except:
                pass

    def on_closing(self):
        """Action à la fermeture"""
        self.save_app_settings()
        self.destroy()

    # — HELPERS UI —
    def add_grid_row(self, parent, row_idx, label_text, widget):
        lbl = ctk.CTkLabel(parent, text=label_text, width=100, anchor="w")
        lbl.grid(row=row_idx, column=0, padx=(15, 5), pady=5, sticky="w")
        widget.grid(row=row_idx, column=1, padx=(5, 15), pady=5, sticky="ew")

    def add_file_row(self, parent, label, var):
        row = ctk.CTkFrame(parent, fg_color="transparent")
        row.pack(fill="x", padx=10, pady=3)
        ctk.CTkLabel(row, text=label, width=130, anchor="w").pack(side="left")
        ctk.CTkEntry(row, textvariable=var).pack(side="left", fill="x", expand=True, padx=5)
        ctk.CTkButton(row, text="…", width=40, command=lambda: var.set(filedialog.askopenfilename())).pack(side="right")

    def update_word_text(self, val):
        self.word_label.configure(text=f"Mots par segment : {int(val)}")

    def log(self, msg):
        self.log_box.insert("end", f"> {msg}\n")
        self.log_box.see("end")

    # — PROFILS —
    def load_all_profiles(self):
        if os.path.exists(PROFILES_FILE):
            with open(PROFILES_FILE, "r") as f: return json.load(f)
        return {}

    def load_profiles_list(self):
        names = list(self.load_all_profiles().keys())
        self.profile_menu.configure(values=names if names else ["Par défaut"])

    def save_profile(self):
        name = self.profile_menu.get()
        if not name or name == "Par défaut": return
        data = self.load_all_profiles()
        data[name] = {
            "model": self.model_var.get(), "lang": self.lang_var.get(), "words": self.word_slider.get(),
            "res": self.res_var.get(), "fps": self.fps_var.get(), "offset": self.offset_var.get(), "prog": self.prog_var.get()
        }
        with open(PROFILES_FILE, "w") as f: json.dump(data, f)
        self.load_profiles_list()
        self.log(f"Profil '{name}' sauvegardé.")

    def apply_profile(self, name):
        data = self.load_all_profiles()
        if name in data:
            p = data[name]
            self.model_var.set(p["model"]); self.lang_var.set(p.get("lang", "fr"))
            self.word_slider.set(p["words"]); self.update_word_text(p["words"])
            self.res_var.set(p["res"]); self.fps_var.set(p["fps"])
            self.offset_var.set(p.get("offset", 0.1)); self.prog_var.set(p.get("prog", True))

    def delete_profile(self):
        name = self.profile_menu.get()
        data = self.load_all_profiles()
        if name in data:
            del data[name]
            with open(PROFILES_FILE, "w") as f: json.dump(data, f)
            self.load_profiles_list()

    # — TRAITEMENT ET CHRONOMÉTRAGE —
    def start_thread(self):
        self.stop_requested = False
        threading.Thread(target=self.process, daemon=True).start()

    def request_stop(self):
        self.stop_requested = True
        if self.current_process:
            self.current_process.terminate()

    def process(self):
        try:
            total_start_time = time.time() # Début chrono global
            self.start_btn.configure(state="disabled")
            self.cancel_btn.configure(state="normal", fg_color="#A12222")
            
            vocal = self.vocal_path.get()
            instru = self.instru_path.get()
            if not vocal or not instru: raise ValueError("Fichiers audio manquants.")
            
            nom = Path(vocal).stem
            ass_path = Path(f"uvr/{nom}.ass")
            output_mp4 = Path(f"uvr/mp4/{nom}.mp4")
            ass_path.parent.mkdir(exist_ok=True); output_mp4.parent.mkdir(exist_ok=True)

            # Étape 1 : Transcription
            self.log("Étape 1 : Transcription Whisper…")
            t1_start = time.time()
            generer_karaoke(vocal, str(ass_path), max_mots=int(self.word_slider.get()), 
                            decalage_manuel=self.offset_var.get(), progressif=self.prog_var.get(),
                            langage=self.lang_var.get(), model_name=self.model_var.get())
            t1_end = time.time()
            self.log(f"⏱ Transcription terminée en {format_duration(t1_end – t1_start)}")

            if self.stop_requested: return

            # Étape 2 : FFmpeg
            self.log("Étape 2 : Rendu FFmpeg…")
            t2_start = time.time()
            self.render_with_ffmpeg(instru, ass_path, output_mp4)
            t2_end = time.time()
            self.log(f"⏱ Rendu vidéo terminé en {format_duration(t2_end – t2_start)}")

            if not self.stop_requested:
                total_duration = time.time() – total_start_time
                self.log(f"\n✅ Terminé avec succès !")
                self.log(f"📁 Vidéo : {output_mp4}")
                self.log(f"⌛ Durée totale : {format_duration(total_duration)}")

        except Exception as e:
            self.log(f"❌ Erreur : {e}")
        finally:
            self.start_btn.configure(state="normal")
            self.cancel_btn.configure(state="disabled", fg_color="grey")

    def render_with_ffmpeg(self, instru, ass_file, output):
        ass_filter = str(ass_file).replace("\\", "/").replace(":", "\\:")
        res = self.res_var.get()
        fps = self.fps_var.get()
        
        if self.bg_path.get():
            input_bg = ["-stream_loop", "-1", "-i", self.bg_path.get()]
        else:
            input_bg = ["-f", "lavfi", "-i", f"color=size={res}:rate={fps}:color=black"]

        cmd = ["ffmpeg", "-y"] + input_bg + ["-i", instru, "-vf", 
               f"scale={res.replace('x',':')}:force_original_aspect_ratio=increase,crop={res.replace('x',':')},ass='{ass_filter}'",
               "-c:v", "libx264", "-crf", "18", "-pix_fmt", "yuv420p", "-c:a", "aac", "-shortest", str(output)]
        
        self.current_process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
        for line in self.current_process.stdout:
            if "frame=" in line:
                pass # Feedback silencieux pour ne pas encombrer le log
        self.current_process.wait()

if __name__ == "__main__":
    app = KaraokeApp()
    app.mainloop()

Flux de Production Karaoké Haute Fidélité

Published by geo on 30 décembre 202530 décembre 2025

1. Phase d’Extraction : Ultimate Vocal Remover (UVR)

Choix des Modèles Recommandés

L’importance du format WAV

2. Phase de Génération : Karaoké Generator Pro

Pourquoi utiliser ce script après UVR ?

3. Guide d’utilisation du Script

Interface et Paramètres

Gestion des Profils

4. Conseils pour un rendu optimal

5. Installation des dépendances Python (Pip)

6. Dépendance Système : FFmpeg (Indispensable)

7. Configuration pour l’accélération GPU (Optionnel)

8. Structure des dossiers

9. Vidéos de fonds

Choix des fonds : Vidéos en boucle (Loops)

Où trouver des fonds de qualité ?

Pourquoi privilégier ces termes de recherche ?

Intégration technique dans le script

Fonctionnement de la boucle

Conseil pratique

Conclusion : Vers une Création de Karaoké Semi-Automatisée et Professionnelle

Possibilités d’améliorations et d’extensions

Source

0 commentaire

Laisser un commentaire Annuler la réponse

Audio Downloader Pro

Project Zipper (Partenaire de Code)

Application de Prévisions Météo (Python/Tkinter)

Flux de Production Karaoké Haute Fidélité

Published by geo on 30 décembre 202530 décembre 2025

1. Phase d’Extraction : Ultimate Vocal Remover (UVR)

Choix des Modèles Recommandés

L’importance du format WAV

2. Phase de Génération : Karaoké Generator Pro

Pourquoi utiliser ce script après UVR ?

3. Guide d’utilisation du Script

Interface et Paramètres

Gestion des Profils

4. Conseils pour un rendu optimal

5. Installation des dépendances Python (Pip)

6. Dépendance Système : FFmpeg (Indispensable)

7. Configuration pour l’accélération GPU (Optionnel)

8. Structure des dossiers

9. Vidéos de fonds

Choix des fonds : Vidéos en boucle (Loops)

Où trouver des fonds de qualité ?

Pourquoi privilégier ces termes de recherche ?

Intégration technique dans le script

Fonctionnement de la boucle

Conseil pratique

Conclusion : Vers une Création de Karaoké Semi-Automatisée et Professionnelle

Possibilités d’améliorations et d’extensions

Source

0 commentaire

Laisser un commentaire Annuler la réponse

Articles similaires

Audio Downloader Pro

Project Zipper (Partenaire de Code)

Application de Prévisions Météo (Python/Tkinter)