---
title: "Python-Video-Intro-Editor: Silero VAD + MoviePy auf dem Mac"
description: "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."
date: 2025-12-09
categories: ["ai"]
tags: ["python","uv","moviepy"]
---

*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](/install-upgrade-python-mac/).

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](/uv-get-start/) 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.mp4
    
- 
    
    FFmpeg · Audio als 16-kHz-Mono-WAV
    
- 
    
    Silero VAD · Sprach-Timestamps finden
    
- 
    
    Sprachsegmente über 2 s · 6 sampeln
    
- 
    
- 
    
- 
    
- 
    pro Clip × 6
    
    FFmpeg
    geblurrter Hintergrund
    
    FFmpeg
    3D-Perspektiv-Warp
    
- 
    
- 
    
- 
    
- 
    
    MoviePy · 3x-Tempo, Slides, Crossfades
    
- 
    
    FFmpeg · stille Audiospur muxen
    
- 
    
    intro_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](/uv-run-scripts-guide/) 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](/docker-run-python/).

### Erwartete Ausgabe

```
🧠 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:

- Das Intro rendert absichtlich stumm – leg also Musik in deinem Editor darüber, [generiere ein Voiceover mit einem Python-Text-to-Speech-Skript](/uv-text-to-speech-script/) oder nutze einen gehosteten Dienst mit Voice Cloning wie [Fish Audio](https://go.bitdoze.com/fish-audio) für eine konsistente Sprecherstimme, ohne lokal Modelle laufen zu lassen.
- Die CLI nimmt genau ein Argument – ein guter Kandidat, um [das Skript mit NiceGUI in eine Desktop-UI zu packen](/nicegui-get-started/): ein Datei-Picker, ein Render-Button, ein Fortschrittsbalken.
- Die Montage kann nur so gut aussehen wie ihr Input. [Screen.Studio](https://go.bitdoze.com/screen-studio) automatisiert Zooms und Schnitte für macOS-Screenrecordings; der ausführliche [Screen.Studio-Test](/de/screen-studio-review/) erzählt die lange Version.
- Lieber einen KI-Coding-Agenten Animationen, Captions und Soundeffekte in einer Desktop-Timeline generieren lassen, statt MoviePy-Skripte zu pflegen? Lies mein [HyperFrames-Studio-Review](/de/hyperframes-studio-review/).
- Kein Footage zum Schneiden? [KI-Video-Generierungs-APIs wie Veo und Kling](/kie-ai-video-generation/) erzeugen B-Roll aus einem Prompt, und [Kie.ai](https://go.bitdoze.com/kie-ai) steckt diese Modelle hinter eine einzige API.
- Wenn das Video fertig ist, [hoste Intro und Videos mit Bunny Stream](/bunny-stream-guide/), statt dich mit Plattform-Embeds herumzuschlagen, und kombiniere das Intro mit Thumbnail-Art aus dem Guide, wie du [KI-Bilder lokal auf dem Mac generierst](/de/ki-bilder-mac/).