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ção | Motor | Motivo |
|---|---|---|
| GPU CUDA disponível | faster-whisper | Acelerado por GPU CTranslate2, 4x mais rápido que Whisper padrão |
| MPS (Apple Silicon) | openai-whisper | Whisper padrão, usa aceleração MPS quando disponível |
| Apenas CPU | openai-whisper | Whisper 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ção | Modelo Recomendado | Velocidade (1h de gravação) | Precisão |
|---|---|---|---|
| CUDA >= 8 GB VRAM | large-v3 | ~5 min | Melhor |
| CUDA 4-7 GB VRAM | medium | ~8 min | Alta |
| MPS (Apple Silicon, 16+ GB) | medium | ~15 min | Alta |
| MPS (Apple Silicon, 8 GB) | small | ~10 min | Boa |
| CPU + RAM >= 16 GB | small | ~30 min | Boa |
| CPU + RAM < 16 GB | base | ~15 min | Adequada |
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:
| Plataforma | Comando de instalação |
|---|---|
| macOS (Homebrew) | brew install ffmpeg |
| macOS (sem Homebrew) | Guie o usuário a instalar Homebrew primeiro, depois ffmpeg |
| Ubuntu/Debian | sudo apt update && sudo apt install -y ffmpeg |
| Fedora/RHEL | sudo dnf install -y ffmpeg |
| Arch Linux | sudo 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:
| Plataforma | Comando 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
| Dispositivo | base | small | medium | large-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
| Modelo | Parâmetros | Velocidade | Precisão | Melhor Para |
|---|---|---|---|---|
tiny | 39M | Muito rápido | Baixa | Verificação rápida, ver se o áudio é utilizável |
base | 74M | Rápido | Adequada | Padrão para reuniões curtas/limpas |
small | 244M | Moderado | Boa | Reuniões gerais com sotaques |
medium | 769M | Lento | Alta | Reuniões importantes, com clientes |
large-v3 | 1.5B | Muito lento | Melhor | Gravaçõ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
| Erro | Causa | Correção |
|---|---|---|
ffmpeg: command not found | ffmpeg não instalado | Instalar conforme tabela de plataforma acima |
No module named 'whisper' | Whisper não instalado | pip3 install openai-whisper |
No module named 'faster_whisper' | faster-whisper não instalado | pip3 install faster-whisper |
CUDA out of memory | Modelo grande demais para a VRAM | Mudar para modelo menor |
RuntimeError: MPS backend | Problema MPS em macOS antigo | Atualizar macOS, ou voltar para CPU com PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0 |
torch not found | Dependências Python faltando | Instalar torch conforme tabela de plataforma acima |
| Transcrição confusa | Idioma errado ou áudio ruim | Tentar especificar language="pt" ou usar um modelo maior |
| Transcrição muito lenta | Executando modelo grande na CPU | Mudar para modelo base ou small |