Communitygithub.com

Video/Audio Processor

Verarbeitet Video-/Audioaufnahmen (Zoom, Meetings usw.), indem es Audio mit Whisper transkribiert und visuelle Frames mit ffmpeg extrahiert. Erkennt automatisch Ihre Hardware (Apple Silicon, NVIDIA, AMD, CPU) und wählt das beste Transkriptionsmodell aus. Plattformübergreifend: macOS, Linux, Windows.

Was ist Audio Processor?

Diese Fähigkeit wandelt Video- und Audioaufnahmen (z. B. Zoom-Meetings) in Texttranskripte und visuelle Frame-Aufnahmen um, die dann analysiert werden können. Dabei erkennt die Fähigkeit automatisch die verfügbare Hardware (Apple Silicon, NVIDIA CUDA, AMD ROCm oder CPU) und wählt das optimale Transkriptionsmodell sowie die passenden Compute-Einstellungen aus. Sie unterstützt macOS, Linux und Windows und installiert bei Bedarf ffmpeg, torch und das passende Whisper-Modell (faster-whisper für CUDA, openai-whisper für MPS und CPU). Der Workflow ist in sechs Phasen unterteilt: Erkennung der Compute-Umgebung, Identifikation der Aufnahme, Installation von Abhängigkeiten, Ermittlung der Dauer, Extraktion von Videoframes (ein Frame pro Minute) und Transkription des Audios. Das Ergebnis ist ein zusammengefasster Bericht, der Teilnehmer, Bildschirminhalte, wichtige Aussagen und Aktionspunkte enthält.

Funktioniert mit~Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/sacredvoid/skillkit/tree/HEAD/skills/video-audio-processor

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Video/Audio Prozessor

Verarbeitet Video- und Audioaufnahmen in Texttranskripte und visuelle Frame-Aufnahmen für die Analyse. Erkennt automatisch Ihre Hardware und wählt das optimale Transkriptionsmodell, Gerät und Einstellungen aus.

Phase 0: Compute-Umgebung erkennen

Führen Sie dies zu Beginn jeder Ausführung aus. Es bestimmt alles nachfolgende.

python3 -c "
import platform, shutil, subprocess, json

info = {'os': platform.system(), 'arch': platform.machine(), 'ram_gb': 0, 'gpu': 'none', 'vram_gb': 0, 'device': 'cpu', 'dtype': 'float32'}

# RAM
try:
    if platform.system() == 'Darwin':
        import os; info['ram_gb'] = round(os.sysconf('SC_PAGE_SIZE') * os.sysconf('SC_PHYS_PAGES') / (1024**3))
    elif platform.system() == 'Linux':
        with open('/proc/meminfo') as f:
            for line in f:
                if line.startswith('MemTotal'):
                    info['ram_gb'] = round(int(line.split()[1]) / (1024**2))
                    break
    else:
        import ctypes
        mem = ctypes.c_ulonglong(0)
        ctypes.windll.kernel32.GetPhysicallyInstalledMemory(ctypes.byref(mem))
        info['ram_gb'] = round(mem.value / (1024**2))
except: pass

# GPU-Erkennung
try:
    import torch
    if torch.cuda.is_available():
        info['gpu'] = torch.cuda.get_device_name(0)
        info['vram_gb'] = round(torch.cuda.get_device_properties(0).total_mem / (1024**3))
        info['device'] = 'cuda'
        info['dtype'] = 'float16'
    elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
        info['gpu'] = 'Apple Silicon (MPS)'
        info['vram_gb'] = info['ram_gb']  # unified memory
        info['device'] = 'mps'
        info['dtype'] = 'float16'
    elif hasattr(torch, 'hip') or 'AMD' in str(getattr(torch, '_C', '')):
        info['gpu'] = 'AMD (ROCm)'
        info['device'] = 'cuda'  # ROCm verwendet CUDA API
        info['dtype'] = 'float16'
except ImportError:
    pass

# ffmpeg-Erkennung
info['ffmpeg'] = shutil.which('ffmpeg') is not None
info['ffprobe'] = shutil.which('ffprobe') is not None

print(json.dumps(info))
"

Parsen Sie die JSON-Ausgabe und speichern Sie sie intern als COMPUTE. Präsentieren Sie die Ergebnisse dem Benutzer:

Erkannte Hardware:

  • OS: {os} ({arch})
  • RAM: {ram_gb} GB
  • GPU: {gpu} ({vram_gb} GB VRAM)
  • Compute-Gerät: {device}
  • ffmpeg: {installiert/fehlt}

Whisper-Engine Auswahl

Basierend auf der Hardware wählen Sie die Transkriptions-Engine:

BedingungEngineGrund
CUDA GPU verfügbarfaster-whisperGPU-beschleunigtes CTranslate2, 4x schneller als Standard Whisper
MPS (Apple Silicon)openai-whisperStandard Whisper, nutzt MPS-Beschleunigung wenn verfügbar
Nur CPUopenai-whisperStandard Whisper auf CPU, zuverlässiger Fallback

Modellauswahlmatrix

Basierend auf Hardware und Aufnahmelänge empfehlen Sie ein Modell:

BedingungEmpfohlenes ModellGeschwindigkeit (1h Aufnahme)Genauigkeit
CUDA >= 8 GB VRAMlarge-v3~5 minBeste
CUDA 4-7 GB VRAMmedium~8 minHoch
MPS (Apple Silicon, 16+ GB)medium~15 minHoch
MPS (Apple Silicon, 8 GB)small~10 minGut
CPU + RAM >= 16 GBsmall~30 minGut
CPU + RAM < 16 GBbase~15 minAusreichend

Präsentieren Sie die Empfehlung und lassen Sie den Benutzer wählen:

AskUserQuestion: "Welches Transkriptionsmodell soll ich verwenden?"
Optionen:
- [Empfohlenes Modell] (Empfohlen) - [Grund basierend auf ihrer Hardware]
- large-v3 - Beste Genauigkeit, benötigt 8+ GB VRAM oder viel RAM
- medium - Hohe Genauigkeit, ausgewogene Geschwindigkeit
- small - Gute Genauigkeit, schnellere Verarbeitung
- base - Ausreichend für die meisten Meetings, am schnellsten

Speichern Sie das gewählte Modell als WHISPER_MODEL und die Engine als WHISPER_ENGINE.

Phase 1: Aufnahme identifizieren

Finden Sie die Datei. Zoom-Aufnahmen folgen typischerweise dem Muster:

  • GMT{datum}-{uhrzeit}_Recording_{auflösung}.mp4 (Video)
  • GMT{datum}-{uhrzeit}_Recording.m4a (nur Audio)
  • GMT{datum}-{uhrzeit}_RecordingnewChat.txt (Chat-Protokoll)

Überprüfen Sie auf alle drei Artefakte. Lesen Sie zuerst die Chat-Datei (sie ist klein und gibt sofortigen Kontext).

Phase 2: Abhängigkeiten installieren

Überprüfen und installieren Sie, was basierend auf der Plattform benötigt wird.

ffmpeg

# Überprüfen, ob ffmpeg verfügbar ist
ffmpeg -version 2>&1 | head -1
ffprobe -version 2>&1 | head -1

Wenn ffmpeg fehlt, installieren Sie basierend auf der Plattform:

PlattformInstallationsbefehl
macOS (Homebrew)brew install ffmpeg
macOS (kein Homebrew)Benutzer anleiten, zuerst Homebrew und dann ffmpeg zu installieren
Ubuntu/Debiansudo apt update && sudo apt install -y ffmpeg
Fedora/RHELsudo dnf install -y ffmpeg
Arch Linuxsudo pacman -S ffmpeg
Windows (winget)winget install Gyan.FFmpeg
Windows (choco)choco install ffmpeg
Windows (scoop)scoop install ffmpeg

Python + Whisper

python3 -c "import torch; print(torch.__version__)" 2>&1

Wenn torch fehlt, installieren Sie basierend auf der Plattform:

PlattformInstallationsbefehl
macOS (MPS)pip3 install torch torchvision torchaudio
Linux (CUDA)pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
Linux (ROCm)pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.0
Linux/Windows (CPU)pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
Windows (CUDA)pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

Installieren Sie dann die Transkriptions-Engine:

# Für CUDA-Systeme (faster-whisper mit CTranslate2-Beschleunigung)
pip3 install faster-whisper

# Für MPS / CPU-Systeme (Standard OpenAI Whisper)
pip3 install openai-whisper

Phase 3: Dauer ermitteln

Verwenden Sie ffprobe (plattformübergreifend), um die Dateidauer zu ermitteln:

ffprobe -v quiet -show_entries format=duration -of csv=p=0 "/path/to/file"

Dies gibt die Dauer in Sekunden zurück. Konvertieren Sie in ein lesbares Format und zeigen Sie es dem Benutzer an. Verwenden Sie dies, um die Transkriptionszeit basierend auf dem ausgewählten Modell und der Hardware zu schätzen.

Präsentieren Sie den Plan:

Verarbeitungsplan:

  • Datei: {dateiname} ({dauer})
  • Engine: {WHISPER_ENGINE} mit {WHISPER_MODEL} Modell auf {device}
  • Geschätzte Transkriptionszeit: {schätzung}
  • Frame-Extraktion: 1 pro Minute ({frame_count} Frames)

Möchten Sie etwas anpassen, bevor ich beginne?

Zeitschätzungen

Gerätbasesmallmediumlarge-v3
CUDA (RTX 3060+)~1 min/Std~2 min/Std~4 min/Std~5 min/Std
CUDA (faster-whisper)~30s/Std~1 min/Std~2 min/Std~3 min/Std
MPS (M1/M2/M3/M4)~3 min/Std~6 min/Std~15 min/Std~25 min/Std
CPU (16GB+ RAM)~8 min/Std~15 min/Std~30 min/Std~60 min/Std

Phase 4: Visuelle Frames extrahieren

Extrahieren Sie einen Frame pro Minute für visuellen Kontext. Verwenden Sie ein plattformübergreifendes temporäres Verzeichnis:

# Temporäres Verzeichnis erstellen (plattformübergreifend)
python3 -c "import tempfile, os; d = os.path.join(tempfile.gettempdir(), 'av-frames'); os.makedirs(d, exist_ok=True); print(d)"

Dann Frames extrahieren:

ffmpeg -i "/path/to/video.mp4" \
  -vf "fps=1/60,scale=1280:-1" -q:v 3 {TEMP_DIR}/frame_%03d.jpg

Verwenden Sie das Read-Tool, um jeden Frame zu betrachten. Frames zeigen:

  • Bildschirmfreigaben (Code, Folien, UIs)
  • Teilnehmernamen (unten links in jedem Videofenster)
  • Zeitstempel (falls in der Bildschirmfreigabe sichtbar)

Phase 5: Audio transkribieren

Führen Sie die Transkriptions-Engine aus. Wählen Sie den richtigen Code basierend auf WHISPER_ENGINE:

faster-whisper (CUDA-Systeme)

from faster_whisper import WhisperModel
import json

model = WhisperModel("{WHISPER_MODEL}", device="cuda", compute_type="float16")
segments, info = model.transcribe("/path/to/audio", beam_size=5, language="en")

results = []
for segment in segments:
    results.append({
        "start": segment.start,
        "end": segment.end,
        "text": segment.text.strip()
    })

# Zeitgestempeltes Transkript speichern
with open("{TEMP_DIR}/transcript.json", "w") as f:
    json.dump({"language": info.language, "segments": results}, f, indent=2)

with open("{TEMP_DIR}/transcript.txt", "w") as f:
    for seg in results:
        start = int(seg["start"])
        mins, secs = divmod(start, 60)
        f.write(f"[{mins:02d}:{secs:02d}] {seg['text']}\n")

print(f"Transkribiert {len(results)} Segmente")

openai-whisper (MPS / CPU-Systeme)

import whisper, json

model = whisper.load_model("{WHISPER_MODEL}")
result = model.transcribe("/path/to/audio", verbose=False)

# Zeitgestempeltes Transkript speichern
with open("{TEMP_DIR}/transcript.json", "w") as f:
    json.dump(result, f, indent=2)

with open("{TEMP_DIR}/transcript.txt", "w") as f:
    for seg in result["segments"]:
        start = int(seg["start"])
        mins, secs = divmod(start, 60)
        f.write(f"[{mins:02d}:{secs:02d}] {seg['text'].strip()}\n")

print(f"Transkribiert {len(result['segments'])} Segmente")

Führen Sie die Transkription im Hintergrund aus, da sie viel Zeit in Anspruch nimmt. Während sie läuft, überprüfen Sie die extrahierten Frames visuell.

Phase 6: Synthese

Kombinieren Sie visuelle Frames + Transkript + Chat, um ein Verständnis aufzubauen:

  • Wer: Teilnehmer anhand von Videobezeichnungen und Stimmzuweisung identifizieren
  • Was: Was auf dem Bildschirm gezeigt wurde (Demos, Folien, Code)
  • Gesagt: Wichtige Zitate, Entscheidungen, Anforderungen, Feedback
  • Aktionspunkte: Explizite Zusagen und Folgemaßnahmen

Modellreferenz

ModellParameterGeschwindigkeitGenauigkeitAm besten geeignet für
tiny39MSehr schnellNiedrigSchnelle Überprüfung, ob Audio verwendbar ist
base74MSchnellAusreichendStandard für kurze/klare Meetings
small244MMäßigGutAllgemeine Meetings mit Akzenten
medium769MLangsamHochWichtige Meetings, kundenorientiert
large-v31.5BSehr langsamAm bestenKritische Aufnahmen, schlechte Audioqualität

Tipps

  • Führen Sie die Transkription immer im Hintergrund aus, während Sie Frames visuell überprüfen
  • Lesen Sie Frames in Batches von 8 (Werkzeug-Parallelitätsgrenze)
  • Standard Whisper verwendet FP32 auf CPU und MPS; faster-whisper verwendet CTranslate2 mit FP16 auf CUDA
  • Bei sehr langen Aufnahmen (>1 Stunde) erwägen Sie, das Audio zuerst zu splitten
  • Chat-Dateien von Zoom enthalten Zeitstempel und geteilte Links; lesen Sie sie zuerst für schnellen Kontext
  • Unter Windows verwenden Sie Schrägstriche oder Raw-Strings für Dateipfade in Python

Fehlerbehandlung

FehlerUrsacheLösung
ffmpeg: command not foundffmpeg nicht installiertInstallieren gemäß Plattformtabelle oben
No module named 'whisper'Whisper nicht installiertpip3 install openai-whisper
No module named 'faster_whisper'faster-whisper nicht installiertpip3 install faster-whisper
CUDA out of memoryModell zu groß für VRAMAuf kleineres Modell umsteigen
RuntimeError: MPS backendMPS-Problem auf älterem macOSmacOS aktualisieren, oder auf CPU zurückfallen mit PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0
torch not foundPython-Abhängigkeiten fehlentorch gemäß Plattformtabelle oben installieren
Verworrenes TranskriptFalsche Sprache oder schlechtes AudioVersuchen, language="en" anzugeben oder ein größeres Modell verwenden
Sehr langsame TranskriptionGroßes Modell auf CPU ausgeführtAuf base oder small Modell umsteigen

Verwandte Skills