Wie man Untertitel für Videos mit Python, OpenAI Whisper und FFmpeg generiert und hinzufügt

Der Autor wählte die Open Source Initiative, um eine Spende im Rahmen des Write for DOnations-Programms zu erhalten.

Einführung

In diesem Tutorial erstellen Sie eine Python-Anwendung, die in der Lage ist, Audio aus einem Eingangsvideo zu extrahieren, das extrahierte Audio zu transkribieren, eine Untertiteldatei basierend auf der Transkription zu generieren und dann den Untertitel zu einer Kopie des Eingangsvidoes hinzuzufügen.

Um diese Anwendung zu erstellen, verwenden Sie FFmpeg, um Audio aus einem Eingabevideo zu extrahieren. Sie verwenden OpenAI's Whisper, um ein Transkript für das extrahierte Audio zu erstellen, und verwenden dieses Transkript dann, um eine Untertiteldatei zu erstellen. Darüber hinaus verwenden Sie FFmpeg, um die generierte Untertiteldatei zu einer Kopie des Eingabevideos hinzuzufügen.

FFmpeg ist eine leistungsstarke und quelloffene Software-Suite zur Verarbeitung von Multimedia-Daten, einschließlich Audio- und Videoverarbeitungsaufgaben. Es bietet ein Befehlszeilenwerkzeug, das den Benutzern ermöglicht, Multimedia-Dateien in einer Vielzahl von Formaten und Codecs zu konvertieren, zu bearbeiten und zu manipulieren.

OpenAIs Whisper ist ein automatisches Spracherkennungssystem (ASR), das entwickelt wurde, um gesprochene Sprache in geschriebenen Text umzuwandeln. Es wurde mit einer großen Menge an mehrsprachigen und multitaskingüberwachten Daten trainiert und ist hervorragend darin, vielfältige Audioinhalte mit hoher Genauigkeit zu transkribieren.

Am Ende dieses Tutorials werden Sie eine Anwendung haben, die in der Lage ist, Untertitel zu einem Video hinzuzufügen:

Voraussetzungen

Um dieses Tutorial zu verfolgen, benötigt der Leser folgende Werkzeuge:

Python-Version 3.9+ und das entsprechende venv installiert
FFmpeg installiert.
Ein grundlegendes Verständnis von Python. Du kannst dieser Tutorialsreihe folgen, um zu lernen, wie man in Python programmiert.

Schritt 1 — Erstellung des Projektstammverzeichnisses

In diesem Abschnitt werden Sie das Projektverzeichnis erstellen, das Eingangsvideo herunterladen, eine virtuelle Umgebung erstellen und aktivieren sowie die erforderlichen Python-Pakete installieren.

Öffnen Sie ein Terminalfenster und navigieren Sie zu einem geeigneten Ort für Ihr Projekt. Führen Sie den folgenden Befehl aus, um das Projektverzeichnis zu erstellen:

mkdir generate-subtitle

Navigiere zum Projektverzeichnis:

cd generate-subtitle

Laden Sie dieses bearbeitete Video herunter und speichern Sie es im Hauptverzeichnis Ihres Projekts als input.mp4. Das Video zeigt ein Kind namens Rushawn, das "Beautiful Day" von Jermaine Edward singt. Das bearbeitete Video, das Sie in diesem Tutorial verwenden werden, stammt aus dem folgenden YouTube-Video:

Erstelle eine neue virtuelle Umgebung und nenne sie env:

python3 -m venv env

Aktivieren Sie die virtuelle Umgebung:

source env/bin/activate

Verwenden Sie jetzt den folgenden Befehl, um die benötigten Pakete zu installieren, um diese Anwendung zu erstellen:

pip3 install faster-whisper ffmpeg-python

Mit dem obigen Befehl haben Sie die folgenden Bibliotheken installiert:

faster-whisper: ist eine neu gestaltete Version des Whisper-Modells von OpenAI, die CTranslate2 nutzt, eine Hochleistungs-Inferenz-Engine für Transformermodelle. Diese Implementierung erreicht eine bis zu viermal höhere Geschwindigkeit als openai/whisper bei vergleichbarer Genauigkeit und verbraucht dabei weniger Speicher.
ffmpeg-python: ist eine Python-Bibliothek, die eine Schnittstelle um das FFmpeg-Tool bereitstellt und es Benutzern ermöglicht, einfach mit den FFmpeg-Funktionalitäten in Python-Skripten zu interagieren. Durch eine pythonartige Schnittstelle ermöglicht sie Video- und Audiobearbeitungsaufgaben wie Bearbeitung, Konvertierung und Manipulation.

Führen Sie den folgenden Befehl aus, um die Pakete, die mit pip in der virtuellen Umgebung installiert wurden, in einer Datei namens requirements.txt zu speichern:

pip3 freeze > requirements.txt

Die requirements.txt-Datei sollte ähnlich wie folgt aussehen:

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

In diesem Abschnitt haben Sie das Projektverzeichnis erstellt, das Eingabevideo heruntergeladen, das in diesem Tutorial verwendet wird, eine virtuelle Umgebung eingerichtet, sie aktiviert und die erforderlichen Python-Pakete installiert. Im nächsten Abschnitt werden Sie ein Transkript für das Eingabevideo erstellen.

Schritt 2 — Das Erstellen des Video-Transkripts

In diesem Abschnitt werden Sie das Python-Skript erstellen, in dem die Anwendung leben wird. In diesem Skript verwenden Sie die ffmpeg-python Bibliothek, um die Audiospur aus dem im vorherigen Abschnitt heruntergeladenen Video zu extrahieren und sie als WAV-Datei zu speichern. Anschließend verwenden Sie die faster-whisper Bibliothek, um ein Transkript für die extrahierte Audiodatei zu generieren.

Erstellen Sie im Stammverzeichnis Ihres Projekts eine Datei mit dem Namen main.py und fügen Sie den folgenden Code hinzu:

import time
import math
import ffmpeg

from faster_whisper import WhisperModel

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

Hier beginnt der Code mit dem Import verschiedener Bibliotheken und Module, einschließlich time, math, ffmpeg aus ffmpeg-python und einem benutzerdefinierten Modul namens WhisperModel aus faster_whisper. Diese Bibliotheken werden für die Video- und Audioverarbeitung, Transkription und Generierung von Untertiteln verwendet.

Als nächstes legt der Code den Namen der Eingabedatei für das Video fest, speichert ihn in einer Konstante namens input_video und speichert dann den Dateinamen des Videos ohne die .mp4-Erweiterung in einer Konstante namens input_video_name. Das Festlegen des Eingabedateinamens hier ermöglicht es Ihnen, an mehreren Eingabevideos zu arbeiten, ohne die Untertitel- und Ausgabedateien, die für sie erstellt wurden, zu überschreiben.

Fügen Sie den folgenden Code am Ende Ihrer main.py hinzu:

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

Der oben stehende Code definiert eine Funktion mit dem Namen extract_audio(), die dafür verantwortlich ist, den Ton aus dem eingegebenen Video zu extrahieren.

Zunächst wird der Name der Audioaufnahme auf einen Namen gesetzt, der gebildet wird, indem audio- an den Basisnamen des Eingangs-Videos mit einer .wav-Erweiterung angehängt wird, und dieser Name wird in einer Konstante namens extracted_audio gespeichert.

Als Nächstes ruft der Code die Methode ffmpeg.input() der ffmpeg-Bibliothek auf, um das Eingabevideo zu öffnen, und erstellt ein Eingabestream-Objekt mit dem Namen stream.

Der Code ruft dann die Methode ffmpeg.output() auf, um ein Ausgabestream-Objekt mit dem Eingabestream und dem definierten extrahierten Audiodateinamen zu erstellen.

Nachdem der Ausgabestrom festgelegt wurde, ruft der Code die Methode ffmpeg.run() auf und übergibt den Ausgabestrom als Parameter, um den Audiokomprimierungsprozess zu starten und die extrahierte Audiodatei im Stammverzeichnis Ihres Projekts zu speichern. Zusätzlich wird ein boolescher Parameter, overwrite_output=True, hinzugefügt, um eine bereits vorhandene Ausgabedatei durch die neu generierte zu ersetzen, falls eine solche Datei bereits existiert.

Schließlich gibt der Code den Namen der extrahierten Audiodatei zurück.

Fügen Sie den folgenden Code unter der extract_audio()-Funktion hinzu:

def run():

    extracted_audio = extract_audio()
run()

Hier definiert der Code eine Funktion namens run() und ruft sie dann auf. Diese Funktion ruft alle Funktionen auf, die benötigt werden, um Untertitel zu erzeugen und zu einem Video hinzuzufügen.

Innerhalb der Funktion ruft der Code die Funktion extract_audio() auf, um Audio aus einem Video zu extrahieren, und speichert dann den zurückgegebenen Dateinamen der Audiodatei in einer Variablen mit dem Namen extracted_audio.

Gehe zurück zu deinem Terminal und führe den folgenden Befehl aus, um das main.py Skript auszuführen:

python3 main.py

Nach der Ausführung des obigen Befehls wird die FFmpeg-Ausgabe im Terminal angezeigt, und eine Datei mit dem Namen audio-input.wav, die den aus dem Eingangsvideo extrahierten Audio enthält, wird im Stammverzeichnis Ihres Projekts gespeichert.

Gehen Sie zurück zu Ihrer main.py-Datei und fügen Sie den folgenden Code zwischen den Funktionen extract_audio() und run() hinzu:

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

Der obige Code definiert eine Funktion mit dem Namen transcribe, die für die Transkription der Audiodatei verantwortlich ist, die aus dem eingegebenen Video extrahiert wurde.

Zunächst erstellt der Code eine Instanz des WhisperModel Objekts und setzt den Modelltyp auf small. OpenAI's Whisper hat die folgenden Modelltypen: tiny, base, small, medium und large. Das tiny-Modell ist das kleinste und schnellste, während das large-Modell das größte und langsamste, aber am genauesten ist.

Als Nächstes ruft der Code die Methode model.transcribe() mit dem extrahierten Audio als Argument auf, um die Segments-Funktion und die Audioinformationen abzurufen und speichert sie in Variablen mit den Namen info und segments. Die Segments-Funktion ist ein Python-Generator, sodass die Transkription erst beginnt, wenn der Code über sie iteriert. Die Transkription kann vollständig ausgeführt werden, indem die Segmente in einer list oder in einer for-Schleife gesammelt werden.

Als Nächstes speichert der Code die in der Audiodatei erkannte Sprache in einer Konstante namens info und gibt sie in der Konsole aus.

Nachdem die erkannte Sprache ausgegeben wurde, sammelt der Code die Transkriptionssegmente in einer Liste, um die Transkription durchzuführen, und speichert die gesammelten Segmente in einer ebenfalls segments genannten Variablen. Der Code durchläuft dann die Liste der Transkriptionssegmente und gibt die Startzeit, Endzeit und den Text jedes Segments auf der Konsole aus.

Schließlich gibt der Code die in der Audiodatei erkannte Sprache und die Transkriptionssegmente zurück.

Fügen Sie den folgenden Code innerhalb der run() Funktion hinzu:

def run():

    extracted_audio = extract_audio()

    language, segments = transcribe(audio=extracted_audio)

Der hinzugefügte Code ruft die Transkriptionsfunktion mit der extrahierten Audiodatei als Argument auf und speichert die zurückgegebenen Werte in Konstanten mit den Namen language und segments.

Gehen Sie zurück zu Ihrem Terminal und führen Sie den folgenden Befehl aus, um das main.py Skript auszuführen:

python3 main.py

Beim ersten Ausführen dieses Skripts wird der Code zunächst das Whisper Small-Modell herunterladen und zwischenspeichern. Bei nachfolgenden Ausführungen wird es viel schneller sein.

Nachdem Sie den oben genannten Befehl ausgeführt haben, sollten Sie die folgende Ausgabe in der Konsole sehen:

…
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

Die obige Ausgabe zeigt, dass die in der Audiodatei erkannte Sprache Englisch (en) ist. Zusätzlich zeigt sie die Start- und Endzeit jedes Transkriptionssegments in Sekunden und den Text.

Warnung: Obwohl die Spracherkennung von OpenAI's Whisper sehr genau ist, ist sie nicht 100% genau. Sie kann Einschränkungen und gelegentliche Fehler aufweisen, insbesondere in herausfordernden sprachlichen oder audio-szenarien. Überprüfen Sie daher immer die Transkription manuell.

In diesem Abschnitt haben Sie ein Python-Skript für die Anwendung erstellt. Im Skript wurde ffmpeg-python verwendet, um den Ton aus dem heruntergeladenen Video zu extrahieren und als WAV-Datei zu speichern. Dann wurde die Bibliothek faster-whisper verwendet, um ein Transkript für den extrahierten Ton zu erstellen. Im nächsten Abschnitt werden Sie eine Untertiteldatei basierend auf dem Transkript generieren und dann den Untertitel dem Video hinzufügen.

Schritt 3 — Das Erstellen und Hinzufügen des Untertitels zum Video

In diesem Abschnitt werden Sie zunächst verstehen, was eine Untertiteldatei ist und wie sie strukturiert ist. Anschließend werden Sie die Transkriptionssegmente, die im vorherigen Abschnitt erstellt wurden, verwenden, um eine Untertiteldatei zu erstellen. Nach der Erstellung der Untertiteldatei werden Sie die ffmpeg-python Bibliothek verwenden, um die Untertiteldatei zu einer Kopie des Eingangs-Videos hinzuzufügen.

Verstehen von Untertiteln: Struktur und Typen

Eine Untertiteldatei ist eine Textdatei, die zeitlich abgestimmte Textinformationen enthält, die mit gesprochener oder geschriebener Sprache in einem Video oder Film übereinstimmen. Sie enthält typischerweise Informationen darüber, wann jeder Untertitel auf dem Bildschirm erscheinen und verschwinden soll. Es gibt viele Untertitelformate, jedoch werden wir in diesem Tutorial den weit verbreiteten Standard namens SubRip (SRT) behandeln.

Eine Untertiteldatei ist in eine Reihe von Untertitel-Einträgen organisiert, von denen jeder typischerweise einem bestimmten Format folgt. Die allgemeine Struktur eines Untertitel-Eintrags umfasst:

Untertitelindex: Eine sequenzielle Nummer, die die Reihenfolge des Untertitels in der Datei angibt.
Zeitcodes: Start- und Endzeitmarkierungen, die festlegen, wann der Untertiteltext angezeigt werden soll. Die Zeitcodes sind normalerweise im Format HH:MM:SS,sss (Stunden, Minuten, Sekunden, Millisekunden) formatiert.
Untertiteltext: Der eigentliche Text des Untertitel-Eintrags, der gesprochene oder geschriebene Inhalte darstellt. Dieser Text wird während des angegebenen Zeitintervalls auf dem Bildschirm angezeigt.

Zum Beispiel könnte ein Untertitel-Eintrag in einer SRT-Datei folgendermaßen aussehen:

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

In diesem Beispiel beträgt der Index 1, die Zeitcodes zeigen an, dass die Untertitel von 10,5 Sekunden bis 15 Sekunden angezeigt werden sollen, und der Untertiteltext lautet Dies ist ein Beispieluntertitel.

Untertitel lassen sich in zwei Haupttypen unterteilen:

Weiche Untertitel: Auch bekannt als geschlossene Untertitel, werden extern als separate Dateien (z. B. SRT) gespeichert und können unabhängig vom Video hinzugefügt oder entfernt werden. Sie bieten dem Zuschauer Flexibilität, da sie das Umschalten, den Sprachwechsel und die Anpassung der Einstellungen ermöglichen. Ihre Wirksamkeit hängt jedoch von der Unterstützung des Videoplayers ab, und nicht alle Player unterstützen universell weiche Untertitel.
Harte Untertitel: Sind während des Bearbeitens oder Kodierens dauerhaft in die Videobilder eingebettet und bleiben ein fester Teil des Videos. Während sie eine ständige Sichtbarkeit gewährleisten, selbst auf Playern, die keine Unterstützung für externe Untertiteldateien bieten, erfordern Änderungen oder das Ausschalten eine neuerliche Kodierung des gesamten Videos, was die Benutzerkontrolle einschränkt.

Erstellen der Untertiteldatei

Gehe zurück zu deiner main.py-Datei und füge den folgenden Code zwischen den transcribe()- und run()-Funktionen hinzu:

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

Hier definiert der Code eine Funktion namens format_time(), die dafür verantwortlich ist, die Start- und Endzeit eines gegebenen Transkriptionssegments in Sekunden in ein untertitelkompatibles Zeitformat umzuwandeln, das Stunden, Minuten, Sekunden und Millisekunden anzeigt (HH:MM:SS,sss).

Der Code berechnet zunächst Stunden, Minuten, Sekunden und Millisekunden aus der gegebenen Zeit in Sekunden, formatiert sie entsprechend und gibt dann die formatierte Zeit zurück.

Fügen Sie den folgenden Code zwischen den Funktionen format_time() und run() ein:

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

Der hinzugefügte Code definiert eine Funktion namens generate_subtitle_file(), die als Parameter die in der extrahierten Audiodatei erkannte Sprache und die Transkriptionssegmente übernimmt. Diese Funktion ist dafür verantwortlich, eine SRT-Untertiteldatei basierend auf der Sprache und den Transkriptionssegmenten zu erstellen.

Zuerst setzt der Code den Namen der Untertiteldatei auf einen Namen, der gebildet wird, indem sub- und die erkannte Sprache an den Basisnamen des Eingangsvideos mit der Endung “.srt ” angehängt werden, und speichert diesen Namen in einer konstanten Variable namens subtitle_file. Zusätzlich definiert der Code eine Variable namens text, in der Sie die Untertitel-Einträge speichern werden.

Als nächstes durchläuft der Code die transkribierten Segmente, formatiert die Start- und Endzeiten mit der format_time()-Funktion, verwendet diese formatierten Werte zusammen mit dem Segmentindex und dem Text, um einen Untertitel-Eintrag zu erstellen, und fügt dann eine leere Zeile hinzu, um jeden Untertitel-Eintrag zu trennen.

Schließlich erstellt der Code eine Untertiteldatei im Stammverzeichnis Ihres Projekts mit dem zuvor festgelegten Namen, fügt die Untertitel-Einträge zur Datei hinzu und gibt den Dateinamen der Untertitel zurück.

Fügen Sie den folgenden Code am Ende Ihrer run()-Funktion hinzu:

def run():

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

Der hinzugefügte Code ruft die Funktion generate_subtitle_file() mit der erkannten Sprache und den Transkriptionssegmenten als Argumente auf und speichert die zurückgegebene Untertiteldatei unter einem konstanten Namen subtitle_file.

Gehen Sie zurück zu Ihrem Terminal und führen Sie den folgenden Befehl aus, um das main.py Skript auszuführen:

python3 main.py

Nachdem Sie den oben genannten Befehl ausgeführt haben, wird eine Untertiteldatei mit dem Namen sub-input.en.srt im Stammverzeichnis Ihres Projekts gespeichert.

Öffnen Sie die sub-input.en.srt Untertiteldatei und Sie sollten etwas Ähnliches wie das Folgende sehen:

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

Untertitel zu Videos hinzufügen

Fügen Sie den folgenden Code zwischen der generate_subtitle_file() und der run() Funktion hinzu:

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)

Hier definiert der Code eine Funktion namens add_subtitle_to_video(), die als Parameter einen booleschen Wert verwendet, um zu bestimmen, ob ein weicher Untertitel oder ein harter Untertitel hinzugefügt werden soll, den Dateinamen der Untertitel und die in der Transkription erkannte Sprache. Diese Funktion ist verantwortlich für das Hinzufügen von weichen oder harten Untertiteln zu einer Kopie des Eingabevideos.

Zuerst verwendet der Code die Methode ffmpeg.input() mit der Eingabe-Video- und Untertiteldatei, um Eingabestream-Objekte für das Eingabevideo und die Untertiteldatei zu erstellen und speichert sie in Konstanten mit den Namen video_input_stream und subtitle_input_stream.

Nachdem die Eingabeströme erstellt wurden, setzt der Code den Namen der Ausgabedatei des Videos auf einen Namen, der gebildet wird, indem output- an den Basisnamen des Eingabevideos mit der Endung “.mp4” angehängt wird, und speichert diesen Namen in einer Konstante namens output_video. Zusätzlich wird der Name des Untertiteltracks auf den Dateinamen der Untertitel ohne die Endung .srt gesetzt und dieser Name in einer Konstante namens subtitle_track_title gespeichert.

Als nächstes prüft der Code, ob die boolesche soft_subtitle auf True gesetzt ist, was anzeigt, dass ein weicher Untertitel hinzugefügt werden sollte.

Wenn das der Fall ist, ruft der Code die Methode ffmpeg.output() auf, um ein Ausgabestream-Objekt mit den Eingabestreams, dem Ausgabename der Videodatei und den folgenden Optionen für das Ausvideo zu erstellen:

Es gibt an, dass der Video-Codec und andere Video-Parameter direkt vom Eingang zum Ausgang kopiert werden sollen, ohne neu codiert zu werden.
"c:s": "mov_text": Es gibt an, dass der Untertitel-Codec und die Parameter ebenfalls unverändert von der Eingabe in die Ausgabe kopiert werden sollen, ohne neu codiert zu werden. "mov_text" ist ein gängiger Untertitel-Codec, der in MP4/MOV-Dateien verwendet wird.
Es legt die Sprachmetadaten für den Untertitelstrom fest. Die Sprache wird auf den Wert gesetzt, der in subtitle_language gespeichert ist.
Es setzt die Titelmetadaten für den Untertitelstrom. Der Titel wird auf den Wert gesetzt, der in subtitle_track_title gespeichert ist.

Schließlich ruft der Code die Methode ffmpeg.run() auf und übergibt den Ausgabestrom als Parameter, um die weichen Untertitel zum Video hinzuzufügen und die Ausgabedatei im Stammverzeichnis Ihres Projekts zu speichern.

Fügen Sie den folgenden Code am Ende Ihrer add_subtitle_to_video() Funktion hinzu:

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)

Der hervorgehobene Code wird ausgeführt, wenn der boolesche soft_subtitle auf False gesetzt ist, was anzeigt, dass ein harter Untertitel hinzugefügt werden soll.

Falls das der Fall ist, ruft der Code zuerst die Methode ffmpeg.output() auf, um ein Ausgabestream-Objekt mit dem Eingangs-Video-Stream, dem Namen der Ausgabedatei und dem Parameter vf=f"subtitles={subtitle_file}" zu erstellen. Das vf steht für „Video-Filter“ und wird verwendet, um einen Filter auf den Video-Stream anzuwenden. In diesem Fall besteht der angewendete Filter darin, die Untertitel hinzuzufügen.

Schließlich ruft der Code die Methode ffmpeg.run() auf und übergibt den Ausgabestrom als Parameter, um die harten Untertitel zum Video hinzuzufügen und die Ausgabedatei im Stammverzeichnis Ihres Projekts zu speichern.

Fügen Sie den folgenden hervorgehobenen Code zur run()-Funktion hinzu:

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
    )

Der hervorgehobene Code ruft die add_subtitle_to_video() mit dem Parameter soft_subtitle, der auf True gesetzt ist, dem Dateinamen der Untertitel und der Untertitelsprache auf, um einem Kopie des Eingabevideos einen Soft-Untertitel hinzuzufügen.

Gehen Sie zurück zu Ihrem Terminal und führen Sie den folgenden Befehl aus, um das main.py Skript auszuführen:

python3 main.py

Nachdem Sie den oben genannten Befehl ausgeführt haben, wird eine Ausgabedatei namens output-input.mp4 im Stammverzeichnis Ihres Projekts gespeichert.

Öffnen Sie das Video mit Ihrem bevorzugten Videoplayer, wählen Sie ein Untertitel für das Video aus und beachten Sie, dass der Untertitel erst angezeigt wird, wenn Sie ihn auswählen:

Gehe zurück zur main.py Datei, navigiere zur run() Funktion und setze im Aufruf der Funktion add_subtitle_to_video() den Parameter soft_subtitle auf False:

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

Hier setzen Sie den soft_subtitle Parameter auf False, um dem Video harte Untertitel hinzuzufügen.

Gehen Sie zurück zu Ihrem Terminal und führen Sie den folgenden Befehl aus, um das main.py Skript auszuführen:

python3 main.py

Nachdem Sie den oben genannten Befehl ausgeführt haben, wird die output-input.mp4 Videodatei, die sich im Stammverzeichnis Ihres Projekts befindet, überschrieben.

Öffnen Sie das Video mit Ihrem bevorzugten Videoplayer, versuchen Sie, ein Untertitel für das Video auszuwählen, und beachten Sie, dass zwar kein Untertitel verfügbar ist, aber dennoch ein Untertitel angezeigt wird:

In diesem Abschnitt haben Sie ein Verständnis für die Struktur einer SRT-Untertiteldatei gewonnen und die Transkriptionssegmente aus dem vorherigen Abschnitt genutzt, um eine zu erstellen. Anschließend wurde die ffmpeg-python Bibliothek verwendet, um die erzeugte Untertiteldatei zum Video hinzuzufügen.

Schlussfolgerung

In diesem Tutorial haben Sie die Python-Bibliotheken ffmpeg-python und faster-whisper verwendet, um eine Anwendung zu erstellen, die in der Lage ist, Audio aus einem Eingangsvideo zu extrahieren, das extrahierte Audio zu transkribieren, eine Untertiteldatei auf Grundlage der Transkription zu erstellen und die Untertitel zu einer Kopie des Eingangsvideos hinzuzufügen.