Communitygithub.com

sacredvoid/skillkit

Traite les enregistrements vidéo/audio (Zoom, réunions, etc.) en transcrivant l'audio avec Whisper et en extrayant les images clés avec ffmpeg. Détecte automatiquement votre matériel (Apple Silicon, NVIDIA, AMD, CPU) et sélectionne le meilleur modèle de transcription. Multi-plateforme : macOS, Linux, Windows.

Qu'est-ce que skillkit ?

Cette compétence automatise le traitement des enregistrements de réunions (vidéo et audio) en transcriptions textuelles horodatées et en captures d'écran visuelles. Elle détecte automatiquement votre matériel (GPU NVIDIA/AMD/Apple Silicon ou CPU), votre système d'exploitation et votre quantité de RAM pour choisir le moteur de transcription optimal (faster-whisper pour CUDA, openai-whisper pour MPS ou CPU), la taille de modèle la plus adaptée (de tiny à large-v3) et le type de calcul (float16/float32). La compétence gère l'ensemble du pipeline : identification du fichier (motifs Zoom), installations des dépendances (ffmpeg, torch, whisper), extraction d'une image par minute via ffmpeg, transcription en arrière-plan, et synthèse finale (participants, décisions, actions). Elle est conçue pour fonctionner sur macOS, Linux et Windows, avec des instructions d'installation spécifiques à chaque plateforme.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Processeur Vidéo/Audio

Traite les enregistrements vidéo et audio en transcriptions textuelles et en captures d'images clés pour analyse. Détecte automatiquement votre matériel et sélectionne le modèle de transcription, le périphérique et les paramètres optimaux.

Phase 0 : Détection de l'Environnement de Calcul

Exécutez ceci au début de chaque invocation. Cela détermine tout ce qui suit.

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

# Détection GPU
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']  # mémoire unifiée
        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 utilise l'API CUDA
        info['dtype'] = 'float16'
except ImportError:
    pass

# Détection ffmpeg
info['ffmpeg'] = shutil.which('ffmpeg') is not None
info['ffprobe'] = shutil.which('ffprobe') is not None

print(json.dumps(info))
"

Analysez la sortie JSON et stockez-la en interne sous le nom COMPUTE. Présentez les résultats à l'utilisateur :

Matériel détecté :

  • OS : {os} ({arch})
  • RAM : {ram_gb} Go
  • GPU : {gpu} ({vram_gb} Go VRAM)
  • Périphérique de calcul : {device}
  • ffmpeg : {installé/manquant}

Sélection du Moteur Whisper

En fonction du matériel, choisissez le moteur de transcription :

ConditionMoteurRaison
GPU CUDA disponiblefaster-whisperCTranslate2 accéléré par GPU, 4x plus rapide que Whisper standard
MPS (Apple Silicon)openai-whisperWhisper standard, utilise l'accélération MPS quand disponible
CPU uniquementopenai-whisperWhisper standard sur CPU, solution de repli fiable

Matrice de Sélection du Modèle

En fonction du matériel et de la durée d'enregistrement, recommandez un modèle :

ConditionModèle RecommandéVitesse (enreg. 1h)Précision
CUDA >= 8 Go VRAMlarge-v3~5 minMeilleure
CUDA 4-7 Go VRAMmedium~8 minÉlevée
MPS (Apple Silicon, 16+ Go)medium~15 minÉlevée
MPS (Apple Silicon, 8 Go)small~10 minBonne
CPU + RAM >= 16 Gosmall~30 minBonne
CPU + RAM < 16 Gobase~15 minAdéquate

Présentez la recommandation et laissez l'utilisateur choisir :

AskUserQuestion: "Quel modèle de transcription dois-je utiliser ?"
Options:
- [Modèle recommandé] (Recommandé) - [raison basée sur leur matériel]
- large-v3 - Meilleure précision, nécessite 8+ Go VRAM ou beaucoup de RAM
- medium - Haute précision, vitesse équilibrée
- small - Bonne précision, traitement plus rapide
- base - Adéquat pour la plupart des réunions, le plus rapide

Stockez le modèle choisi sous le nom WHISPER_MODEL et le moteur sous le nom WHISPER_ENGINE.

Phase 1 : Identifier l'Enregistrement

Trouvez le fichier. Les enregistrements Zoom suivent généralement le motif :

  • GMT{date}-{time}_Recording_{résolution}.mp4 (vidéo)
  • GMT{date}-{time}_Recording.m4a (audio uniquement)
  • GMT{date}-{time}_RecordingnewChat.txt (journal de chat)

Vérifiez la présence des trois artefacts. Lisez d'abord le fichier de chat (il est petit et fournit un contexte immédiat).

Phase 2 : Installer les Dépendances

Vérifiez et installez ce qui est nécessaire en fonction de la plateforme.

ffmpeg

# Vérifiez si ffmpeg est disponible
ffmpeg -version 2>&1 | head -1
ffprobe -version 2>&1 | head -1

Si ffmpeg est manquant, installez-le selon la plateforme :

PlateformeCommande d'installation
macOS (Homebrew)brew install ffmpeg
macOS (sans Homebrew)Guidez l'utilisateur pour installer Homebrew d'abord, puis ffmpeg
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

Si torch est manquant, installez-le selon la plateforme :

PlateformeCommande d'installation
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

Installez ensuite le moteur de transcription :

# Pour les systèmes CUDA (faster-whisper avec accélération CTranslate2)
pip3 install faster-whisper

# Pour les systèmes MPS / CPU (Whisper OpenAI standard)
pip3 install openai-whisper

Phase 3 : Obtenir la Durée

Utilisez ffprobe (multi-plateforme) pour obtenir la durée du fichier :

ffprobe -v quiet -show_entries format=duration -of csv=p=0 "/chemin/vers/fichier"

Cela renvoie la durée en secondes. Convertissez-la en un format lisible et affichez-la à l'utilisateur. Utilisez-la pour estimer le temps de transcription basé sur le modèle sélectionné et le matériel.

Présentez le plan :

Plan de traitement :

  • Fichier : {nomfichier} ({durée})
  • Moteur : {WHISPER_ENGINE} avec le modèle {WHISPER_MODEL} sur {device}
  • Temps de transcription estimé : {estimation}
  • Extraction d'images : 1 par minute ({nombre_images} images)

Souhaitez-vous ajuster quelque chose avant de commencer ?

Estimations de Temps

Périphériquebasesmallmediumlarge-v3
CUDA (RTX 3060+)~1 min/h~2 min/h~4 min/h~5 min/h
CUDA (faster-whisper)~30 s/h~1 min/h~2 min/h~3 min/h
MPS (M1/M2/M3/M4)~3 min/h~6 min/h~15 min/h~25 min/h
CPU (16 Go+ RAM)~8 min/h~15 min/h~30 min/h~60 min/h

Phase 4 : Extraire les Images Clés

Extrayez une image par minute pour le contexte visuel. Utilisez un répertoire temporaire multi-plateforme :

# Créer un répertoire temporaire (multi-plateforme)
python3 -c "import tempfile, os; d = os.path.join(tempfile.gettempdir(), 'av-frames'); os.makedirs(d, exist_ok=True); print(d)"

Extrayez ensuite les images :

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

Utilisez l'outil de lecture sur chaque image pour les visualiser. Les images montrent :

  • Les partages d'écran (code, diapositives, interfaces utilisateur)
  • Les noms des participants (en bas à gauche de chaque vignette vidéo)
  • Les horodatages (si visibles dans le partage d'écran)

Phase 5 : Transcrire l'Audio

Exécutez le moteur de transcription. Choisissez le code correct en fonction de WHISPER_ENGINE :

faster-whisper (systèmes CUDA)

from faster_whisper import WhisperModel
import json

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

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

# Sauvegarder la transcription horodatée
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"{len(results)} segments transcrits")

openai-whisper (systèmes MPS / CPU)

import whisper, json

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

# Sauvegarder la transcription horodatée
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"{len(result['segments'])} segments transcrits")

Exécutez la transcription en arrière-plan car elle prend un temps significatif. Pendant qu'elle s'exécute, examinez visuellement les images extraites.

Phase 6 : Synthétiser

Combinez les images clés + la transcription + le chat pour construire une compréhension :

  • Qui : Identifiez les participants à partir des étiquettes de noms vidéo et de l'attribution vocale
  • Quoi : Ce qui a été montré à l'écran (démos, diapositives, code)
  • Dit : Citations clés, décisions, exigences, retours
  • Actions : Engagements explicites et suivis

Référence des Modèles

ModèleParamètresVitessePrécisionIdéal Pour
tiny39MTrès rapideFaibleAnalyse rapide, vérifier si l'audio est utilisable
base74MRapideAdéquatePar défaut pour les réunions courtes/claires
small244MModéréBonneRéunions générales avec accents
medium769MLentÉlevéeRéunions importantes, face au client
large-v31,5BTrès lentMeilleureEnregistrements critiques, mauvaise qualité audio

Conseils

  • Exécutez toujours la transcription en arrière-plan pendant que vous examinez les images visuellement
  • Lisez les images par lots de 8 (limite de parallélisme de l'outil)
  • Whisper standard utilise FP32 sur CPU et MPS ; faster-whisper utilise CTranslate2 avec FP16 sur CUDA
  • Pour les enregistrements très longs (>1 heure), envisagez de diviser l'audio d'abord
  • Les fichiers de chat de Zoom contiennent des horodatages et des liens partagés, lisez-les d'abord pour un contexte rapide
  • Sous Windows, utilisez des barres obliques ou des chaînes brutes pour les chemins de fichiers en Python

Gestion des Erreurs

ErreurCauseSolution
ffmpeg: command not foundffmpeg non installéInstallez selon le tableau de plateforme ci-dessus
No module named 'whisper'Whisper non installépip3 install openai-whisper
No module named 'faster_whisper'faster-whisper non installépip3 install faster-whisper
CUDA out of memoryModèle trop grand pour la VRAMPassez à un modèle plus petit
RuntimeError: MPS backendProblème MPS sur macOS ancienMettez à jour macOS, ou revenez au CPU avec PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0
torch not foundDépendances Python manquantesInstallez torch selon le tableau de plateforme ci-dessus
Transcription incohérenteMauvaise langue ou audio de mauvaise qualitéEssayez de spécifier language="en" ou utilisez un modèle plus grand
Transcription très lenteExécution d'un grand modèle sur CPUPassez au modèle base ou small

Skills associés