Karaoké Master Pro (v1.0)

Cette documentation présente les objectifs, le mode d’emploi et les détails techniques du logiciel de gestion et de diffusion de karaoké MIDI/KAR.

1. Objectifs du Projet

L’objectif principal est de fournir une solution logicielle légère et autonome pour animer des sessions de karaoké. Contrairement aux lecteurs standards, ce script offre une maîtrise totale sur le rendu musical et visuel.

Gestion Thématique : Permettre d’organiser des centaines de fichiers via des listes de lecture personnalisées.
Adaptabilité : Offrir au chanteur la possibilité de modifier la tonalité (transposition) et de couper les pistes inutiles (mélodie guide) sans altérer le fichier original.
Immersion Visuelle : Remplacer l’écran noir classique par un arrière-plan dynamique et élégant pour une ambiance professionnelle.

2. Guide d’Utilisation

Préparation

Installation : Assurez-vous d’avoir Python installé avec les bibliothèques pygame et mido.
Fichiers : Placez vos fichiers .mid ou .kar dans le dossier nommé ori situé au même emplacement que le script.

L’Interface de Gestion

Bibliothèque : À gauche, l’onglet « 🔍 Bibliothèque » liste tous vos fichiers. La barre de recherche filtre les titres instantanément. Cliquez sur « Scan dossiers » pour actualiser la liste si vous ajoutez des chansons.
Playlists : L’onglet « ⭐ Playlists » permet de gérer plusieurs sélections.
- [+] : Créer une nouvelle playlist.
- [🗑️] : Supprimer la playlist actuelle.
- ▲ / ▼ : Réorganiser l’ordre de passage des chansons.
Configuration du morceau : Avant de lancer la musique, cochez les pistes à rendre muettes et ajustez la barre de tonalité si nécessaire. Cliquez sur « 💾 AJOUTER » pour mémoriser ces réglages dans votre playlist.

La Lecture (Mode Karaoké)

Cliquez sur « ▶ LANCER » pour passer en plein écran.
Paroles : Le texte jaune indique ce qu’il faut chanter. Le texte blanc en dessous permet d’anticiper la suite.
Quitter : Appuyez sur la touche ECHAP à tout moment pour revenir à l’interface de gestion.

3. Implémentation Technique

Le logiciel est conçu autour d’une architecture à trois piliers :

A. Persistance des Données (JSON)

L’application ne nécessite pas de base de données complexe. Elle utilise trois fichiers plats :

index_karaoke.json : Stocke le chemin de tous les fichiers scannés.
playlists.json : Contient le dictionnaire des playlists et les paramètres utilisateur (transposition, pistes muettes) associés à chaque titre.
karaoke_config.json : Sauvegarde l’apparence de la fenêtre (taille et position).

B. Moteur de Rendu Dynamique

Le fond d’écran est généré par une classe Particle.

Algorithme : Une douzaine de cercles translucides (« Bokeh ») se déplacent avec des vecteurs de vitesse aléatoires.
Optimisation : Le rendu est limité à 60 FPS pour rester fluide sans surcharger le processeur.
Lisibilité : Une ombre portée noire est générée sous chaque ligne de texte pour garantir que les paroles restent lisibles, même lorsque des motifs clairs passent en arrière-plan.

C. Traitement MIDI à la volée

Lorsqu’un utilisateur modifie la tonalité ou coupe une piste, le script ne modifie pas le fichier source.

Il lit le fichier original via mido.
Il applique un décalage aux messages note_on (sauf sur le canal 9, réservé aux percussions).
Il filtre les pistes mues.
Il enregistre le résultat dans un fichier temporaire temp_output.kar qui est celui réellement lu par le moteur audio.

Python

import pygame
import mido
import time
import threading
import tkinter as tk
from tkinter import filedialog, messagebox, ttk, simpledialog
import json
import os
import random

CONFIG_FILE = "karaoke_config.json"
INDEX_FILE = "index_karaoke.json"
PLAYLIST_FILE = "playlists.json"
DOSSIER_ORI = "ori"
NOTES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']

class KaraokeApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Karaoké Master Pro – Animation & Playlists")
        
        self.chemin_fichier = tk.StringVar()
        self.tonalite_orig = tk.StringVar(value="–")
        self.tonalite_curr = tk.StringVar(value="–")
        self.transposition = tk.IntVar(value=0)
        self.search_var = tk.StringVar()
        
        # Structure : {"Nom Playlist": [{"nom":…, "chemin":…, "mues":…, "transpo":…}, …]}
        self.all_playlists = {"Ma Sélection": []}
        self.current_playlist_name = tk.StringVar(value="Ma Sélection")
        
        self.full_index = []
        self.is_playing = False
        self.stop_requested = False
        
        self.config_chargee = self.charger_config()
        self.setup_ui()
        self.charger_index_existant()
        self.charger_playlists_du_disque()
        
        if "separateur" in self.config_chargee:
            self.root.after(100, lambda: self.paned.sash_place(0, self.config_chargee["separateur"], 0))
            
        self.root.protocol("WM_DELETE_WINDOW", self.quitter_et_sauvegarder)

    def charger_config(self):
        if os.path.exists(CONFIG_FILE):
            try:
                with open(CONFIG_FILE, "r") as f: return json.load(f)
            except: return {}
        return {}

    def charger_playlists_du_disque(self):
        if os.path.exists(PLAYLIST_FILE):
            try:
                with open(PLAYLIST_FILE, "r") as f:
                    data = json.load(f)
                    if isinstance(data, dict) and data:
                        self.all_playlists = data
                        first_name = list(self.all_playlists.keys())[0]
                        self.current_playlist_name.set(first_name)
                    else:
                        self.all_playlists = {"Ma Sélection": []}
            except:
                self.all_playlists = {"Ma Sélection": []}
        self.maj_combo_playlists()
        self.maj_liste_playlist_ui()

    def sauver_playlists_sur_disque(self):
        with open(PLAYLIST_FILE, "w") as f:
            json.dump(self.all_playlists, f)

    def setup_ui(self):
        self.root.geometry(self.config_chargee.get("geometrie", "1250×750+50+50"))
        self.paned = tk.PanedWindow(self.root, orient="horizontal", sashrelief="raised", sashwidth=4)
        self.paned.pack(fill="both", expand=True)

        # — GAUCHE —
        left_frame = tk.Frame(self.paned, padx=5, pady=5)
        self.paned.add(left_frame, width=self.config_chargee.get("separateur", 450))

        nb = ttk.Notebook(left_frame)
        nb.pack(fill="both", expand=True)

        tab_search = tk.Frame(nb)
        nb.add(tab_search, text="🔍 Bibliothèque")
        tk.Entry(tab_search, textvariable=self.search_var).pack(fill="x", pady=2)
        self.search_var.trace_add("write", self.filtrer_liste)
        self.listbox = tk.Listbox(tab_search, bg="white")
        self.listbox.pack(fill="both", expand=True)
        self.listbox.bind("<<ListboxSelect>>", self.on_select_file)
        tk.Button(tab_search, text="🔄 Scan dossiers récursif", command=self.maj_index).pack(fill="x")

        tab_play = tk.Frame(nb)
        nb.add(tab_play, text="⭐ Playlists")
        
        header_pl = tk.Frame(tab_play)
        header_pl.pack(fill="x", pady=5)
        self.combo_pl = ttk.Combobox(header_pl, textvariable=self.current_playlist_name, state="readonly")
        self.combo_pl.pack(side="left", expand=True, fill="x")
        self.combo_pl.bind("<<ComboboxSelected>>", lambda e: self.maj_liste_playlist_ui())
        
        tk.Button(header_pl, text="+", command=self.creer_playlist, width=3).pack(side="left", padx=2)
        tk.Button(header_pl, text="🗑️", command=self.supprimer_playlist_courante, width=3).pack(side="left")

        self.listbox_playlist = tk.Listbox(tab_play, bg="#fffdf0")
        self.listbox_playlist.pack(fill="both", expand=True)
        self.listbox_playlist.bind("<<ListboxSelect>>", self.on_select_playlist_item)
        
        frame_tri = tk.Frame(tab_play)
        frame_tri.pack(fill="x")
        tk.Button(frame_tri, text="▲ Monter", command=lambda: self.deplacer_item(-1)).pack(side="left", expand=True, fill="x")
        tk.Button(frame_tri, text="▼ Descendre", command=lambda: self.deplacer_item(1)).pack(side="left", expand=True, fill="x")
        tk.Button(tab_play, text="Retirer l'élément", fg="red", command=self.retirer_item_playlist).pack(fill="x")

        # — DROITE —
        right_frame = tk.Frame(self.paned, padx=10, pady=5)
        self.paned.add(right_frame)

        header = tk.Frame(right_frame)
        header.pack(fill="x", pady=(0, 10))
        f_info = tk.Frame(header)
        f_info.pack(side="left", fill="x", expand=True)
        tk.Label(f_info, text="Fichier chargé :", font=("Arial", 9, "bold")).pack(anchor="w")
        tk.Label(f_info, textvariable=self.chemin_fichier, fg="blue", wraplength=450).pack(anchor="w")
        tk.Button(header, text="💾 AJOUTER À LA\nPLAYLIST COURANTE", bg="#ffd700", command=self.ajouter_a_playlist_courante).pack(side="right")

        mid = tk.Frame(right_frame)
        mid.pack(fill="both", expand=True)

        track_frame = tk.LabelFrame(mid, text="Pistes Muettes", padx=10)
        track_frame.pack(side="left", fill="both", expand=True)
        self.canvas = tk.Canvas(track_frame)
        scrolly = tk.Scrollbar(track_frame, orient="vertical", command=self.canvas.yview)
        self.scroll_f = tk.Frame(self.canvas)
        self.scroll_f.bind("<Configure>", lambda e: self.canvas.configure(scrollregion=self.canvas.bbox("all")))
        self.canvas.create_window((0, 0), window=self.scroll_f, anchor="nw")
        self.canvas.configure(yscrollcommand=scrolly.set)
        self.canvas.pack(side="left", fill="both", expand=True)
        scrolly.pack(side="right", fill="y")

        t_frame = tk.LabelFrame(mid, text="Tonalité", padx=10, width=160)
        t_frame.pack(side="right", fill="y", padx=(10, 0))
        t_frame.pack_propagate(False)
        tk.Label(t_frame, text="ORIGINALE").pack()
        tk.Label(t_frame, textvariable=self.tonalite_orig, font=("Arial", 10, "bold")).pack()
        tk.Label(t_frame, text="COURANTE", pady=10).pack()
        tk.Label(t_frame, textvariable=self.tonalite_curr, fg="red", font=("Arial", 14, "bold")).pack()
        tk.Scale(t_frame, from_=12, to=-12, variable=self.transposition, length=200).pack()
        self.transposition.trace_add("write", self.calculer_nouvelle_tonalite)
        tk.Button(t_frame, text="Reset", command=lambda: self.transposition.set(0)).pack(fill="x")

        ctrl = tk.LabelFrame(right_frame, text="Contrôle de lecture", pady=10)
        ctrl.pack(fill="x", pady=10)
        self.btn_play = tk.Button(ctrl, text="▶ LANCER LE KARAOKÉ", bg="#ccffcc", font=("Arial", 12, "bold"), command=self.lancer_karaoke)
        self.btn_play.pack(side="left", expand=True, fill="both", padx=5)
        self.btn_stop = tk.Button(ctrl, text="■ ARRÊTER (ECHAP)", bg="#ffcccc", font=("Arial", 12, "bold"), command=self.stopper_karaoke, state="disabled")
        self.btn_stop.pack(side="left", expand=True, fill="both", padx=5)

        self.check_vars = {}

    # — LOGIQUE PLAYLIST & TRI —
    def maj_combo_playlists(self):
        self.combo_pl['values'] = list(self.all_playlists.keys())

    def maj_liste_playlist_ui(self):
        self.listbox_playlist.delete(0, tk.END)
        plist = self.all_playlists.get(self.current_playlist_name.get(), [])
        for item in plist:
            self.listbox_playlist.insert(tk.END, f"{item['nom']} ({item['transpo']} st)")

    def deplacer_item(self, direction):
        sel = self.listbox_playlist.curselection()
        if not sel: return
        idx = sel[0]
        new_idx = idx + direction
        plist = self.all_playlists[self.current_playlist_name.get()]
        if 0 <= new_idx < len(plist):
            plist[idx], plist[new_idx] = plist[new_idx], plist[idx]
            self.maj_liste_playlist_ui()
            self.listbox_playlist.selection_set(new_idx)
            self.sauver_playlists_sur_disque()

    def creer_playlist(self):
        nom = simpledialog.askstring("Nouvelle Playlist", "Entrez le nom de la playlist :")
        if nom:
            self.all_playlists[nom] = []
            self.current_playlist_name.set(nom)
            self.maj_combo_playlists()
            self.maj_liste_playlist_ui()
            self.sauver_playlists_sur_disque()

    def supprimer_playlist_courante(self):
        nom = self.current_playlist_name.get()
        if len(self.all_playlists) > 1 and messagebox.askyesno("Confirm", f"Supprimer la playlist '{nom}' ?"):
            del self.all_playlists[nom]
            self.current_playlist_name.set(list(self.all_playlists.keys())[0])
            self.maj_combo_playlists()
            self.maj_liste_playlist_ui()
            self.sauver_playlists_sur_disque()

    def ajouter_a_playlist_courante(self):
        path = self.chemin_fichier.get()
        if not path: return
        mues = [idx for idx, d in self.check_vars.items() if d["var"].get()]
        item = {"nom": os.path.basename(path), "chemin": path, "mues": mues, "transpo": self.transposition.get()}
        self.all_playlists[self.current_playlist_name.get()].append(item)
        self.sauver_playlists_sur_disque()
        self.maj_liste_playlist_ui()

    def retirer_item_playlist(self):
        sel = self.listbox_playlist.curselection()
        if sel:
            del self.all_playlists[self.current_playlist_name.get()][sel[0]]
            self.sauver_playlists_sur_disque()
            self.maj_liste_playlist_ui()

    def on_select_playlist_item(self, event):
        sel = self.listbox_playlist.curselection()
        if not sel: return
        data = self.all_playlists[self.current_playlist_name.get()][sel[0]]
        self.chemin_fichier.set(data["chemin"])
        self.analyser_pistes(data["chemin"])
        self.transposition.set(data["transpo"])
        for idx, v in self.check_vars.items(): v["var"].set(idx in data["mues"])

    # — LOGIQUE TECHNIQUE —
    def maj_index(self):
        if not os.path.exists(DOSSIER_ORI): os.makedirs(DOSSIER_ORI)
        self.full_index = []
        for r, d, files in os.walk(DOSSIER_ORI):
            for f in files:
                if f.lower().endswith(('.mid', '.kar')):
                    self.full_index.append({"nom": f, "chemin": os.path.join(r, f)})
        with open(INDEX_FILE, "w") as f: json.dump(self.full_index, f)
        self.filtrer_liste()

    def charger_index_existant(self):
        if os.path.exists(INDEX_FILE):
            with open(INDEX_FILE, "r") as f: self.full_index = json.load(f)
            self.filtrer_liste()

    def filtrer_liste(self, *args):
        terms = self.search_var.get().lower().split()
        self.listbox.delete(0, tk.END)
        for i in self.full_index:
            if all(t in (i['nom']+i['chemin']).lower() for t in terms):
                self.listbox.insert(tk.END, i['nom'])

    def on_select_file(self, event):
        sel = self.listbox.curselection()
        if not sel: return
        nom = self.listbox.get(sel[0])
        for i in self.full_index:
            if i['nom'] == nom:
                self.chemin_fichier.set(i['chemin']); self.analyser_pistes(i['chemin']); break

    def analyser_pistes(self, chemin):
        for w in self.scroll_f.winfo_children(): w.destroy()
        self.check_vars = {}
        self.tonalite_orig.set("–")
        try:
            mid = mido.MidiFile(chemin)
            for i, track in enumerate(mid.tracks):
                nom = "Inconnu"
                for msg in track:
                    if msg.type == 'track_name': nom = msg.name
                    if msg.type == 'key_signature': self.tonalite_orig.set(msg.key)
                v = tk.BooleanVar(); tk.Checkbutton(self.scroll_f, text=f"{i}: {nom}", variable=v).pack(anchor="w")
                self.check_vars[i] = {"var": v}
            self.calculer_nouvelle_tonalite()
        except: pass

    def calculer_nouvelle_tonalite(self, *args):
        o = self.tonalite_orig.get()
        if o == "–": self.tonalite_curr.set("–"); return
        bn = o.replace('m','').replace('b','#')
        sfx = 'm' if 'm' in o else ''
        if bn in NOTES:
            idx = (NOTES.index(bn) + self.transposition.get()) % 12
            self.tonalite_curr.set(NOTES[idx] + sfx)

    def quitter_et_sauvegarder(self):
        try: p = self.paned.sash_coord(0)[0]
        except: p = 450
        conf = {"geometrie": self.root.winfo_geometry(), "separateur": p}
        with open(CONFIG_FILE, "w") as f: json.dump(conf, f)
        self.root.destroy()

    # — MOTEUR DE RENDU PYGAME —
    def moteur_karaoke(self, chemin_fichier):
        try:
            pygame.init()
            W, H = pygame.display.Info().current_w, pygame.display.Info().current_h
            screen = pygame.display.set_mode((W, H), pygame.FULLSCREEN)
            pygame.mouse.set_visible(False)
            
            # Système de motifs animés
            class Particle:
                def __init__(self):
                    self.x, self.y = random.randint(0, W), random.randint(0, H)
                    self.radius = random.randint(50, 150)
                    self.color = [random.randint(10, 50), random.randint(10, 40), random.randint(40, 90)]
                    self.vx, self.vy = random.uniform(-0.6, 0.6), random.uniform(-0.6, 0.6)
                def draw(self, surf):
                    self.x = (self.x + self.vx) % W
                    self.y = (self.y + self.vy) % H
                    pygame.draw.circle(surf, self.color, (int(self.x), int(self.y)), self.radius)

            bg_particles = [Particle() for _ in range(12)]
            font_p = pygame.font.SysFont("Arial", int(H/10), bold=True)
            font_s = pygame.font.SysFont("Arial", int(H/18), italic=True)
            
            mid = mido.MidiFile(chemin_fichier)
            lignes, syllabes_temp, t_cumule = [], [], 0
            for msg in mid:
                t_cumule += msg.time
                if msg.type in ['lyrics', 'text']:
                    txt = msg.text.replace('\r', '').replace('\n', '')
                    if not txt: continue
                    if txt.startswith('\\') or txt.startswith('/'):
                        if syllabes_temp: lignes.append(syllabes_temp)
                        syllabes_temp = []
                        txt = txt.replace('\\', '').replace('/', '')
                    syllabes_temp.append({"temps": t_cumule, "texte": txt})
            if syllabes_temp: lignes.append(syllabes_temp)

            pygame.mixer.music.load(chemin_fichier)
            pygame.mixer.music.play()

            while self.is_playing and not self.stop_requested:
                if not pygame.mixer.music.get_busy(): break
                for ev in pygame.event.get():
                    if ev.type == pygame.KEYDOWN and ev.key == pygame.K_ESCAPE: self.stop_requested = True
                
                t_act = pygame.mixer.music.get_pos() / 1000.0
                screen.fill((10, 10, 25))
                for p in bg_particles: p.draw(screen)
                
                # Voile pour contraste
                overlay = pygame.Surface((W, H), pygame.SRCALPHA)
                overlay.fill((0, 0, 0, 110))
                screen.blit(overlay, (0,0))

                idx = -1
                for i, l in enumerate(lignes):
                    if l[0]["temps"] <= t_act: idx = i
                    else: break
                
                if idx != -1:
                    cur = lignes[idx]
                    full_txt = "".join([s["texte"] for s in cur])
                    s_base = font_p.render(full_txt, True, (160, 160, 160))
                    x_s, y_s = (W – s_base.get_width()) // 2, H // 2 – 50
                    
                    # Ombre
                    shadow = font_p.render(full_txt, True, (0, 0, 0))
                    screen.blit(shadow, (x_s + 4, y_s + 4))
                    screen.blit(s_base, (x_s, y_s))
                    
                    x_o = 0
                    for s in cur:
                        s_act = font_p.render(s["texte"], True, (255, 255, 0))
                        idx_s = cur.index(s)
                        f = cur[idx_s+1]["temps"] if idx_s+1 < len(cur) else s["temps"] + 1.5
                        if t_act >= s["temps"]:
                            p = min(1.0, (t_act – s["temps"]) / (f – s["temps"])) if (f – s["temps"]) > 0 else 1.0
                            screen.blit(s_act, (x_s + x_o, y_s), pygame.Rect(0,0, int(s_act.get_width()*p), s_act.get_height()))
                        x_o += s_act.get_width()

                    if idx + 1 < len(lignes):
                        nxt_txt = "".join([s["texte"] for s in lignes[idx+1]])
                        s_nxt = font_s.render(nxt_txt, True, (210, 210, 210))
                        shadow_n = font_s.render(nxt_txt, True, (0, 0, 0))
                        xn, yn = (W – s_nxt.get_width()) // 2, y_s + 160
                        screen.blit(shadow_n, (xn+2, yn+2))
                        screen.blit(s_nxt, (xn, yn))

                pygame.display.flip()
                pygame.time.Clock().tick(60)
        finally:
            if pygame.mixer.get_init(): pygame.mixer.music.stop()
            if pygame.display.get_init(): pygame.mouse.set_visible(True); pygame.display.quit()
            pygame.quit(); self.root.after(0, self.finaliser_arret)

    def lancer_karaoke(self):
        if not self.chemin_fichier.get(): return
        mues = [idx for idx, d in self.check_vars.items() if d["var"].get()]
        trans = self.transposition.get()
        f = self.chemin_fichier.get()
        if mues or trans != 0:
            f = "temp_output.kar"
            mid_orig = mido.MidiFile(self.chemin_fichier.get())
            mid_new = mido.MidiFile(type=mid_orig.type, ticks_per_beat=mid_orig.ticks_per_beat)
            for i, track in enumerate(mid_orig.tracks):
                if i in mues: continue
                new_t = mido.MidiTrack()
                for msg in track:
                    nm = msg.copy()
                    if not msg.is_meta and msg.type in ['note_on', 'note_off'] and msg.channel != 9:
                        nm.note = max(0, min(127, msg.note + trans))
                    new_t.append(nm)
                mid_new.tracks.append(new_t)
            mid_new.save(f)
        self.stop_requested, self.is_playing = False, True
        self.btn_stop.config(state="normal"); self.btn_play.config(state="disabled")
        threading.Thread(target=self.moteur_karaoke, args=(f,), daemon=True).start()

    def finaliser_arret(self):
        self.is_playing = False; self.stop_requested = False
        self.btn_stop.config(state="disabled"); self.btn_play.config(state="normal")

    def stopper_karaoke(self): self.stop_requested = True

if __name__ == "__main__":
    root = tk.Tk(); app = KaraokeApp(root); root.mainloop()

Karaoké Master Pro (v1.0)

Published by geo on 23 décembre 202523 décembre 2025

1. Objectifs du Projet

2. Guide d’Utilisation

Préparation

L’Interface de Gestion

La Lecture (Mode Karaoké)

3. Implémentation Technique

A. Persistance des Données (JSON)

B. Moteur de Rendu Dynamique

C. Traitement MIDI à la volée

0 commentaire

Laisser un commentaire Annuler la réponse

Audio Downloader Pro

Flux de Production Karaoké Haute Fidélité

Project Zipper (Partenaire de Code)

Karaoké Master Pro (v1.0)

Published by geo on 23 décembre 202523 décembre 2025

1. Objectifs du Projet

2. Guide d’Utilisation

Préparation

L’Interface de Gestion

La Lecture (Mode Karaoké)

3. Implémentation Technique

A. Persistance des Données (JSON)

B. Moteur de Rendu Dynamique

C. Traitement MIDI à la volée

0 commentaire

Laisser un commentaire Annuler la réponse

Articles similaires

Audio Downloader Pro

Flux de Production Karaoké Haute Fidélité

Project Zipper (Partenaire de Code)