Comment générer et ajouter des sous-titres à des vidéos en utilisant Python, OpenAI Whisper et FFmpeg

L'auteur a choisi l'Open Source Initiative pour recevoir un don dans le cadre du programme Write for DOnations.

Introduction

Dans ce tutoriel, vous allez créer une application Python capable d'extraire l'audio d'une vidéo d'entrée, de transcrire l'audio extrait, de générer un fichier de sous-titres basé sur la transcription, puis d'ajouter les sous-titres à une copie de la vidéo d'entrée.

Pour construire cette application, vous utiliserez FFmpeg pour extraire l'audio d'une vidéo d'entrée. Vous utiliserez Whisper d'OpenAI pour générer une transcription de l'audio extrait, puis vous utiliserez cette transcription pour générer un fichier de sous-titres. De plus, vous utiliserez FFmpeg pour ajouter le fichier de sous-titres généré à une copie de la vidéo d'entrée.

FFmpeg est une suite logicielle puissante et open-source pour le traitement des données multimédias, y compris les tâches de traitement audio et vidéo. Elle fournit un outil en ligne de commande qui permet aux utilisateurs de convertir, éditer et manipuler des fichiers multimédias dans une large gamme de formats et de codecs.

Le Whisper d'OpenAI est un système de reconnaissance automatique de la parole (RAP) conçu pour convertir la langue parlée en texte écrit. Entraîné sur une vaste quantité de données supervisées multilingues et multitâches, il excelle à transcrire divers contenus audio avec une grande précision.

À la fin de ce tutoriel, vous aurez une application capable d'ajouter des sous-titres à une vidéo :

Conditions préalables

Pour suivre ce tutoriel, le lecteur aura besoin des outils suivants :

Version de Python 3.9+ et venv correspondant installé
FFmpeg installé.
Une compréhension de base de Python. Vous pouvez suivre cette série de tutoriels pour apprendre à programmer en Python.

Étape 1 — Création du répertoire racine du projet

Dans cette section, vous allez créer le répertoire du projet, télécharger la vidéo d'entrée, créer et activer un environnement virtuel, et installer les paquets Python requis.

Ouvrez une fenêtre de terminal et naviguez vers un emplacement approprié pour votre projet. Exécutez la commande suivante pour créer le répertoire du projet :

mkdir generate-subtitle

Accédez au répertoire du projet :

cd generate-subtitle

Téléchargez cette vidéo montée et enregistrez-la dans le répertoire racine de votre projet sous le nom input.mp4. La vidéo présente un enfant nommé Rushawn chantant “Beautiful Day” de Jermaine Edward. La vidéo montée que vous allez utiliser dans ce tutoriel a été tirée de la vidéo YouTube suivante :

Créez un nouvel environnement virtuel et nommez-le env :

python3 -m venv env

Activez l'environnement virtuel :

source env/bin/activate

Maintenant, utilisez la commande suivante pour installer les packages nécessaires à la construction de cette application :

pip3 install faster-whisper ffmpeg-python

Avec la commande ci-dessus, vous avez installé les bibliothèques suivantes :

faster-whisper : est une version repensée du modèle Whisper d'OpenAI qui tire parti de CTranslate2, un moteur d'inférence haute performance pour les modèles Transformer. Cette implémentation atteint des vitesses jusqu'à quatre fois supérieures à celles de openai/whisper avec une précision comparable, tout en consommant moins de mémoire.
ffmpeg-python : est une bibliothèque Python qui offre une interface autour de l'outil FFmpeg, permettant aux utilisateurs d'interagir facilement avec les fonctionnalités de FFmpeg dans des scripts Python. Grâce à une interface pythonique, elle permet d'effectuer des tâches de traitement vidéo et audio, telles que le montage, la conversion et la manipulation.

Exécutez la commande suivante pour enregistrer les packages qui ont été installés à l'aide de pip dans l'environnement virtuel dans un fichier nommé requirements.txt :

pip3 freeze > requirements.txt

Le fichier requirements.txt devrait ressembler à ceci :

av==10.0.0
certifi==2023.7.22
charset-normalizer==3.3.2
coloredlogs==15.0.1
ctranslate2==3.20.0
faster-whisper==0.9.0
ffmpeg-python==0.2.0
filelock==3.13.1
flatbuffers==23.5.26
fsspec==2023.10.0
future==0.18.3
huggingface-hub==0.17.3
humanfriendly==10.0
idna==3.4
mpmath==1.3.0
numpy==1.26.1
onnxruntime==1.16.1
packaging==23.2
protobuf==4.25.0
PyYAML==6.0.1
requests==2.31.0
sympy==1.12
tokenizers==0.14.1
tqdm==4.66.1
typing_extensions==4.8.0
urllib3==2.0.7

Dans cette section, vous avez créé le répertoire du projet, téléchargé la vidéo d'entrée qui sera utilisée dans ce tutoriel, configuré un environnement virtuel, l'avez activé et installé les packages Python nécessaires. Dans la section suivante, vous allez générer une transcription pour la vidéo d'entrée.

Étape 2 — Génération de la transcription vidéo

Dans cette section, vous allez créer le script Python où l'application sera exécutée. Dans ce script, vous utiliserez la bibliothèque ffmpeg-python pour extraire la piste audio de la vidéo d'entrée téléchargée dans la section précédente et l'enregistrer au format WAV. Ensuite, vous utiliserez la bibliothèque faster-whisper pour générer une transcription de l'audio extrait.

Dans le répertoire racine de votre projet, créez un fichier nommé main.py et ajoutez le code suivant :

import time
import math
import ffmpeg

from faster_whisper import WhisperModel

input_video = "input.mp4"
input_video_name = input_video.replace(".mp4", "")

Ici, le code commence par importer diverses bibliothèques et modules, y compris time, math, ffmpeg de ffmpeg-python, et un module personnalisé nommé WhisperModel de faster_whisper. Ces bibliothèques seront utilisées pour le traitement vidéo et audio, la transcription et la génération de sous-titres.

Ensuite, le code définit le nom du fichier vidéo d'entrée, le stocke dans une constante appelée input_video, puis stocke le nom du fichier vidéo sans l'extension .mp4 dans une constante nommée input_video_name. Définir le nom du fichier d'entrée ici vous permettra de travailler sur plusieurs vidéos d'entrée sans écraser les fichiers de sous-titres et de vidéo de sortie générés pour elles.

Ajoutez le code suivant à la fin de votre main.py :

def extract_audio():
    extracted_audio = f"audio-{input_video_name}.wav"
    stream = ffmpeg.input(input_video)
    stream = ffmpeg.output(stream, extracted_audio)
    ffmpeg.run(stream, overwrite_output=True)
    return extracted_audio

Le code ci-dessus définit une fonction nommée extract_audio() qui est responsable de l'extraction de l'audio de la vidéo d'entrée.

Tout d'abord, il définit le nom de l'audio qui sera extrait à partir d'un nom formé en ajoutant audio- au nom de base de la vidéo d'entrée avec une extension .wav, et stocke ce nom dans une constante nommée extracted_audio.

Ensuite, le code appelle la méthode ffmpeg.input() de la bibliothèque ffmpeg pour ouvrir la vidéo d'entrée et crée un objet de flux d'entrée nommé stream.

Le code appelle ensuite la méthode ffmpeg.output() pour créer un objet de flux de sortie avec le flux d'entrée et le nom de fichier audio extrait défini.

Après avoir défini le flux de sortie, le code appelle la méthode ffmpeg.run(), passant le flux de sortie comme paramètre pour initier le processus d'extraction audio et enregistrer le fichier audio extrait dans le répertoire racine de votre projet. De plus, un paramètre booléen, overwrite_output=True, est inclus pour remplacer tout fichier de sortie préexistant par le nouveau fichier généré si un tel fichier existe déjà.

Enfin, le code retourne le nom du fichier audio extrait.

Ajoutez le code suivant en dessous de la fonction extract_audio() :

def run():

    extracted_audio = extract_audio()
run()

Ici, le code définit une fonction nommée run() et l'appelle ensuite. Cette fonction appelle toutes les fonctions nécessaires pour générer et ajouter des sous-titres à une vidéo.

À l'intérieur de la fonction, le code appelle la fonction extract_audio() pour extraire l'audio d'une vidéo et stocke ensuite le nom du fichier audio retourné dans une variable nommée extracted_audio.

Retournez à votre terminal et exécutez la commande suivante pour exécuter le script main.py :

python3 main.py

Après avoir exécuté la commande ci-dessus, la sortie de FFmpeg sera affichée dans le terminal, et un fichier nommé audio-input.wav contenant l'audio extrait de la vidéo d'entrée sera stocké dans le répertoire racine de votre projet.

Retournez dans votre fichier main.py et ajoutez le code suivant entre les fonctions extract_audio() et run() :

def transcribe(audio):
    model = WhisperModel("small")
    segments, info = model.transcribe(audio)
    language = info[0]
    print("Transcription language", info[0])
    segments = list(segments)
    for segment in segments:
        # print(segment)
        print("[%.2fs -> %.2fs] %s" %
              (segment.start, segment.end, segment.text))
    return language, segments

Le code ci-dessus définit une fonction nommée transcribe responsable de la transcription du fichier audio extrait de la vidéo d'entrée.

Tout d'abord, le code crée une instance de l'objet WhisperModel et définit le type de modèle sur small. Le modèle Whisper d'OpenAI comporte les types de modèle suivants : tiny, base, small, medium et large. Le modèle tiny est le plus petit et le plus rapide, tandis que le modèle large est le plus grand et le plus lent, mais le plus précis.

Ensuite, le code appelle la méthode model.transcribe() avec l'audio extrait comme argument pour récupérer la fonction des segments et les informations audio, et les stocke dans des variables nommées info et segments respectivement. La fonction des segments est un générateur Python, donc la transcription ne commencera que lorsque le code y itérera. La transcription peut être exécutée jusqu'à son terme en rassemblant les segments dans une liste ou une boucle for.

Ensuite, le code stocke la langue détectée dans l'audio dans une constante nommée info et l'imprime dans la console.

Après avoir imprimé la langue détectée, le code rassemble les segments de transcription dans une liste pour exécuter la transcription et stocke les segments rassemblés dans une variable également nommée segments. Le code parcourt ensuite la liste des segments de transcription et imprime le temps de début, le temps de fin et le texte de chaque segment dans la console.

Enfin, le code retourne la langue détectée dans l'audio et les segments de transcription.

Ajoutez le code suivant à l'intérieur de la fonction run() :

def run():

    extracted_audio = extract_audio()

    language, segments = transcribe(audio=extracted_audio)

Le code ajouté appelle la fonction de transcription avec l'audio extrait comme argument et stocke les valeurs retournées dans des constantes nommées langue et segments.

Retournez à votre terminal et exécutez la commande suivante pour exécuter le script main.py :

python3 main.py

La première fois que vous exécutez ce script, le code téléchargera d'abord et mettra en cache le modèle Whisper Small, les exécutions suivantes seront beaucoup plus rapides.

Après avoir exécuté la commande ci-dessus, vous devriez voir la sortie suivante dans la console :

…
Transcription language en
[0.00s -> 4.00s]  This morning I wake up and I look in the mirror
[4.00s -> 8.00s]  Every part of my body was in the place many people lie
[8.00s -> 11.00s]  I don't wanna act too high and mighty
[11.00s -> 15.00s]  Cause tomorrow I may fall down on my face
[15.00s -> 17.00s]  Lord I thank You for sunshine
[17.00s -> 19.00s]  Thank You for rain
[19.00s -> 20.00s]  Thank You for joy
[20.00s -> 22.00s]  Thank You for pain
[22.00s -> 25.00s]  It's a beautiful day
[25.00s -> 28.00s]  It's a beautiful day

La sortie ci-dessus montre que la langue détectée dans l'audio est l'anglais (en). De plus, elle indique le temps de début et de fin en secondes pour chaque segment de transcription ainsi que le texte.

Avertissement : Bien que la reconnaissance vocale Whisper d'OpenAI soit très précise, elle n'est pas à 100 % exacte, elle peut être soumise à des limites et à des erreurs occasionnelles, en particulier dans des scénarios linguistiques ou audio difficiles. Assurez-vous donc toujours de vérifier la transcription manuellement.

Dans cette section, vous avez créé un script Python pour l'application. À l'intérieur du script, ffmpeg-python a été utilisé pour extraire l'audio de la vidéo téléchargée et le sauvegarder sous forme de fichier WAV. Ensuite, la bibliothèque faster-whisper a été utilisée pour générer une transcription de l'audio extrait. Dans la prochaine section, vous allez générer un fichier de sous-titres basé sur la transcription et ensuite vous ajouterez les sous-titres à la vidéo.

Étape 3 — Générer et ajouter les sous-titres à la vidéo

Dans cette section, vous comprendrez d'abord ce qu'est un fichier de sous-titres et comment il est structuré. Ensuite, vous utiliserez les segments de transcription générés dans la section précédente pour créer un fichier de sous-titres. Après avoir créé le fichier de sous-titres, vous utiliserez la bibliothèque ffmpeg-python pour ajouter le fichier de sous-titres à une copie de la vidéo d'entrée.

Comprendre les sous-titres : structure et types

Un fichier de sous-titres est un fichier texte qui contient des informations textuelles chronométrées correspondant à un contenu parlé ou écrit dans une vidéo ou un film. Il contient généralement des informations sur le moment où chaque sous-titre doit apparaître et disparaître de l'écran. Il existe de nombreux formats de sous-titres, cependant, dans ce tutoriel, nous nous concentrerons sur le format largement utilisé appelé SubRip (SRT).

Un fichier de sous-titres est organisé en une série d'entrées de sous-titres, chacune suivant généralement un format spécifique. La structure commune d'une entrée de sous-titre comprend :

Index des sous-titres : Un numéro séquentiel indiquant l'ordre des sous-titres dans le fichier.
Les codes temporels : Ce sont des marqueurs de début et de fin qui spécifient quand le texte des sous-titres doit être affiché. Les codes temporels sont généralement formatés comme HH:MM:SS,sss (heures, minutes, secondes, millisecondes).
Texte des sous-titres : Le texte réel de l'entrée de sous-titres, représentant le contenu parlé ou écrit. Ce texte est affiché à l'écran pendant l'intervalle de temps spécifié.

Par exemple, une entrée de sous-titre dans un fichier SRT pourrait ressembler à ceci :

1
00:00:10,500 --> 00:00:15,000
This is an example subtitle.

Dans cet exemple, l'index est 1, les timestamps indiquent que les sous-titres doivent être affichés de 10,5 secondes à 15 secondes, et le texte des sous-titres est Ceci est un exemple de sous-titre.

Les sous-titres peuvent être divisés en deux types principaux :

Sous-titres souples : Également connus sous le nom de sous-titres codés, ils sont stockés séparément dans des fichiers externes (comme SRT) et peuvent être ajoutés ou supprimés indépendamment de la vidéo. Ils offrent une flexibilité aux spectateurs, permettant de basculer, de changer de langue et de personnaliser les paramètres. Cependant, leur efficacité dépend du support du lecteur vidéo, et tous les lecteurs n'accueillent pas universellement les sous-titres souples.
Les sous-titres durs : sont intégrés de manière permanente dans les images vidéo pendant le montage ou l'encodage, restant une partie fixe de la vidéo. Bien qu'ils garantissent une visibilité constante, même sur des lecteurs ne prenant pas en charge les fichiers de sous-titres externes, les modifications ou le fait de les désactiver nécessitent le réencodage de la vidéo entière, limitant ainsi le contrôle de l'utilisateur.

Créer le fichier de sous-titres

Retournez à votre fichier main.py et ajoutez le code suivant entre les fonctions transcribe() et run() :

def format_time(seconds):

    hours = math.floor(seconds / 3600)
    seconds %= 3600
    minutes = math.floor(seconds / 60)
    seconds %= 60
    milliseconds = round((seconds - math.floor(seconds)) * 1000)
    seconds = math.floor(seconds)
    formatted_time = f"{hours:02d}:{minutes:02d}:{seconds:01d},{milliseconds:03d}"

    return formatted_time

Ici, le code définit une fonction nommée format_time() qui est responsable de la conversion du temps de début et de fin d'un segment de transcription donné en secondes dans un format de temps compatible avec les sous-titres qui affiche les heures, les minutes, les secondes et les millisecondes (HH:MM:SS,sss).

Le code calcule d'abord les heures, les minutes, les secondes et les millisecondes à partir du temps donné en secondes, les formate en conséquence et retourne ensuite le temps formaté.

Ajoutez le code suivant entre les fonctions format_time() et run() :

def generate_subtitle_file(language, segments):

    subtitle_file = f"sub-{input_video_name}.{language}.srt"
    text = ""
    for index, segment in enumerate(segments):
        segment_start = format_time(segment.start)
        segment_end = format_time(segment.end)
        text += f"{str(index+1)} \n"
        text += f"{segment_start} --> {segment_end} \n"
        text += f"{segment.text} \n"
        text += "\n"
        
    f = open(subtitle_file, "w")
    f.write(text)
    f.close()

    return subtitle_file

Le code ajouté définit une fonction nommée generate_subtitle_file() qui prend en paramètres la langue détectée dans l'audio extrait et les segments de transcription. Cette fonction est responsable de la génération d'un fichier de sous-titres SRT basé sur la langue et les segments de transcription.

Tout d'abord, le code définit le nom du fichier de sous-titres à un nom formé en ajoutant sub- et la langue détectée au nom de base de la vidéo d'entrée avec l'extension “.srt ”, et stocke ce nom dans une constante nommée subtitle_file. De plus, le code définit une variable nommée text où vous allez stocker les entrées des sous-titres.

Ensuite, le code itère à travers les segments transcrits, formate les heures de début et de fin en utilisant la fonction format_time(), utilise ces valeurs formatées avec l'index du segment et le texte pour créer une entrée de sous-titre, puis ajoute une ligne vide pour séparer chaque entrée de sous-titre.

Enfin, le code crée un fichier de sous-titres dans le répertoire racine de votre projet avec le nom défini précédemment, ajoute les entrées de sous-titres au fichier et renvoie le nom du fichier de sous-titres.

Ajoutez le code suivant à la fin de votre fonction run() :

def run():

    extracted_audio = extract_audio()
    language, segments = transcribe(audio=extracted_audio)
    subtitle_file = generate_subtitle_file(
    language=language,
    segments=segments
    )

Le code ajouté appelle la fonction generate_subtitle_file() avec la langue détectée et les segments de transcription en tant qu'arguments, et stocke le nom du fichier de sous-titres retourné dans une constante nommée subtitle_file.

Retournez à votre terminal et exécutez la commande suivante pour exécuter le script main.py :

python3 main.py

Après avoir exécuté la commande ci-dessus, un fichier de sous-titres nommé sub-input.en.srt sera enregistré dans le répertoire racine de votre projet.

Ouvrez le fichier de sous-titres sub-input.en.srt et vous devriez voir quelque chose de similaire à ce qui suit :

1
00:00:0,000 --> 00:00:4,000
 This morning I wake up and I look in the mirror

2
00:00:4,000 --> 00:00:8,000
 Every part of my body was in the place many people lie

3
00:00:8,000 --> 00:00:11,000
 I don't wanna act too high and mighty

4
00:00:11,000 --> 00:00:15,000
 Cause tomorrow I may fall down on my face

5
00:00:15,000 --> 00:00:17,000
 Lord I thank You for sunshine

6
00:00:17,000 --> 00:00:19,000
 Thank You for rain

7
00:00:19,000 --> 00:00:20,000
 Thank You for joy

8
00:00:20,000 --> 00:00:22,000
 Thank You for pain
 
9
00:00:22,000 --> 00:00:25,000
 It's a beautiful day

10
00:00:25,000 --> 00:00:28,000
 It's a beautiful day

Ajouter des sous-titres aux vidéos

Ajoutez le code suivant entre la fonction generate_subtitle_file() et la fonction run():

def add_subtitle_to_video(soft_subtitle, subtitle_file,  subtitle_language):

    video_input_stream = ffmpeg.input(input_video)
    subtitle_input_stream = ffmpeg.input(subtitle_file)
    output_video = f"output-{input_video_name}.mp4"
    subtitle_track_title = subtitle_file.replace(".srt", "")

    if soft_subtitle:
        stream = ffmpeg.output(
            video_input_stream, subtitle_input_stream, output_video, **{"c": "copy", "c:s": "mov_text"},
            **{"metadata:s:s:0": f"language={subtitle_language}",
            "metadata:s:s:0": f"title={subtitle_track_title}"}
        )
        ffmpeg.run(stream, overwrite_output=True)

Ici, le code définit une fonction nommée add_subtitle_to_video() qui prend en paramètres une valeur booléenne utilisée pour déterminer si elle doit ajouter des sous-titres doux ou des sous-titres durs, le nom du fichier de sous-titres et la langue détectée dans la transcription. Cette fonction est responsable de l'ajout de sous-titres doux ou durs à une copie de la vidéo d'entrée.

Tout d'abord, le code utilise la méthode ffmpeg.input() avec le fichier vidéo d'entrée et le fichier de sous-titres pour créer des objets de flux d'entrée pour le fichier vidéo d'entrée et le fichier de sous-titres et les stocke dans des constantes nommées video_input_stream et subtitle_input_stream respectivement.

Après avoir créé les flux d'entrée, le code définit le nom du fichier vidéo de sortie sur un nom formé en ajoutant output- au nom de base de la vidéo d'entrée avec l'extension “.mp4 ”, et stocke ce nom dans une constante nommée output_video. De plus, il définit le nom de la piste de sous-titres sur le nom du fichier de sous-titres sans l'extension .srt et stocke ce nom dans une constante nommée subtitle_track_title.

Ensuite, le code vérifie si le boolean soft_subtitle est défini sur True, indiquant qu'il doit ajouter un sous-titre souple.

Si tel est le cas, le code appelle la méthode ffmpeg.output() pour créer un objet de flux de sortie avec les flux d'entrée, le nom du fichier vidéo de sortie et les options suivantes pour la vidéo de sortie :

Il spécifie que le codec vidéo et d'autres paramètres vidéo doivent être copiés directement de l'entrée à la sortie sans ré-encodage.
Il spécifie que le codec de sous-titres et les paramètres doivent également être copiés de l'entrée à la sortie sans ré-encodage. mov_text est un codec de sous-titres courant utilisé dans les fichiers MP4/MOV.
Il définit les métadonnées de langue pour le flux de sous-titres. La langue est définie sur la valeur stockée dans subtitle_language.
Il définit les métadonnées du titre pour le flux de sous-titres. Le titre est défini sur la valeur stockée dans subtitle_track_title.

Enfin, le code appelle la méthode ffmpeg.run(), en passant le flux de sortie comme paramètre pour ajouter les sous-titres au format soft à la vidéo et enregistrer le fichier vidéo de sortie dans le répertoire racine de votre projet.

Ajoutez le code suivant à la fin de votre fonction add_subtitle_to_video() :

def add_subtitle_to_video(soft_subtitle, subtitle_file,  subtitle_language):
    ...
    if soft_subtitle:
        ...
    else:
        stream = ffmpeg.output(video_input_stream, output_video,

                               vf=f"subtitles={subtitle_file}")

        ffmpeg.run(stream, overwrite_output=True)

Le code mis en surbrillance s'exécute si le booléen soft_subtitle est défini sur False, indiquant qu'il doit ajouter un sous-titre codé.

Si c'est le cas, d'abord, le code appelle la méthode ffmpeg.output() pour créer un objet de flux de sortie avec le flux vidéo d'entrée, le nom du fichier vidéo de sortie, et le paramètre vf=f"subtitles={subtitle_file}". Le vf signifie “filtre vidéo”, et il est utilisé pour appliquer un filtre au flux vidéo. Dans ce cas, le filtre appliqué est l'ajout des sous-titres.

Enfin, le code appelle la méthode ffmpeg.run(), en passant le flux de sortie comme paramètre pour ajouter le sous-titre codé à la vidéo et enregistrer le fichier vidéo de sortie dans le répertoire racine de votre projet.

Ajoutez le code mis en surbrillance suivant à la fonction run() :

def run():
    extracted_audio = extract_audio()
    language, segments = transcribe(audio=extracted_audio)
    subtitle_file = generate_subtitle_file(
        language=language,
        segments=segments
    )

    add_subtitle_to_video(
        soft_subtitle=True,
        subtitle_file=subtitle_file,
        subtitle_language=language
    )

Le code surligné appelle la fonction add_subtitle_to_video() avec le paramètre soft_subtitle réglé sur True, le nom du fichier de sous-titres et la langue des sous-titres pour ajouter un sous-titre doux à une copie de la vidéo d'entrée.

Retournez à votre terminal et exécutez la commande suivante pour exécuter le script main.py :

python3 main.py

Après avoir exécuté la commande ci-dessus, un fichier vidéo de sortie nommé output-input.mp4 sera enregistré dans le répertoire racine de votre projet.

Ouvrez la vidéo avec votre lecteur vidéo préféré, sélectionnez un sous-titre pour la vidéo, et remarquez que le sous-titre ne s'affichera pas tant que vous ne l'aurez pas sélectionné :

Retournez au fichier main.py, naviguez jusqu'à la fonction run(), et dans l'appel de la fonction add_subtitle_to_video(), définissez le paramètre soft_subtitle sur False:

def run():
    …
    add_subtitle_to_video(
        soft_subtitle=False,
        subtitle_file=subtitle_file,
        subtitle_language=language
    )

Ici, vous définissez le paramètre soft_subtitle sur False pour ajouter des sous-titres intégrés à la vidéo.

Retournez à votre terminal et exécutez la commande suivante pour exécuter le script main.py :

python3 main.py

Après avoir exécuté la commande ci-dessus, le fichier vidéo output-input.mp4 situé dans le répertoire racine de votre projet sera écrasé.

Ouvrez la vidéo avec votre lecteur vidéo préféré, essayez de sélectionner un sous-titre pour la vidéo et remarquez comment aucun n'est disponible alors qu'un sous-titre est affiché.

Dans cette section, vous avez acquis une compréhension de la structure d'un fichier de sous-titres SRT et utilisé les segments de transcription de la section précédente pour en créer un. Par la suite, la bibliothèque ffmpeg-python a été utilisée pour ajouter le fichier de sous-titres généré à la vidéo.

Conclusion

Dans ce tutoriel, vous avez utilisé les bibliothèques Python ffmpeg-python et faster-whisper pour créer une application capable d'extraire l'audio d'une vidéo d'entrée, de transcrire l'audio extrait, de générer un fichier de sous-titres basé sur la transcription et d'ajouter les sous-titres à une copie de la vidéo d'entrée.