KI-Videoproduktion mit Google Veo3: Text-Prompt rein, fertiges Video raus

💰 Warum sich KI-Videoproduktion rechnet

Ein professionelles 2-Minuten-Video kostet in der Produktion 1.500–5.000 € und dauert 2–4 Wochen. Mit Veo3 und einer automatisierten Pipeline entsteht das gleiche Video in 10–30 Minuten für unter 50 € Cloud-Kosten. Der Unterschied zwischen „wir machen vielleicht nächstes Quartal ein Video" und „wir machen heute eins".

⚙️ So funktioniert's

Vom JSON-Script zum fertigen Video — vollautomatisch.

💻 Technische Umsetzung

Die Pipeline ist ein Python-Script, das Google Vertex AI (Veo3) für die KI-Videogenerierung und FFmpeg für Frame-Extraktion und Video-Merging nutzt. Die Steuerung erfolgt über ein JSON-Script.

🏗️ Architektur

🎬 Der Veo3VideoPipeline Core

class Veo3VideoPipeline:
    def __init__(self, project_id, location="us-central1", output_dir="output"):
        self.project_id = project_id
        self.location = location
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(exist_ok=True)
        
        if VERTEX_AI_AVAILABLE:
            aiplatform.init(project=project_id, location=location)

    def generate_video_text_to_video(self, prompt, scene_number, duration=8):
        model = VideoGenerationModel.from_pretrained("veo-3")
        response = model.generate_video(
            prompt=prompt,
            duration=duration,
            aspect_ratio="16:9"
        )
        output_path = self.output_dir / f"scene_{scene_number:03d}.mp4"
        with open(output_path, "wb") as f:
            f.write(response.video_data)
        return str(output_path)

    def generate_video_image_to_video(self, prompt, reference_image, 
                                       scene_number, duration=8):
        model = VideoGenerationModel.from_pretrained("veo-3")
        with open(reference_image, "rb") as f:
            image_data = f.read()
        response = model.generate_video(
            prompt=prompt,
            reference_image=image_data,
            duration=duration,
            aspect_ratio="16:9"
        )
        output_path = self.output_dir / f"scene_{scene_number:03d}.mp4"
        with open(output_path, "wb") as f:
            f.write(response.video_data)
        return str(output_path)

🖼️ Frame-Extraktion mit FFmpeg

def extract_last_frame(self, video_path, output_image_path):
    cmd = [
        "ffmpeg",
        "-sseof", "-3",       # 3 Sekunden vor Ende starten
        "-i", video_path,
        "-vframes", "1",      # Nur ein Frame
        "-q:v", "2",          # Hohe Qualität
        "-update", "1",       # Single image output
        "-y",                 # Überschreiben
        output_image_path
    ]
    subprocess.run(cmd, capture_output=True, text=True, check=True)
    return Path(output_image_path).exists()

🔀 Workflow: Script → Szenen → Mergen

def process_script(self, script):
    scenes = script.get("scenes", [])
    generated_videos = []
    previous_frame = None

    for idx, scene in enumerate(scenes, start=1):
        prompt = scene.get("prompt", "")
        duration = scene.get("duration", 8)

        if idx == 1:
            # Erste Szene: Text-to-Video
            video_path = self.generate_video_text_to_video(
                prompt=prompt, scene_number=idx, duration=duration
            )
        else:
            # Weitere Szenen: Image-to-Video mit vorherigem Frame
            if previous_frame and Path(previous_frame).exists():
                video_path = self.generate_video_image_to_video(
                    prompt=prompt, reference_image=previous_frame,
                    scene_number=idx, duration=duration
                )
            else:
                video_path = self.generate_video_text_to_video(
                    prompt=prompt, scene_number=idx, duration=duration
                )

        if video_path:
            generated_videos.append(video_path)
            # Letzten Frame für nächste Szene extrahieren
            frame_path = self.output_dir / f"scene_{idx:03d}_last_frame.jpg"
            if self.extract_last_frame(video_path, str(frame_path)):
                previous_frame = str(frame_path)

    return generated_videos

def merge_videos(self, video_paths, output_name="final_video.mp4"):
    concat_file = self.output_dir / "concat_list.txt"
    with open(concat_file, 'w') as f:
        for video_path in video_paths:
            f.write(f"file '{Path(video_path).absolute()}'\n")
    
    subprocess.run([
        "ffmpeg", "-f", "concat", "-safe", "0",
        "-i", str(concat_file), "-c", "copy", "-y",
        str(self.output_dir / output_name)
    ], check=True)
    concat_file.unlink()

📜 Beispiel: Video-Script JSON

{
  "title": "KI im Mittelstand",
  "merge_videos": true,
  "scenes": [
    {
      "prompt": "Eine moderne Büroumgebung mit Mitarbeitern, die an Computern arbeiten. 
                 Eine KI-Assistentin erscheint als Hologramm und hilft bei der Arbeit.",
      "duration": 8
    },
    {
      "prompt": "Nahaufnahme eines Bildschirms, auf dem automatisch E-Mails sortiert werden. 
                 Die KI kategorisiert blitzschnell hunderte Nachrichten.",
      "duration": 8
    },
    {
      "prompt": "Glückliche Mitarbeiter beim Feierabend. Text erscheint: 
                 '90% weniger Routinearbeit — dank KI'. Firmenlogo blendet ein.",
      "duration": 8
    }
  ]
}

🚀 Gebaut mit Vibecoding — in 5–7 Tagen statt 8–13 Wochen

🗣️ Der System-Prompt hinter diesem Projekt

Dieser Prompt erzeugte die komplette Veo3-Pipeline mit Text-to-Video, Image-to-Video und FFmpeg-Integration:

Du bist ein Python-Experte für Google Cloud Vertex AI und Videoproduktion.

Aufgabe: Erstelle eine automatisierte Video-Pipeline mit Google Veo3, 
die aus einem JSON-Videoscript ein fertiges Multi-Szene-Video generiert.

Technische Anforderungen:
- Google Vertex AI SDK mit VideoGenerationModel (Veo3)
- Zwei Generierungs-Modi:
  * Text-to-Video für die erste Szene
  * Image-to-Video für Folgeszenen (mit letztem Frame der Vorszene)
- FFmpeg-Integration:
  * Frame-Extraktion: Letzten Frame via -sseof -3 extrahieren
  * Video-Merging: FFmpeg concat demuxer für verlustfreies Zusammenführen
- JSON-basierte Script-Steuerung (Titel, Szenen-Array, Prompts, Dauer)
- Robustes Error-Handling mit Fallback auf Text-to-Video
- CLI-Argumente: script.json [project-id]

VideoScript JSON-Format:
{
  "title": "Video Titel",
  "merge_videos": true,
  "scenes": [
    {"prompt": "Beschreibung Szene 1", "duration": 8},
    {"prompt": "Beschreibung Szene 2", "duration": 8}
  ]
}

Output: Ausführbare .py-Datei mit vollständiger Pipeline, inklusive 
setup_veo3.py für Authentifizierung und Beispiel-Script.

🎯 Strategische Erkenntnisse aus diesem Projekt

KI-Videogenerierung ist 2026 auf einem Level, das vor zwei Jahren Science-Fiction war. Die strategische Frage ist nicht mehr „ob", sondern „wie schnell".