Bitdoze-Logo

Python-Video-Intro-Editor: Silero VAD + MoviePy auf dem Mac

Baue einen Python-Video-Intro-Editor mit Silero VAD, MoviePy und FFmpeg. Erkenne Sprache in deinem Videomaterial automatisch und rendere eine Intro-Montage im 3D-Stil auf dem Mac.

Dragos

Aktualisiert Veröffentlicht 17 Min. Lesezeit

Terminal-Ausgabe eines Python-Video-Intro-Editors, der mit Silero VAD Sprache erkennt und eine 3D-Intro-Montage auf dem Mac rendert

Hinweis: Diese Anleitung enthält Referral-Links. Wenn du darüber kaufst, erhalte ich möglicherweise eine Provision – ohne zusätzliche Kosten für dich.

Ein Intro von Hand zu schneiden heißt: durchs Videomaterial scrubben, gute Momente suchen und bei jedem Upload dieselbe Montage neu bauen. Dieser Guide zeigt dir, wie du einen Python-Video-Intro-Editor baust, der das für dich erledigt: Er analysiert dein Footage, erkennt per Voice Activity Detection (VAD), wann jemand spricht, und rendert eine Intro-Montage im 3D-Stil.

Der Stack: Silero VAD findet die Sprache lokal, FFmpeg übernimmt den Blur und die Perspektiv-Effekte, MoviePy kompositiert die schnellen Schnitte, und uv führt das Ganze als einzelnes Skript aus – ganz ohne manuelles Dependency-Management. Die Anleitung zielt auf einen Mac; das Skript darunter ist schlichtes Python.

Was du lernen wirst

  • Sprache lokal mit Silero VAD erkennen – ohne API-Key
  • Clips mit FFmpeg-Filtern blurren und in 3D verzerren
  • Schnelle Schnitte mit MoviePy kompositieren: 3x-Tempo, Slides, Crossfades
  • Alles mit einem einzigen uv run-Befehl ausführen – dank PEP-723-Inline-Dependencies

Voraussetzungen


  • FFmpeg über Homebrew installiert
  • uv installiert (ein curl-Befehl)
  • Ein Quellvideo, in dem Leute sprechen
  • Ein paar GB freier Speicher für den einmaligen PyTorch-Download

FFmpeg

FFmpeg übernimmt die Audio-Extraktion, den Blur und den 3D-Warp. Installiere es mit Homebrew:

bash
brew install ffmpeg

Prüfe, ob es funktioniert:

bash
ffmpeg -version

Du solltest eine Versionszeile wie ffmpeg version 7.x sehen. Bekommst du zsh: command not found: ffmpeg, hat Homebrew nicht verlinkt; führe brew link ffmpeg aus oder öffne dein Terminal neu.

uv

uv verwaltet die Python-Seite, inklusive des Interpreters selbst. Installiere es mit:

bash
curl -LsSf https://astral.sh/uv/install.sh | sh

Prüfen:

bash
uv --version

Python und Speicherplatz

Das Skript deklariert requires-python = ">=3.10", und uv lädt beim ersten Lauf ein passendes Python herunter und verwaltet es – du musst Python also nicht von Hand installieren oder konfigurieren. Wenn du lieber einen regulären Interpreter plus venv-Setup auf der Maschine behalten willst, folge dieser Anleitung, um Python auf dem Mac zu installieren und eine virtuelle Umgebung einzurichten.

Plane ein paar Gigabyte freien Speicher ein: Der erste Lauf lädt PyTorch und die Modellgewichte von Silero VAD. Alles danach kommt aus dem Cache.

Neu bei uv?

Wenn du neu bei uv bist, behandelt Erste Schritte mit uv: Python-Projekt-Setup in 2026 das Projekt-Setup und die Umgebungs-Basics. Für diesen Artikel brauchst du nur einen Befehl: uv run.

So funktioniert der Python-Video-Intro-Editor


Das Skript führt eine geradlinige Pipeline von Rohmaterial bis zur fertigen Montage aus:

  1. Extrahiert das Audio aus deinem Video mit FFmpeg als 16-kHz-Mono-WAV
  2. Lässt Silero VAD über das Audio laufen, um zu finden, wo jemand spricht
  3. Wählt Sprachsegmente länger als 2 Sekunden und sampelt sechs davon
  4. Baut pro Clip mit FFmpeg einen geblurrten Hintergrund plus einen 3D-perspektivisch verzerrten Vordergrund
  5. Kompositiert die Ebenen in MoviePy mit 3x-Tempo, Slide und Crossfade
  6. Hängt die Clips aneinander und muxt eine stille Audiospur in intro_only.mp4

Mit den Defaults sind das sechs Clips à 1,5 Sekunden: eine etwa 9-sekündige Montage mit stiller Audiospur, fertig zum Ablegen unter einem Musikbett.

Pipeline-Diagramm des Python-Video-Intro-Editors: FFmpeg extrahiert Audio, Silero VAD erkennt Sprache, FFmpeg verzerrt Clips, MoviePy kompositiert das Intro.input.mp4FFmpeg · Audio als 16-kHz-Mono-WAVSilero VAD · Sprach-Timestamps findenSprachsegmente über 2 s · 6 sampelnpro Clip × 6FFmpeggeblurrter HintergrundFFmpeg3D-Perspektiv-WarpMoviePy · 3x-Tempo, Slides, CrossfadesFFmpeg · stille Audiospur muxenintro_only.mp4

Die Intro-Pipeline: FFmpeg extrahiert das Audio, Silero VAD findet die Sprachstellen, der Picker sampelt sechs Segmente, FFmpeg baut pro Clip den geblurrten Hintergrund und den 3D-verzerrten Vordergrund, MoviePy kompositiert und hängt aneinander, und ein letzter FFmpeg-Durchlauf fügt die stille Audiospur hinzu.

Das komplette Skript


Hier ist das vollständige Skript. Speichere es als intro_generator.py; der PEP-723-Header oben sagt uv exakt, welche gepinnten Dependencies installiert werden müssen – uv run ist also der einzige Befehl, den du brauchst.

python
# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "openai-whisper",
#     "torch",
#     "torchaudio<2.6",
#     "soundfile",
#     "numpy<2.0.0",
#     "moviepy==1.0.3",
#     "packaging",
#     "Pillow<10.0.0",
# ]
# ///

import os
import sys
import warnings

# 1. Suppress warnings BEFORE importing moviepy
# This hides the "invalid escape sequence" text
warnings.filterwarnings("ignore")

import random
import subprocess
from pathlib import Path

import torch
import whisper
from moviepy.editor import (
    CompositeVideoClip,
    VideoFileClip,
    concatenate_videoclips,
    vfx,
)

# --- Configuration ---
MIN_SILENCE = 0.5
MIN_SPEECH = 0.25
PADDING = 0.1

# Intro Style Settings
INTRO_CLIP_COUNT = 6  # Number of fast cuts
INTRO_SPEED = 3.0  # Speed multiplier (3x fast)
CLIP_DURATION = 1.5  # Duration of each clip in seconds
OUTPUT_FILENAME = "intro_only.mp4"


def check_ffmpeg():
    try:
        subprocess.run(["ffmpeg", "-version"], capture_output=True, check=True)
    except:
        print("❌ Error: FFmpeg not found. Run: brew install ffmpeg")
        sys.exit(1)


def extract_audio(video_path, audio_path):
    subprocess.run(
        [
            "ffmpeg",
            "-y",
            "-i",
            video_path,
            "-vn",
            "-acodec",
            "pcm_s16le",
            "-ar",
            "16000",
            "-ac",
            "1",
            "-loglevel",
            "error",
            audio_path,
        ],
        check=True,
    )


def get_good_segments(audio_path):
    """Finds segments where people are actually speaking (Key Moments)."""
    print("🧠 Scanning video for key moments...")

    # Load Silero VAD
    # trust_repo=True fixes the "cache" warning/error
    model, utils = torch.hub.load(
        repo_or_dir="snakers4/silero-vad", model="silero_vad", trust_repo=True
    )
    (get_speech_timestamps, _, read_audio, _, _) = utils

    wav = read_audio(audio_path)
    vad_stamps = get_speech_timestamps(
        wav,
        model,
        threshold=0.5,
        min_speech_duration_ms=int(MIN_SPEECH * 1000),
        min_silence_duration_ms=int(MIN_SILENCE * 1000),
    )

    segments = []
    for v in vad_stamps:
        segments.append((v["start"] / 16000, v["end"] / 16000))

    return segments


def apply_blur_background(input_path, output_path):
    subprocess.run(
        [
            "ffmpeg",
            "-y",
            "-i",
            input_path,
            "-vf",
            "boxblur=40:5,eq=brightness=-0.4",
            "-c:v",
            "libx264",
            "-preset",
            "ultrafast",
            "-an",
            "-loglevel",
            "error",
            output_path,
        ],
        check=True,
    )


def apply_3d_warp(input_path, output_path, direction="left"):
    if direction == "left":
        vf = "perspective=x0=0:y0=0:x1=W:y1=H/5:x2=0:y2=H:x3=W:y3=4*H/5:sense=destination"
    else:
        vf = "perspective=x0=0:y0=H/5:x1=W:y1=0:x2=0:y2=4*H/5:x3=W:y3=H:sense=destination"

    vf += ",pad=w=iw+100:h=ih+100:x=50:y=50:color=black@0"

    subprocess.run(
        [
            "ffmpeg",
            "-y",
            "-i",
            input_path,
            "-vf",
            vf,
            "-c:v",
            "libx264",
            "-preset",
            "ultrafast",
            "-an",
            "-loglevel",
            "error",
            output_path,
        ],
        check=True,
    )


def generate_intro(video_path, segments):
    print("✨ Rendering 3D Intro (No Text)...")

    long_segments = [s for s in segments if (s[1] - s[0]) > 2.0]

    if len(long_segments) < INTRO_CLIP_COUNT:
        print(f"⚠️ Not enough footage found. Need {INTRO_CLIP_COUNT} distinct moments.")
        if not long_segments:
            return
        picks = random.choices(long_segments, k=INTRO_CLIP_COUNT)
    else:
        picks = sorted(random.sample(long_segments, INTRO_CLIP_COUNT))

    intro_clips = []
    temp_files = []

    for i, (start, end) in enumerate(picks):
        raw_dur = CLIP_DURATION * INTRO_SPEED
        mid = start + (end - start) / 2 - (raw_dur / 2)

        raw_clip = f"temp_raw_{i}.mp4"
        bg_clip = f"temp_bg_{i}.mp4"
        fg_clip = f"temp_fg_{i}.mp4"

        # 1. Extract
        subprocess.run(
            [
                "ffmpeg",
                "-y",
                "-ss",
                str(mid),
                "-t",
                str(raw_dur),
                "-i",
                video_path,
                "-c:v",
                "libx264",
                "-an",
                "-loglevel",
                "error",
                raw_clip,
            ],
            check=True,
        )

        # 2. Process
        apply_blur_background(raw_clip, bg_clip)

        direction = "left" if i % 2 == 0 else "right"
        apply_3d_warp(raw_clip, fg_clip, direction)

        # 3. Composite
        try:
            bg = VideoFileClip(bg_clip).fx(vfx.speedx, INTRO_SPEED)
            fg = VideoFileClip(fg_clip).fx(vfx.speedx, INTRO_SPEED)

            if direction == "left":
                fg = fg.set_position(
                    lambda t: (int(-50 + 50 * (t / CLIP_DURATION)), "center")
                )
            else:
                fg = fg.set_position(
                    lambda t: (int(50 - 50 * (t / CLIP_DURATION)), "center")
                )

            comp = CompositeVideoClip([bg, fg]).set_duration(CLIP_DURATION)
            if i > 0:
                comp = comp.crossfadein(0.2)

            intro_clips.append(comp)
            temp_files.extend([raw_clip, bg_clip, fg_clip])

        except Exception as e:
            print(f"   ⚠️ Error processing clip {i}: {e}")

    if not intro_clips:
        print("❌ Failed to generate intro clips.")
        return

    # Concatenate
    full_montage = concatenate_videoclips(intro_clips, method="compose")

    print("   💾 Saving video file...")
    full_montage.write_videofile(
        "temp_visual_intro.mp4", fps=24, codec="libx264", logger=None
    )

    # Add silent audio
    print("   🔊 Adding silent audio track...")
    subprocess.run(
        [
            "ffmpeg",
            "-y",
            "-i",
            "temp_visual_intro.mp4",
            "-f",
            "lavfi",
            "-i",
            "anullsrc=channel_layout=mono:sample_rate=44100",
            "-c:v",
            "copy",
            "-c:a",
            "aac",
            "-shortest",
            "-loglevel",
            "error",
            OUTPUT_FILENAME,
        ],
        check=True,
    )

    # Cleanup
    for f in temp_files:
        if os.path.exists(f):
            os.remove(f)
    if os.path.exists("temp_visual_intro.mp4"):
        os.remove("temp_visual_intro.mp4")

    print(f"✅ Success! Intro saved as: {OUTPUT_FILENAME}")


def main():
    if len(sys.argv) < 2:
        print("Usage: uv run intro_generator.py <video.mp4>")
        sys.exit(1)

    input_video = sys.argv[1]
    check_ffmpeg()

    temp_wav = "temp_analysis.wav"

    try:
        extract_audio(input_video, temp_wav)

        good_parts = get_good_segments(temp_wav)

        if not good_parts:
            print("⚠️ No speech detected. Picking random segments...")
            duration = float(
                subprocess.check_output(
                    [
                        "ffprobe",
                        "-v",
                        "error",
                        "-show_entries",
                        "format=duration",
                        "-of",
                        "default=noprint_wrappers=1:nokey=1",
                        input_video,
                    ]
                )
            )
            good_parts = [(t, t + 5) for t in range(0, int(duration), 10)]

        generate_intro(input_video, good_parts)

    finally:
        if os.path.exists(temp_wav):
            os.remove(temp_wav)


if __name__ == "__main__":
    main()

Das Skript verstehen


Das Skript deklariert seine Dependencies über PEP-723-Inline-Metadaten:

python
# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "openai-whisper",
#     "torch",
#     "torchaudio<2.6",
#     "soundfile",
#     "numpy<2.0.0",
#     "moviepy==1.0.3",
#     "packaging",
#     "Pillow<10.0.0",
# ]
# ///

Wenn du es ausführst, erstellt uv eine isolierte Umgebung, installiert exakt diese Versionen und rührt nichts an deinem globalen Python an. Das Muster behandelt uv run: Python-Skripte ganz ohne Dependency-Management ausführen ausführlicher.

Konfigurationsvariablen

Variable Standard Beschreibung
MIN_SILENCE 0.5 Minimale Stilldauer in Sekunden
MIN_SPEECH 0.25 Minimale Sprechdauer in Sekunden
INTRO_CLIP_COUNT 6 Anzahl der Clips im Intro
INTRO_SPEED 3.0 Geschwindigkeitsmultiplikator für Clips
CLIP_DURATION 1.5 Dauer jedes Clips in Sekunden
OUTPUT_FILENAME “intro_only.mp4” Name der Ausgabedatei

Zwei davon bestimmen die Länge des Intros: Die Gesamtlaufzeit ist immer INTRO_CLIP_COUNT × CLIP_DURATION – mit den Defaults ergibt das eine 9-sekündige Montage.

Voice Activity Detection (VAD)

Die Spracherkennung ist das, was hieraus einen Editor statt einen Zufalls-Clip-Sampler macht. get_good_segments() lädt Silero VAD über torch.hub und fragt es nach jedem Zeitfenster, in dem jemand spricht:

python
def get_good_segments(audio_path):
    """Finds segments where people are actually speaking (Key Moments)."""
    model, utils = torch.hub.load(
        repo_or_dir="snakers4/silero-vad", model="silero_vad", trust_repo=True
    )
    (get_speech_timestamps, _, read_audio, _, _) = utils

    wav = read_audio(audio_path)
    vad_stamps = get_speech_timestamps(
        wav,
        model,
        threshold=0.5,
        min_speech_duration_ms=int(MIN_SPEECH * 1000),
        min_silence_duration_ms=int(MIN_SILENCE * 1000),
    )

    return [(v["start"] / 16000, v["end"] / 16000) for v in vad_stamps]

Silero VAD ist die übliche Wahl für Voice Activity Detection in Python: Das Modell ist rund zwei Megabyte groß, läuft auf der CPU und arbeitet nach dem einmaligen Download komplett offline. Du brauchst keinen API-Key, und es gibt keine Kosten pro Minute. Es liefert Start- und Endpositionen in Samples bei 16 kHz, die die Funktion in Sekunden umrechnet. Das Argument threshold=0.5 ist der Sensitivitätsregler: Senke ihn, wenn leise Sprache durchrutscht, erhöhe ihn, wenn Hintergrundgeräusche Fehltreffer erzeugen.

3D-Perspektiv-Effekte mit FFmpeg

Der 3D-Look kommt vom perspective-Filter von FFmpeg, der mit abwechselnder Richtung auf jeden Clip angewendet wird:

python
def apply_3d_warp(input_path, output_path, direction="left"):
    if direction == "left":
        vf = "perspective=x0=0:y0=0:x1=W:y1=H/5:x2=0:y2=H:x3=W:y3=4*H/5:sense=destination"
    else:
        vf = "perspective=x0=0:y0=H/5:x1=W:y1=0:x2=0:y2=4*H/5:x3=W:y3=H:sense=destination"

sense=destination sagt FFmpeg, die vier Eckpunkte des Outputs auf die Quelle abzubilden. Das presst den Frame in ein Trapez, statt ihn zu strecken: Eine Kante kippt nach innen, während die gegenüberliegende fixiert bleibt. Der pad-Filter hinter dem Perspective-String fügt auf jeder Seite 50 Pixel transparenten Rand hinzu, damit der verzerrte Clip später ohne harte Kanten über den geblurrten Hintergrund sliden kann.

Video-Compositing mit MoviePy

MoviePy stapelt jeden Clip als geblurrten Hintergrund mit einem verzerrten Vordergrund, der darübergleitet:

python
bg = VideoFileClip(bg_clip).fx(vfx.speedx, INTRO_SPEED)
fg = VideoFileClip(fg_clip).fx(vfx.speedx, INTRO_SPEED)

if direction == "left":
    fg = fg.set_position(
        lambda t: (int(-50 + 50 * (t / CLIP_DURATION)), "center")
    )

comp = CompositeVideoClip([bg, fg]).set_duration(CLIP_DURATION)

Beide Ebenen werden mit vfx.speedx auf 3x beschleunigt, der Vordergrund bewegt sich über die 1,5 Sekunden des Clips 50 Pixel Richtung Mitte, und CompositeVideoClip drückt den Stapel flach. Jeder fertige Clip bekommt ein 0,2-sekündiges crossfadein, dann stapelt concatenate_videoclips alle sechs zur Montage.

Warum MoviePy auf 1.0.3 gepinnt ist

MoviePy 2.0 erschien Ende 2024 mit einem Breaking Rewrite: Das Modul moviepy.editor ist weg, aus set_position wurde with_position, und die .fx()-Verkettung hat sich geändert. Dieses Skript importiert direkt aus moviepy.editor – jede 2.x-Installation schlägt deshalb schon beim Import fehl.

Dieser Pin ist es, der das Skript reproduzierbar hält. uv liest den Header, installiert MoviePy 1.0.3 in eine Umgebung, die allein dieser Datei gehört, und nichts sonst auf deiner Maschine ändert sich. Auf die 2.x-API zu migrieren ist ein sinnvolles Projekt (der with_position-Stil ist sauberer), aber es ist ein Rewrite des Compositing-Codes, kein Version-Bump. Falls der Import-Fehler trotzdem auftaucht, steht der Fix im Abschnitt Fehlerbehebung weiter unten.

Das Skript ausführen


Mit installiertem uv und FFmpeg:

bash
uv run intro_generator.py your_video.mp4

Der erste Lauf dauert länger: uv löst die gepinnten Dependencies auf und installiert sie (PyTorch ist der große Brocken), und torch.hub lädt das Silero-VAD-Modell einmal herunter. Danach ist alles gecacht, und spätere Läufe zahlen nur noch für den Render.

Weil das Ganze nur uv plus FFmpeg ist, lässt sich das Skript auch gut umziehen: Wenn du eine reproduzierbare Umgebung auf einem Server statt auf deinem Mac willst, schau dir an, wie du jede Python-App in Docker laufen lässt.

Erwartete Ausgabe

text
🧠 Scanning video for key moments...
✨ Rendering 3D Intro (No Text)...
   💾 Saving video file...
   🔊 Adding silent audio track...
✅ Success! Intro saved as: intro_only.mp4

Ausgabe verifizieren

Drei Checks, bevor du es als fertig abhakst.

Die Dauer sollte mit den Defaults bei knapp 9 Sekunden landen (6 Clips × 1,5 s):

bash
ffprobe -v error -show_entries format=duration \
  -of default=noprint_wrappers=1:nokey=1 intro_only.mp4

Der Audio-Stream muss existieren und aac sein – das ist die stille Spur, die das Skript einmuxt:

bash
ffprobe -v error -select_streams a -show_entries stream=codec_name \
  -of default=noprint_wrappers=1:nokey=1 intro_only.mp4

Erwartete Ausgabe: aac. Wenn hier nichts ausgegeben wird, ist der Silent-Audio-Schritt fehlgeschlagen, und Editoren werden sich über eine fehlende Spur beschweren.

Zum Schluss der Sichtcheck: open intro_only.mp4. Du solltest sechs schnelle Schnitte sehen, die links und rechts 3D-verzerrte Warps über einem geblurrten, abgedunkelten Hintergrund abwechseln, mit kurzen Crossfades zwischen den Clips. Wenn es schiefgeht: Eine Dauer weit abseits von 9 Sekunden heißt, dass einzelne Clips beim Processing Fehler geworfen haben (scrolle im Terminal nach den ⚠️-Zeilen), und ein flaches, unverzerrtes Bild heißt, dass der Perspective-Filter-String bei einer Bearbeitung zerhackt wurde.

Ausgabe anpassen


Bearbeite den Konfigurationsblock oben im Skript, um den Stil zu ändern.

Anzahl der Clips ändern

python
INTRO_CLIP_COUNT = 8  # More clips

Tempo anpassen

python
INTRO_SPEED = 2.0  # Slower
INTRO_SPEED = 4.0  # Faster

Clip-Dauer ändern

python
CLIP_DURATION = 2.0  # Longer clips
CLIP_DURATION = 1.0  # Shorter clips

Blur-Intensität ändern

Bearbeite den Filter-String in apply_blur_background():

python
# Stronger blur
"-vf", "boxblur=60:10,eq=brightness=-0.5"

# Lighter blur
"-vf", "boxblur=20:3,eq=brightness=-0.2"

Style-Presets

Drei Startpunkte, wenn du nicht vier Regler von Grund auf einstellen willst. Jedes Preset ändert den Config-Block, und die Presets mit Blur greifen auch in den Filter-String in apply_blur_background().

Standard (schnell)

python
INTRO_CLIP_COUNT = 6
INTRO_SPEED = 3.0
CLIP_DURATION = 1.5
python
# in apply_blur_background()
"boxblur=40:5,eq=brightness=-0.4"

Gesamt: 6 × 1,5 = 9 Sekunden. Das Originalverhalten.

Chill

python
INTRO_CLIP_COUNT = 4
INTRO_SPEED = 2.0
CLIP_DURATION = 2.0
python
# in apply_blur_background()
"boxblur=20:3,eq=brightness=-0.2"

Gesamt: 8 Sekunden. Langsamere Schnitte, sauberer Hintergrund, leichter zu folgen.

Cinematic

python
INTRO_CLIP_COUNT = 5
INTRO_SPEED = 1.5
CLIP_DURATION = 2.5
python
# in apply_blur_background()
"boxblur=40:5,eq=brightness=-0.5"

Gesamt: 12,5 Sekunden. Langsamere Bewegung, dunklerer Hintergrund, mehr Platz für ein Titel-Overlay.

Das sind Startpunkte, keine Kalibrierungsdaten. Die Montage rendert absichtlich mit einer stillen Audiospur – leg also Musik oder ein Voiceover in deinem Editor darüber.

Die Dependencies im Detail


Paket Zweck
openai-whisper Spracherkennungs-Toolkit; oben importiert, aber nie aufgerufen. Silero VAD übernimmt die Erkennung – du kannst diese Zeile und den Import also für eine schlankere Installation streichen
torch PyTorch, um das VAD-Modell auszuführen
torchaudio Audio-Verarbeitung mit PyTorch; stellt den read_audio-Helper bereit, den Silero VAD nutzt
soundfile Audio-Decoding-Backend, das torchaudio beim Laden der WAV nutzen kann
numpy Numerische Operationen
moviepy Videobearbeitung und Compositing
Pillow Bildverarbeitung (wird von MoviePy benötigt)
packaging Utilities zum Umgang mit Versionen

Versionsbeschränkungen

Die Pins im PEP-723-Header sind tragend, keine Deko:

  • moviepy==1.0.3: MoviePy 2.x hat das Modul moviepy.editor entfernt – der Import schlägt bei jeder 2.x-Installation fehl. Siehe „Warum MoviePy auf 1.0.3 gepinnt ist“ weiter oben.
  • torchaudio<2.6: vermeidet Pairing-Probleme zwischen torch und torchaudio auf Apple Silicon. Der Abschnitt Fehlerbehebung unten behandelt langsame oder fehlgeschlagene Installationen.
  • Pillow<10.0.0: MoviePy 1.0.3 referenziert noch Image.ANTIALIAS, das Pillow 10 entfernt hat.
  • numpy<2.0.0: hält den Audio-Stack auf dem numpy-1.x-ABI, den diese torch-Builds erwarten.

Fehlerbehebung


Fehler „FFmpeg not found“

Installiere FFmpeg mit Homebrew:

bash
brew install ffmpeg

Prüfe die Installation:

bash
ffmpeg -version
Warnung „Not enough footage found“

Das passiert, wenn das Video nicht genug Sprechsegmente länger als 2 Sekunden enthält. Das Skript recycelt Segmente in dem Fall. Versuch:

  • Ein längeres Quellvideo nutzen
  • INTRO_CLIP_COUNT reduzieren
  • Die minimale Segmentdauer im Code senken
Speicherfehler bei großen Videos

Bei großen Videos versuch:

  • Kürzere Clips verarbeiten
  • Die Auflösung des Quellvideos reduzieren
  • Andere Anwendungen schließen
Der erste Lauf ist langsam

Der erste Lauf lädt das Silero-VAD-Modell und die Python-Dependencies herunter. Spätere Läufe sind schneller, weil uv und PyTorch diese Dateien cachen.

ImportError: cannot import name 'editor' from 'moviepy'

Du fährst MoviePy 2.x. Das passiert, wenn das Skript mit einem anderen Interpreter als uv run ausgeführt wird (ein per pip installiertes moviepy 2.x verdeckt das gepinnte) oder wenn der PEP-723-Header bei einer Bearbeitung seinen moviepy==1.0.3-Pin verloren hat.

Fixes:

  • Führe das Skript exakt wie dokumentiert aus: uv run intro_generator.py your_video.mp4
  • Prüfe, ob der Header noch moviepy==1.0.3 enthält
  • Wenn du bewusst auf 2.x migriert bist, aktualisiere die API: moviepy.editor ist weg (importiere Clips direkt aus moviepy), aus set_position wurde with_position, und die .fx(vfx.speedx, ...)-Syntax hat sich geändert
torch- oder torchaudio-Install schlägt fehl oder läuft langsam auf Apple Silicon

Arbeite diese Punkte der Reihe nach ab:

  • Prüfe, ob der Pin torchaudio<2.6 noch im Header steht. Ein ungepinntes torchaudio kann einen Build ziehen, der nicht zu deiner torch-Version passt.
  • Leere den Cache und versuch es erneut: uv cache clean, dann denselben uv run-Befehl nochmal ausführen. Ein halbfertiger Download ist die häufigste Ursache.
  • Prüfe, ob uv ein natives arm64-Python gewählt hat: uv python list. Ein x86_64-Interpreter unter Rosetta erzeugt langsame Installs und zufällige Wheel-Fehler.
„No speech detected“ bei Musik- oder B-Roll-Footage

Erwartetes Verhalten, kein Bug: Silero VAD hört auf Stimmen – reines Musik-Footage liefert also keine Timestamps, und das Skript fällt auf gleichmäßig verteilte Zufallssegmente alle 10 Sekunden zurück.

Wenn du bessere Picks aus ruhigem oder gemischtem Footage willst:

  • Senke den VAD-threshold in get_good_segments() von 0.5 auf etwa 0.4. Sensibler, aber mehr False Positives.
  • Senke den Mindestsegment-Filter von 2.0 Sekunden in generate_intro(), damit auch kürzere Sprech-Passagen zählen.
  • Füttere es mit Footage, in dem gesprochen wird. Genau dafür ist der Detektor gebaut.

FAQ


Braucht Silero VAD einen API-Key oder Internetzugang?

Nein. torch.hub lädt das Modell beim ersten Lauf einmal herunter; danach läuft die Voice Activity Detection mit Silero VAD komplett offline auf deiner CPU. Du brauchst weder Account noch API-Key, und es gibt keine Abrechnung pro Minute. Das Modell ist rund zwei Megabyte groß – deshalb startet es auch so schnell.

Funktioniert dieser Python-Video-Intro-Editor unter Linux oder Windows?

Das Skript ist schlichtes Python, FFmpeg und Pip-Pakete – alles plattformübergreifend. Nur der FFmpeg-Installbefehl ändert sich: apt install ffmpeg auf Debian/Ubuntu, winget install ffmpeg auf Windows. Ehrlicher Vorbehalt: Diese Anleitung ist auf einem Mac geschrieben, und ich habe sie auf anderen Systemen nicht erneut laufen lassen – behandle Linux und Windows also als „sollte funktionieren“, bis du es selbst einmal ausgeführt hast.

Warum ist das gerenderte Intro stumm?

Absicht. Das Skript entfernt die Quell-Audiospur und muxt eine stille AAC-Spur ein, damit die Montage in deinem Editor sauber unter Musik oder Voiceover gelegt werden kann, ohne gegen den Originalton anzukämpfen. Wenn du Ton in der Datei willst, leg ihn in der Postproduktion drüber oder generiere vorher ein Voiceover.

Wie lang ist das Intro?

INTRO_CLIP_COUNT × CLIP_DURATION. Die Defaults ergeben 6 × 1,5 = 9 Sekunden. Die Style-Presets oben produzieren 8 Sekunden (Chill) und 12,5 Sekunden (Cinematic). Für ein YouTube-Intro ist es eine gute Faustregel, unter 10 Sekunden zu bleiben – darüber fangen Zuschauer an zu skippen.

Fazit


Das ist die komplette Pipeline: ein Python-Video-Intro-Editor, in dem Silero VAD die Sprechmomente findet, FFmpeg die Blur- und 3D-Perspektiv-Arbeit macht, MoviePy die Schnitte kompositiert und uv jede Dependency an die Skriptdatei selbst pinnt. Zeig es auf irgendein Rohvideo mit Sprache, und du bekommst eine neunsekündige Montage, die du unter ein Musikbett legen kannst.

So kannst du es weiter ausbauen:

#Python#uv#MoviePy

Hat diese Anleitung bei dir funktioniert?

Brauchst du Hilfe bei Astro, VPS oder einer Self-hosted-App? Services ansehen →