Communitygithub.com

sacredvoid/skillkit

Processa gravações de vídeo/áudio (Zoom, reuniões, etc.) transcrevendo o áudio com Whisper e extraindo quadros visuais com ffmpeg. Detecta automaticamente seu hardware (Apple Silicon, NVIDIA, AMD, CPU) e escolhe o melhor modelo de transcrição. Multiplataforma: macOS, Linux, Windows.

O que é skillkit?

A habilidade `sacredvoid/skillkit` automatiza o processamento de gravações de vídeo e áudio, convertendo-as em transcrições de texto e capturas de quadros visuais para análise. Ele detecta automaticamente o hardware disponível (Apple Silicon, NVIDIA CUDA, AMD ROCm ou CPU) e seleciona o motor de transcrição e o modelo mais adequados, seja `faster-whisper` (para GPUs CUDA) ou `openai-whisper` (para MPS/CPU). A ferramenta suporta macOS, Linux e Windows, e lida com a instalação de dependências como ffmpeg e PyTorch com base no ambiente detectado. O fluxo de trabalho inclui a extração de um quadro por minuto para contexto visual, transcrição em segundo plano e uma síntese final que combina quadros, transcrição e chat (se disponível) para identificar participantes, decisões e itens de ação.

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

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Processador de Vídeo/Áudio

Processa gravações de vídeo e áudio em transcrições de texto e capturas de quadros visuais para análise. Detecta automaticamente seu hardware e seleciona o modelo de transcrição, dispositivo e configurações ideais.

Fase 0: Detectar Ambiente de Computação

Execute isso no início de cada invocação. Determina tudo que vem a seguir.

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

# Detecção de 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']  # memória unificada
        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 usa API cuda
        info['dtype'] = 'float16'
except ImportError:
    pass

# Detecção de ffmpeg
info['ffmpeg'] = shutil.which('ffmpeg') is not None
info['ffprobe'] = shutil.which('ffprobe') is not None

print(json.dumps(info))
"

Analise a saída JSON e armazene internamente como COMPUTE. Apresente os resultados ao usuário:

Hardware detectado:

  • SO: {os} ({arch})
  • RAM: {ram_gb} GB
  • GPU: {gpu} ({vram_gb} GB VRAM)
  • Dispositivo de computação: {device}
  • ffmpeg: {instalado/ausente}

Seleção do Motor Whisper

Com base no hardware, escolha o motor de transcrição:

CondiçãoMotorMotivo
GPU CUDA disponívelfaster-whisperAcelerado por GPU CTranslate2, 4x mais rápido que Whisper padrão
MPS (Apple Silicon)openai-whisperWhisper padrão, usa aceleração MPS quando disponível
Apenas CPUopenai-whisperWhisper padrão na CPU, fallback confiável

Matriz de Seleção de Modelo

Com base no hardware e duração da gravação, recomende um modelo:

CondiçãoModelo RecomendadoVelocidade (1h de gravação)Precisão
CUDA >= 8 GB VRAMlarge-v3~5 minMelhor
CUDA 4-7 GB VRAMmedium~8 minAlta
MPS (Apple Silicon, 16+ GB)medium~15 minAlta
MPS (Apple Silicon, 8 GB)small~10 minBoa
CPU + RAM >= 16 GBsmall~30 minBoa
CPU + RAM < 16 GBbase~15 minAdequada

Apresente a recomendação e deixe o usuário escolher:

PerguntaAoUsuario: "Qual modelo de transcrição devo usar?"
Opções:
- [Modelo recomendado] (Recomendado) - [motivo baseado no hardware]
- large-v3 - Melhor precisão, precisa de 8+ GB VRAM ou muita RAM
- medium - Alta precisão, velocidade equilibrada
- small - Boa precisão, processamento mais rápido
- base - Adequado para a maioria das reuniões, mais rápido

Armazene o modelo escolhido como WHISPER_MODEL e o motor como WHISPER_ENGINE.

Fase 1: Identificar a Gravação

Encontre o arquivo. Gravações do Zoom geralmente seguem o padrão:

  • GMT{data}-{hora}_Recording_{resolução}.mp4 (vídeo)
  • GMT{data}-{hora}_Recording.m4a (apenas áudio)
  • GMT{data}-{hora}_RecordingnewChat.txt (log de chat)

Verifique os três artefatos. Leia o arquivo de chat primeiro (é pequeno e fornece contexto imediato).

Fase 2: Instalar Dependências

Verifique e instale o que for necessário com base na plataforma.

ffmpeg

# Verificar se ffmpeg está disponível
ffmpeg -version 2>&1 | head -1
ffprobe -version 2>&1 | head -1

Se ffmpeg estiver ausente, instale com base na plataforma:

PlataformaComando de instalação
macOS (Homebrew)brew install ffmpeg
macOS (sem Homebrew)Guie o usuário a instalar Homebrew primeiro, depois 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

Se o torch estiver ausente, instale com base na plataforma:

PlataformaComando de instalação
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

Em seguida, instale o motor de transcrição:

# Para sistemas CUDA (faster-whisper com aceleração CTranslate2)
pip3 install faster-whisper

# Para sistemas MPS / CPU (Whisper OpenAI padrão)
pip3 install openai-whisper

Fase 3: Obter Duração

Use ffprobe (multiplataforma) para obter a duração do arquivo:

ffprobe -v quiet -show_entries format=duration -of csv=p=0 "/caminho/para/arquivo"

Isso retorna a duração em segundos. Converta para formato legível e exiba ao usuário. Use isso para estimar o tempo de transcrição com base no modelo e hardware selecionados.

Apresente o plano:

Plano de processamento:

  • Arquivo: {nome_arquivo} ({duração})
  • Motor: {WHISPER_ENGINE} com modelo {WHISPER_MODEL} em {device}
  • Tempo estimado de transcrição: {estimativa}
  • Extração de quadros: 1 por minuto ({quantidade_quadros} quadros)

Deseja ajustar algo antes de começar?

Estimativas de Tempo

Dispositivobasesmallmediumlarge-v3
CUDA (RTX 3060+)~1 min/h~2 min/h~4 min/h~5 min/h
CUDA (faster-whisper)~30s/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 (16GB+ RAM)~8 min/h~15 min/h~30 min/h~60 min/h

Fase 4: Extrair Quadros Visuais

Extraia um quadro por minuto para contexto visual. Use um diretório temporário multiplataforma:

# Criar diretório temporário (multiplataforma)
python3 -c "import tempfile, os; d = os.path.join(tempfile.gettempdir(), 'av-frames'); os.makedirs(d, exist_ok=True); print(d)"

Em seguida, extraia os quadros:

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

Use a ferramenta de Leitura em cada quadro para visualizá-los. Os quadros mostram:

  • Compartilhamento de tela (código, slides, UIs)
  • Nomes dos participantes (canto inferior esquerdo de cada bloco de vídeo)
  • Carimbos de data/hora (se visíveis no compartilhamento de tela)

Fase 5: Transcrever Áudio

Execute o motor de transcrição. Escolha o código correto com base em WHISPER_ENGINE:

faster-whisper (sistemas CUDA)

from faster_whisper import WhisperModel
import json

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

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

# Salvar transcrição com timestamps
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"Transcritos {len(results)} segmentos")

openai-whisper (sistemas MPS / CPU)

import whisper, json

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

# Salvar transcrição com timestamps
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"Transcritos {len(result['segments'])} segmentos")

Execute a transcrição em segundo plano, pois leva um tempo significativo. Enquanto isso, revise visualmente os quadros extraídos.

Fase 6: Sintetizar

Combine quadros visuais + transcrição + chat para construir entendimento:

  • Quem: Identifique participantes a partir de rótulos de nomes de vídeo e atribuição de voz
  • O quê: O que foi mostrado na tela (demonstrações, slides, código)
  • Falou: Citações-chave, decisões, requisitos, feedback
  • Itens de ação: Compromissos explícitos e acompanhamentos

Referência de Modelos

ModeloParâmetrosVelocidadePrecisãoMelhor Para
tiny39MMuito rápidoBaixaVerificação rápida, ver se o áudio é utilizável
base74MRápidoAdequadaPadrão para reuniões curtas/limpas
small244MModeradoBoaReuniões gerais com sotaques
medium769MLentoAltaReuniões importantes, com clientes
large-v31.5BMuito lentoMelhorGravações críticas, má qualidade de áudio

Dicas

  • Sempre execute a transcrição em segundo plano enquanto revisa os quadros visualmente
  • Leia os quadros em lotes de 8 (limite de paralelismo da ferramenta)
  • Whisper padrão usa FP32 na CPU e MPS; faster-whisper usa CTranslate2 com FP16 na CUDA
  • Para gravações muito longas (>1 hora), considere dividir o áudio primeiro
  • Arquivos de chat do Zoom contêm timestamps e links compartilhados; leia primeiro para contexto rápido
  • No Windows, use barras normais ou strings raw para caminhos de arquivos no Python

Tratamento de Erros

ErroCausaCorreção
ffmpeg: command not foundffmpeg não instaladoInstalar conforme tabela de plataforma acima
No module named 'whisper'Whisper não instaladopip3 install openai-whisper
No module named 'faster_whisper'faster-whisper não instaladopip3 install faster-whisper
CUDA out of memoryModelo grande demais para a VRAMMudar para modelo menor
RuntimeError: MPS backendProblema MPS em macOS antigoAtualizar macOS, ou voltar para CPU com PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0
torch not foundDependências Python faltandoInstalar torch conforme tabela de plataforma acima
Transcrição confusaIdioma errado ou áudio ruimTentar especificar language="pt" ou usar um modelo maior
Transcrição muito lentaExecutando modelo grande na CPUMudar para modelo base ou small

Habilidades Relacionadas