Clonage de voix française

🌟 Aperçu du Projet

Le script cv6.py implémente une application de clonage de voix basée sur la librairie TTS de Coqui, utilisant spécifiquement le modèle XTTS-v2 pour la synthèse vocale multilingue. L’application est construite avec Tkinter pour fournir une interface utilisateur graphique (GUI) conviviale, permettant de générer de l’audio à partir d’un fichier texte et d’un échantillon vocal de référence.

Elle inclut des fonctionnalités avancées comme la gestion de la configuration, le multithreading pour la génération audio, l’utilisation optionnelle du GPU (CUDA), et le traitement audio (rééchantillonnage, ajout de silence, normalisation). La langue cible est fixée au Français (fr).

⚙️ Prérequis et Configuration

1. Environnement

Ce script nécessite Python 3.x et plusieurs librairies.

2. Installation des Librairies

Tu dois installer les dépendances suivantes dans ton environnement Python :

Shell

pip install TTS pydub simpleaudio tkinter torch pathlib configparser

Note importante : Le paquet TTS (et torch) est lourd et peut prendre du temps à télécharger, car il inclut le modèle XTTS-v2 qui sera téléchargé lors de la première utilisation. Si tu souhaites utiliser le GPU, assure-toi d’avoir la version de torch compatible avec ton installation CUDA.

3. Fichier de Configuration

Le programme crée et utilise automatiquement un fichier de configuration nommé xtts_config.ini pour sauvegarder les chemins de fichiers et les réglages de l’interface (comme l’utilisation du GPU et la géométrie de la fenêtre).

🚀 Utilisation de l’Application (GUI)

Le script est exécuté comme une application autonome :

Shell

python cv6.py

L’interface utilisateur permet de réaliser les étapes suivantes :

Fichier texte (.txt) :
- Clique sur « Parcourir » pour sélectionner un fichier texte (.txt) contenant le script à lire.
- Chaque phrase se terminant par un point (.), un point d’interrogation (?) ou un point d’exclamation (!) sera traitée individuellement.
Fichier WAV référence :
- Clique sur « Parcourir » pour sélectionner un fichier audio WAV (.wav) de la voix que tu souhaites cloner.
- Recommandation : La durée de l’échantillon doit idéalement être comprise entre 3 et 120 secondes. Le fichier sera rééchantillonné automatiquement à 24000 Hz si nécessaire.
Fichier de sortie (.wav) :
- Spécifie le nom du fichier de sortie (.wav).
- Clique sur « Choisir » pour spécifier un emplacement et un nom de fichier différents.
Options Avancées :
- Utiliser GPU (CUDA) : Coche cette case pour utiliser le GPU pour la génération, si torch détecte une carte compatible. Ceci accélère considérablement la génération.
- Silence entre phrases (ms) : Règle la durée du silence ajouté entre chaque phrase générée (valeur par défaut : 300 ms).
Actions :
- « Générer audio » : Démarre le processus de clonage de voix dans un thread séparé.
- « STOP » : Permet d’annuler une génération en cours.
- « ▶ Écouter le résultat » : Lance la lecture du fichier de sortie généré (nécessite la librairie simpleaudio).

🧱 Structure du Code et Composants Clés

1. Variables Globales

Variable	Description	Valeur par Défaut
`MODEL_NAME`	Chemin du modèle XTTS-v2 à utiliser.	`"tts_models/multilingual/multi-dataset/xtts_v2"`
`SPEAKER_SAMPLE_RATE`	Fréquence d’échantillonnage cible pour la voix de référence et la sortie.	`24000` Hz
`MIN_REF_DURATION`	Durée minimale recommandée pour le fichier de référence.	`3.0` s
`GPU_AVAILABLE`	Vérifie si CUDA (GPU) est disponible.	`torch.cuda.is_available()`

2. Fonctions de Génération (Logique Métier)

start_generation_thread : Lance la tâche de génération dans un thread séparé pour éviter de bloquer l’interface.
stop_generation : Permet l’annulation de la tâche via un flag (self.stop_flag).
generate_audio_task :
- Initialise et charge le modèle XTTS (une seule fois).
- Rééchantillonne le fichier de référence à 24000 Hz si sa fréquence est différente.
- Divise le fichier texte en phrases distinctes.
- Génère l’audio phrase par phrase, en les concaténant avec des segments de silence. La langue est fixée à Français (language="fr").
- Normalise le volume du fichier audio final avant l’exportation.
- Fournit une estimation du temps restant et met à jour la progression dans la GUI.
_cleanup_on_finish : Supprime le dossier temporaire (./temp_tts_files) une fois la tâche terminée ou annulée.

💡 Conseils d’Implémentation et Outils

1. Amélioration de la Qualité

Qualité de la référence : Le succès du clonage dépend fortement de la qualité (pas de bruit de fond, pas de musique) et de la cohérence de la voix dans le fichier WAV de référence.
Révision du texte : Assure-toi que le fichier texte est correctement ponctué. La division des phrases par l’expression régulière dépend des signes de ponctuation.

2. Conversion MP3 vers WAV (24000 Hz, Mono)

Pour garantir un format idéal pour le fichier de référence, tu peux utiliser FFmpeg pour convertir des fichiers MP3 (ou autres) vers un fichier WAV mono avec un taux d’échantillonnage de 24000 Hz.

Commande FFmpeg :

Shell

ffmpeg -i input_reference.mp3 -ac 1 -ar 24000 output_reference_24k_mono.wav

Option	Description
`-i input_reference.mp3`	Spécifie le fichier d’entrée (ton fichier MP3).
`-ac 1`	Force le nombre de canaux audio à 1 (canal mono).
`-ar 24000`	Force le taux d’échantillonnage (sample rate) à 24000 Hz.
`output_reference_24k_mono.wav`	Spécifie le fichier de sortie au format WAV.

Source

Python

import tkinter as tk
from tkinter import filedialog, messagebox
from tkinter.ttk import Progressbar, Checkbutton, Style
from TTS.api import TTS
from pydub import AudioSegment
import re
import os
import torch
import simpleaudio as sa
import threading
from pathlib import Path
import shutil 
import configparser
import time

# —————————–
# CONFIGURATION GLOBALE
# —————————–
MODEL_NAME = "tts_models/multilingual/multi-dataset/xtts_v2"
OUTPUT_FILE_DEFAULT = "resultat_xtts.wav"
DEFAULT_SILENCE_MS = 300 
FINAL_SILENCE_MS = 500
SPEAKER_SAMPLE_RATE = 24000 

MIN_REF_DURATION = 3.0
MAX_REF_DURATION = 120.0

GPU_AVAILABLE = torch.cuda.is_available()
CONFIG_FILE = "xtts_config.ini" 

class VoiceCloningApp:
    def __init__(self, master):
        self.master = master
        
        # 1. Chargement de la configuration
        self.config = configparser.ConfigParser()
        self._load_config()
        self._set_window_geometry()
        
        master.title("Clone de voix français – XTTS (Avancé)")
        master.style = Style()
        master.style.theme_use('clam')
        
        # Variables de l'application
        self.text_file_var = tk.StringVar(value=self.config.get('Paths', 'text_file', fallback=''))
        self.wav_file_var = tk.StringVar(value=self.config.get('Paths', 'wav_file', fallback=''))
        self.output_file_var = tk.StringVar(value=self.config.get('Paths', 'output_file', fallback=OUTPUT_FILE_DEFAULT))
        self.status_var = tk.StringVar(value="Prêt à générer.")
        self.text_display_var = tk.StringVar()
        self.gpu_var = tk.BooleanVar(value=self.config.getboolean('Settings', 'use_gpu', fallback=GPU_AVAILABLE))
        self.silence_ms_var = tk.IntVar(value=self.config.getint('Settings', 'silence_ms', fallback=DEFAULT_SILENCE_MS))
        # La variable de langue a été supprimée.
        
        self.is_generating = False
        self.stop_flag = threading.Event()
        self.tts_model = None
        
        self._set_cpu_threads()
        self._create_widgets()
        
        self.master.protocol("WM_DELETE_WINDOW", self.on_closing)

    # —————————–
    # Fonctions de Configuration
    # —————————–
    
    def _load_config(self):
        """Charge la configuration depuis le fichier INI."""
        self.config.read(CONFIG_FILE)
        if 'Paths' not in self.config:
            self.config['Paths'] = {}
        if 'Settings' not in self.config:
            self.config['Settings'] = {}
        if 'Geometry' not in self.config:
            self.config['Geometry'] = {}

    def _save_config(self):
        """Sauvegarde les paramètres et la géométrie de la fenêtre."""
        # Sauvegarde des chemins et réglages
        self.config['Paths']['text_file'] = self.text_file_var.get()
        self.config['Paths']['wav_file'] = self.wav_file_var.get()
        self.config['Paths']['output_file'] = self.output_file_var.get()
        self.config['Settings']['use_gpu'] = str(self.gpu_var.get())
        self.config['Settings']['silence_ms'] = str(self.silence_ms_var.get())
        # La sauvegarde de la langue a été supprimée.

        # Sauvegarde de la géométrie de la fenêtre
        try:
            self.config['Geometry']['window_geometry'] = self.master.geometry()
        except tk.TclError:
            pass
        
        try:
            with open(CONFIG_FILE, 'w') as configfile:
                self.config.write(configfile)
        except Exception as e:
            print(f"Avertissement: Impossible de sauvegarder le fichier de configuration. Erreur: {e}")

    def _set_window_geometry(self):
        """Restaure la taille et la position de la fenêtre."""
        geometry = self.config.get('Geometry', 'window_geometry', fallback='')
        if geometry:
            try:
                self.master.geometry(geometry)
            except tk.TclError:
                pass 
        else:
            # Taille par défaut ajustée
            self.master.geometry('700×500')
            

    def _set_cpu_threads(self):
        num_threads = max(4, os.cpu_count() // 2) if os.cpu_count() else 4
        torch.set_num_threads(num_threads)

    # —————————–
    # Fonctions de l'Interface
    # —————————–

    def _create_widgets(self):
        """Construit l'interface graphique."""
        
        for i in range(3):
            self.master.grid_columnconfigure(i, weight=1 if i == 1 else 0)

        row_counter = 0

        # — Fichier texte (.txt) —
        tk.Label(self.master, text="Fichier texte (.txt) :").grid(row=row_counter, column=0, sticky="w", padx=5, pady=5)
        tk.Entry(self.master, textvariable=self.text_file_var, width=60).grid(row=row_counter, column=1, padx=5, pady=5, sticky="ew")
        tk.Button(self.master, text="Parcourir", command=self.select_text_file).grid(row=row_counter, column=2, padx=5, pady=5)
        row_counter += 1

        # — Fichier WAV référence —
        tk.Label(self.master, text="Fichier WAV référence :").grid(row=row_counter, column=0, sticky="w", padx=5, pady=5)
        tk.Entry(self.master, textvariable=self.wav_file_var, width=60).grid(row=row_counter, column=1, padx=5, pady=5, sticky="ew")
        tk.Button(self.master, text="Parcourir", command=self.select_wav_file).grid(row=row_counter, column=2, padx=5, pady=5)
        row_counter += 1
        
        # — Fichier de Sortie —
        tk.Label(self.master, text="Fichier de sortie (.wav) :").grid(row=row_counter, column=0, sticky="w", padx=5, pady=5)
        tk.Entry(self.master, textvariable=self.output_file_var, width=60).grid(row=row_counter, column=1, padx=5, pady=5, sticky="ew")
        tk.Button(self.master, text="Choisir", command=self.select_output_file).grid(row=row_counter, column=2, padx=5, pady=5)
        row_counter += 1

        # — Options Avancées —
        options_frame = tk.Frame(self.master)
        options_frame.grid(row=row_counter, column=0, columnspan=3, padx=5, pady=10, sticky="w")
        
        # Option GPU
        gpu_text = f"Utiliser GPU (CUDA) – {'Disponible' if GPU_AVAILABLE else 'Non disponible'}"
        self.gpu_check = Checkbutton(options_frame, text=gpu_text, variable=self.gpu_var, state=tk.NORMAL if GPU_AVAILABLE else tk.DISABLED)
        self.gpu_check.pack(side=tk.LEFT, padx=10)

        # Option Silence
        tk.Label(options_frame, text="Silence entre phrases (ms) :").pack(side=tk.LEFT, padx=10)
        tk.Entry(options_frame, textvariable=self.silence_ms_var, width=8).pack(side=tk.LEFT, padx=5)
        
        # Info Fréquence
        tk.Label(options_frame, text=f"(Cible: {SPEAKER_SAMPLE_RATE} Hz)").pack(side=tk.LEFT, padx=10)
        
        # Info Langue (maintenant fixe)
        tk.Label(options_frame, text="Langue: Français (fixe)").pack(side=tk.LEFT, padx=10)

        row_counter += 1
        # L'espace pour le sélecteur de langue est maintenant utilisé par l'info fixe "Langue: Français (fixe)"

        # — Boutons Action —
        self.generate_btn = tk.Button(self.master, text="Générer audio", command=self.start_generation_thread, bg="#4CAF50", fg="white", font=('Arial', 10, 'bold'))
        self.generate_btn.grid(row=row_counter, column=0, columnspan=3, pady=10, sticky="ew")
        
        self.stop_btn = tk.Button(self.master, text="STOP", command=self.stop_generation, bg="#F44336", fg="white", state=tk.DISABLED)
        self.stop_btn.grid(row=row_counter, column=2, padx=5, pady=10, sticky="e")
        
        row_counter += 1

        # — Progressbar —
        self.progress = Progressbar(self.master, orient=tk.HORIZONTAL, length=400, mode='determinate')
        self.progress.grid(row=row_counter, column=0, columnspan=3, padx=5, pady=5, sticky="ew")
        row_counter += 1

        # — Texte en cours / Log —
        tk.Label(self.master, text="Phrase en cours :").grid(row=row_counter, column=0, sticky="w", padx=5, pady=2)
        tk.Label(self.master, textvariable=self.text_display_var, fg="blue", wraplength=550, justify="left").grid(row=row_counter, column=1, columnspan=2, sticky="w")
        row_counter += 1

        # — Status —
        tk.Label(self.master, textvariable=self.status_var, fg="green", font=('Arial', 10, 'italic')).grid(row=row_counter, column=0, columnspan=3, pady=5)
        row_counter += 1

        # — Bouton Play —
        tk.Button(self.master, text="▶ Écouter le résultat", command=self.play_audio, bg="#2196F3", fg="white").grid(row=row_counter, column=0, columnspan=3, pady=10)
        
    def select_text_file(self):
        path = filedialog.askopenfilename(filetypes=[("Text Files", "*.txt")])
        if path:
            self.text_file_var.set(path)

    def select_wav_file(self):
        path = filedialog.askopenfilename(filetypes=[("WAV Files", "*.wav")])
        if path:
            self.wav_file_var.set(path)

    def select_output_file(self):
        path = filedialog.asksaveasfilename(
            defaultextension=".wav",
            initialfile=self.output_file_var.get(),
            filetypes=[("WAV Files", "*.wav")]
        )
        if path:
            self.output_file_var.set(path)

    def play_audio(self):
        output_path = Path(self.output_file_var.get())
        if not output_path.exists():
            messagebox.showwarning("Erreur", "Fichier audio non généré ou introuvable.")
            return
        
        self.status_var.set(f"Lecture de l'audio : {output_path.name}")
        try:
            wave_obj = sa.WaveObject.from_wave_file(str(output_path))
            play_obj = wave_obj.play()
        except Exception as e:
            messagebox.showerror("Erreur de lecture", f"Impossible de lire le fichier. Erreur: {e}")
            self.status_var.set("Erreur de lecture audio.")
            
    # —————————–
    # Fonctions de génération
    # —————————–
    
    def start_generation_thread(self):
        if self.is_generating:
            messagebox.showwarning("Génération en cours", "Une tâche de génération est déjà en cours.")
            return

        text_file = self.text_file_var.get()
        speaker_wav = self.wav_file_var.get()

        if not text_file or not speaker_wav:
            messagebox.showwarning("Erreur", "Sélectionnez le fichier texte et le fichier WAV de référence.")
            return

        # La vérification de la langue a été supprimée
            
        if not Path(text_file).exists() or not Path(speaker_wav).exists():
            messagebox.showerror("Erreur", "Fichier d'entrée introuvable.")
            return

        self.stop_flag.clear()
        self.is_generating = True
        self.generate_btn.config(state=tk.DISABLED)
        self.stop_btn.config(state=tk.NORMAL)
        self.status_var.set("Démarrage de la génération…")
        
        threading.Thread(target=self.generate_audio_task, daemon=True).start()

    def stop_generation(self):
        if self.is_generating:
            self.stop_flag.set()
            self.status_var.set("Arrêt en cours… Veuillez patienter.") 
            self.stop_btn.config(state=tk.DISABLED)

    def _load_tts_model(self):
        if self.tts_model is None:
            self.status_var.set("Chargement du modèle XTTS…")
            self.master.update()
            
            use_gpu = self.gpu_var.get() and GPU_AVAILABLE
            try:
                self.tts_model = TTS(model_name=MODEL_NAME, gpu=use_gpu)
            except Exception as e:
                messagebox.showerror("Erreur de Modèle", f"Échec du chargement du modèle TTS. Erreur: {e}")
                return False
        return True

    def generate_audio_task(self):
        text_file_path = Path(self.text_file_var.get())
        speaker_wav_path = Path(self.wav_file_var.get())
        output_wav_path = Path(self.output_file_var.get())
        # selected_language a été supprimé, la langue est "fr"
        
        temp_dir = Path("./temp_tts_files")
        temp_dir.mkdir(exist_ok=True) 

        if not self._load_tts_model():
            self._cleanup_on_finish(temp_dir)
            return

        # — Vérification, Validation et Rééchantillonnage du fichier de référence —
        final_speaker_wav_path = speaker_wav_path
        try:
            ref_audio = AudioSegment.from_wav(str(speaker_wav_path))

            # Validation de la durée
            duration_s = ref_audio.duration_seconds
            if not (MIN_REF_DURATION <= duration_s <= MAX_REF_DURATION):
                messagebox.showwarning(
                    "Avertissement Durée WAV", 
                    f"La durée du fichier de référence ({duration_s:.1f}s) est en dehors de la plage recommandée ({MIN_REF_DURATION}s à {MAX_REF_DURATION}s). La qualité du clonage pourrait être affectée."
                )

            # Rééchantillonnage
            if ref_audio.frame_rate != SPEAKER_SAMPLE_RATE:
                self.status_var.set(f"Rééchantillonnage de la voix de référence de {ref_audio.frame_rate}Hz à {SPEAKER_SAMPLE_RATE}Hz…")
                self.master.update_idletasks()
                
                resampled_audio = ref_audio.set_frame_rate(SPEAKER_SAMPLE_RATE)
                temp_speaker_wav = temp_dir / "resampled_speaker.wav"
                resampled_audio.export(str(temp_speaker_wav), format="wav")
                
                final_speaker_wav_path = temp_speaker_wav
            
        except Exception as e:
            messagebox.showerror("Erreur Audio de Référence", f"Impossible de lire ou de rééchantillonner le fichier WAV de référence. Erreur: {e}")
            self._cleanup_on_finish(temp_dir)
            return

        # — Préparation du texte —
        try:
            full_text = text_file_path.read_text("utf-8").strip()
        except Exception as e:
            messagebox.showerror("Erreur de Lecture", f"Impossible de lire le fichier texte. Erreur: {e}")
            self._cleanup_on_finish(temp_dir)
            return

        if not full_text:
            messagebox.showerror("Erreur", "Le fichier texte est vide !")
            self._cleanup_on_finish(temp_dir)
            return

        sentences = [s.strip() for s in re.split(r'(?<=[.!?]) +', full_text) if s.strip()]
        n_sentences = len(sentences)
        
        self.progress['value'] = 0
        self.progress['maximum'] = n_sentences
        self.text_display_var.set("")
        
        combined_audio = AudioSegment.empty()
        silence_ms = self.silence_ms_var.get()
        silence_segment = AudioSegment.silent(duration=max(0, silence_ms))
        final_silence_segment = AudioSegment.silent(duration=FINAL_SILENCE_MS)

        # — Chronomètre —
        start_time = time.time() 

        # — Boucle de Génération —
        try:
            for i, sentence in enumerate(sentences):
                if self.stop_flag.is_set():
                    break

                # Calcul et affichage du temps restant (estimation)
                elapsed_time = time.time() – start_time
                if i > 0:
                    avg_time_per_sentence = elapsed_time / i
                    time_remaining = avg_time_per_sentence * (n_sentences – i)
                    time_str = f"Écoulé: {int(elapsed_time)}s | Est. restant: {int(time_remaining)}s"
                else:
                    time_str = f"Écoulé: {int(elapsed_time)}s"

                self.status_var.set(f"Génération phrase {i+1}/{n_sentences} ({time_str})…")
                self.text_display_var.set(sentence)
                self.master.update_idletasks()

                temp_file = temp_dir / f"temp_{i}.wav"
                
                # Génération avec la langue française hardcodée
                self.tts_model.tts_to_file(
                    text=sentence,
                    file_path=str(temp_file),
                    speaker_wav=str(final_speaker_wav_path), 
                    language="fr"
                )
                
                new_segment = AudioSegment.from_wav(str(temp_file))
                combined_audio += new_segment
                
                if i < n_sentences – 1:
                    combined_audio += silence_segment
                
                temp_file.unlink()
                
                self.progress['value'] = i + 1
            
            # — Exportation Finale —
            if not self.stop_flag.is_set() and combined_audio.duration_seconds > 0:
                self.status_var.set("Ajout du silence, normalisation et exportation de l'audio final…")
                
                # Ajout du silence de fin
                combined_audio += final_silence_segment 

                # Normalisation du volume
                normalized_audio = combined_audio.normalize()
                
                normalized_audio.export(str(output_wav_path), format="wav")
                total_time = int(time.time() – start_time)
                self.status_var.set(f"✅ Génération terminée en {total_time}s ! Fichier : {output_wav_path.name}")
            
        except Exception as e:
            messagebox.showerror("Erreur Fatale de Génération", f"Une erreur s'est produite pendant la génération. Erreur: {e}")
            self.status_var.set("💥 Erreur lors de la génération.")
        finally:
            if self.stop_flag.is_set():
                self.status_var.set("Génération annulée. Prêt à commencer une nouvelle tâche.")

            self._cleanup_on_finish(temp_dir)
            self.is_generating = False
            self.generate_btn.config(state=tk.NORMAL)
            self.stop_btn.config(state=tk.DISABLED)
            self.text_display_var.set("")
            self.progress['value'] = 0

    def _cleanup_on_finish(self, temp_dir: Path):
        """Nettoie les fichiers temporaires et le répertoire temporaire."""
        try:
            if temp_dir.exists():
                shutil.rmtree(temp_dir)
        except Exception as e:
            print(f"Avertissement: Impossible de supprimer le répertoire temporaire {temp_dir}. Erreur: {e}")

    def on_closing(self):
        """Gestion de la fermeture de la fenêtre."""
        
        # Sauvegarde de la configuration (y compris la géométrie) AVANT la destruction
        self._save_config()
        
        if self.is_generating:
            if messagebox.askyesno("Quitter l'application", "La génération est en cours. Voulez-vous l'arrêter et quitter ?"):
                self.stop_flag.set()
                self.master.after(500, self.master.destroy) 
        else:
            self.master.destroy()

# —————————–
# Démarrage de l'application
# —————————–
def main():
    root = tk.Tk()
    app = VoiceCloningApp(root)
    root.mainloop()
     
if __name__ == "__main__":
   main()

Clonage de voix française

Published by geo on 5 novembre 20255 novembre 2025

🌟 Aperçu du Projet

⚙️ Prérequis et Configuration

1. Environnement

2. Installation des Librairies

3. Fichier de Configuration

🚀 Utilisation de l’Application (GUI)

🧱 Structure du Code et Composants Clés

1. Variables Globales

2. Fonctions de Génération (Logique Métier)

💡 Conseils d’Implémentation et Outils

1. Amélioration de la Qualité

2. Conversion MP3 vers WAV (24000 Hz, Mono)

Source

0 commentaire

Laisser un commentaire Annuler la réponse

Héberger un site statique sur Raspberry Pi 5 avec IP Fixe et HTTPS

Audio Downloader Pro

Flux de Production Karaoké Haute Fidélité

Clonage de voix française

Published by geo on 5 novembre 20255 novembre 2025

🌟 Aperçu du Projet

⚙️ Prérequis et Configuration

1. Environnement

2. Installation des Librairies

3. Fichier de Configuration

🚀 Utilisation de l’Application (GUI)

🧱 Structure du Code et Composants Clés

1. Variables Globales

2. Fonctions de Génération (Logique Métier)

💡 Conseils d’Implémentation et Outils

1. Amélioration de la Qualité

2. Conversion MP3 vers WAV (24000 Hz, Mono)

Source

0 commentaire

Laisser un commentaire Annuler la réponse

Articles similaires

Héberger un site statique sur Raspberry Pi 5 avec IP Fixe et HTTPS

Audio Downloader Pro

Flux de Production Karaoké Haute Fidélité