Quando esta habilidade for ativada, sempre inicie sua primeira resposta com o emoji :mag:.
Analisador de Vídeo
A análise de vídeo é a prática de extrair informações estruturadas de arquivos de vídeo - metadados, quadros-chave, limites de cena, paletas de cores, dados de movimento e características de áudio. Um pipeline de análise de vídeo bem construído combina FFmpeg para extração de quadros e processamento de sinais com modelos de visão de IA para compreensão semântica do conteúdo visual. Esta habilidade cobre o fluxo de trabalho completo, desde arquivos de vídeo brutos até dados acionáveis: usando ffprobe para inspeção de metadados, gráficos de filtro FFmpeg para extração de quadros e detecção de cena, análise de áudio para detecção de silêncio e volume, e visão de IA para extração de sistemas de design e compreensão de conteúdo.
Os dois pilares da análise de vídeo são FFmpeg (o canivete suíço do processamento de mídia) e modelos de visão de IA (para entender o que está em cada quadro). O FFmpeg lida com o trabalho mecânico - dividir o vídeo em quadros, detectar mudanças de cena por meio de limites de diferença de pixel, extrair formas de onda de áudio. A visão de IA lida com o trabalho semântico - identificar componentes de UI, ler texto, extrair valores de cores e entender padrões de layout.
Quando usar esta habilidade
Ative esta habilidade quando o usuário:
- Quiser extrair quadros de um vídeo em intervalos regulares ou limites de cena
- Precisar analisar metadados de vídeo (resolução, duração, codecs, taxa de bits)
- Perguntar sobre detecção de cena ou timestamps de mudança de cena
- Quiser extrair uma paleta de cores ou sistema de design de conteúdo de vídeo
- Precisar analisar trilhas de áudio (detecção de silêncio, níveis de volume, formas de onda)
- Perguntar sobre análise de movimento ou temporização de animação a partir de vídeo
- Quiser usar visão de IA para entender o conteúdo do vídeo quadro a quadro
- Precisar gerar miniaturas ou tiras de visualização a partir de arquivos de vídeo
Não ative esta habilidade para:
- Criar ou editar vídeos do zero - use remotion-video ou video-creator
- Escrever roteiros de vídeo ou storyboards - use video-scriptwriting
- Transmissão de vídeo ao vivo ou processamento de vídeo em tempo real
- Codificação/transcodificação de vídeo para distribuição (é uma tarefa de renderização, não de análise)
Princípios-chave
-
Extraia depois analise - Sempre separe a extração de quadros (FFmpeg) da análise semântica (visão de IA). Tentar fazer ambos em uma única etapa leva a pipelines frágeis. Extraia os quadros para o disco primeiro, depois analise-os.
-
Use ffprobe antes de ffmpeg - Antes de processar qualquer vídeo, inspecione-o com ffprobe para entender suas propriedades. Executar comandos FFmpeg às cegas em formatos desconhecidos leva a falhas silenciosas e saída corrompida.
-
Detecção de cena sobre intervalos fixos - Ao analisar conteúdo de vídeo, extraia quadros nos limites de cena em vez de intervalos de tempo fixos. Os quadros de mudança de cena capturam a diversidade visual do vídeo com muito menos quadros do que a extração de um por segundo.
-
Saída JSON em toda parte - Use o formato de saída JSON do ffprobe e estruture os resultados da sua análise como JSON. Isso torna os pipelines componíveis e os resultados legíveis por máquina.
-
Consciência de espaço em disco - A extração de quadros de vídeo pode gerar milhares de arquivos de imagem grandes. Sempre estime o tamanho da saída antes de extrair, use formatos de imagem apropriados (JPEG para análise, PNG para trabalho pixel-perfeito) e limpe os quadros temporários após a análise.
Conceitos principais
Arquitetura de pipeline FFmpeg
O FFmpeg processa vídeo através de um pipeline de demuxing, decodificação, filtragem, codificação e muxing. Para análise, usamos principalmente os estágios de decodificação e filtragem:
Arquivo de entrada -> Demuxer -> Decodificador -> Grafo de filtro -> Saída (quadros/dados)
Conceitos-chave de filtro para análise:
- Filtro
select: escolhe quais quadros produzir com base em expressões - Filtro
showinfo: imprime metadados do quadro (timestamps, tipo de imagem, etc.) scenedetecção: pontuação de diferença em nível de pixel entre quadros consecutivos- Filtro
fps: reduz a taxa de quadros para extrair em intervalos regulares
Detecção de cena
A detecção de cena funciona comparando quadros consecutivos usando diferença de pixel. O filtro scene do FFmpeg produz uma pontuação de 0.0 (idêntico) a 1.0 (completamente diferente). Um limite de 0.3-0.4 captura mudanças de cena principais enquanto ignora movimento da câmera e mudanças de iluminação.
| Limite | Comportamento |
|---|---|
| 0.1-0.2 | Muito sensível - captura panorâmicas, zooms, mudanças de iluminação |
| 0.3-0.4 | Equilibrado - captura cortes, transições, mudanças principais |
| 0.5-0.7 | Conservador - apenas cortes bruscos e mudanças de cena dramáticas |
| 0.8-1.0 | Muito agressivo - perde a maioria das mudanças de cena |
Fluxo de trabalho de análise de visão de IA
O fluxo de trabalho para extrair dados estruturados de vídeo usando visão de IA:
- Sondar - Obter metadados do vídeo com ffprobe (duração, resolução, fps)
- Extrair - Extrair quadros-chave nos limites de cena usando FFmpeg
- Ler - Carregar cada imagem de quadro usando a ferramenta Read (suporta imagens)
- Analisar - Para cada quadro, identificar cores, tipografia, layout, componentes
- Agregar - Encontrar padrões consistentes entre os quadros
- Saída - Produzir sistema de design estruturado ou análise de conteúdo
Tarefas comuns
1. Instalar e verificar FFmpeg
Verifique se o FFmpeg está disponível e inspecione sua versão e capacidades.
# Verificar instalação do FFmpeg
ffmpeg -version
# Verificar instalação do ffprobe
ffprobe -version
# Instalar no macOS
brew install ffmpeg
# Instalar no Ubuntu/Debian
sudo apt-get update && sudo apt-get install -y ffmpeg
# Verificar formatos suportados
ffmpeg -formats 2>/dev/null | head -20
# Verificar codecs suportados
ffmpeg -codecs 2>/dev/null | grep -i h264
2. Extrair quadros-chave nos limites de cena
Extraia apenas os quadros onde ocorrem mudanças visuais significativas. Esta é a maneira mais eficiente de amostrar o conteúdo do vídeo.
# Extrair quadros em mudanças de cena (limite 0.3)
mkdir -p scenes
ffmpeg -i input.mp4 \
-vf "select='gt(scene,0.3)',showinfo" \
-vsync vfr \
scenes/scene_%04d.png \
2>&1 | grep showinfo
# Extrair com timestamps registrados em um arquivo
ffmpeg -i input.mp4 \
-vf "select='gt(scene,0.3)',showinfo" \
-vsync vfr \
scenes/scene_%04d.png \
2>&1 | grep "pts_time" > scenes/timestamps.txt
# Extrair quadros de cena como JPEG (arquivos menores, bons para análise)
mkdir -p scenes
ffmpeg -i input.mp4 \
-vf "select='gt(scene,0.3)'" \
-vsync vfr \
-q:v 2 \
scenes/scene_%04d.jpg
3. Extrair quadros em intervalos regulares
Quando você precisa de amostras uniformemente espaçadas, independentemente das mudanças de conteúdo.
# Extrair um quadro por segundo
mkdir -p frames
ffmpeg -i input.mp4 -vf "fps=1" frames/frame_%04d.png
# Extrair um quadro a cada 5 segundos
mkdir -p frames
ffmpeg -i input.mp4 -vf "fps=1/5" frames/frame_%04d.png
# Extrair apenas quadros I (quadros-chave do codec)
mkdir -p keyframes
ffmpeg -i input.mp4 \
-vf "select='eq(pict_type,I)'" \
-vsync vfr \
keyframes/kf_%04d.png
# Extrair um único quadro em um timestamp específico
ffmpeg -i input.mp4 -ss 00:01:30 -frames:v 1 thumbnail.png
# Extrair apenas o primeiro quadro
ffmpeg -i input.mp4 -frames:v 1 first_frame.png
4. Analisar metadados de vídeo com ffprobe
Inspecione as propriedades do vídeo antes de processar. Sempre use saída JSON para resultados legíveis por máquina.
# Metadados completos como JSON (streams e formato)
ffprobe -v quiet \
-print_format json \
-show_format \
-show_streams \
input.mp4
# Obter apenas a duração
ffprobe -v error \
-show_entries format=duration \
-of default=noprint_wrappers=1:nokey=1 \
input.mp4
# Obter resolução
ffprobe -v error \
-select_streams v:0 \
-show_entries stream=width,height \
-of csv=s=x:p=0 \
input.mp4
# Obter taxa de quadros
ffprobe -v error \
-select_streams v:0 \
-show_entries stream=r_frame_rate \
-of default=noprint_wrappers=1:nokey=1 \
input.mp4
# Obter informações do codec
ffprobe -v error \
-select_streams v:0 \
-show_entries stream=codec_name,codec_long_name,profile \
-of json \
input.mp4
# Contar quadros totais
ffprobe -v error \
-count_frames \
-select_streams v:0 \
-show_entries stream=nb_read_frames \
-of default=noprint_wrappers=1:nokey=1 \
input.mp4
5. Detectar cenas e listar timestamps
Obtenha uma lista de timestamps de mudança de cena sem extrair quadros.
# Listar timestamps de mudança de cena
ffmpeg -i input.mp4 \
-vf "select='gt(scene,0.3)',showinfo" \
-f null - \
2>&1 | grep pts_time
# Extrair pontuações de cena para cada quadro (para análise)
ffmpeg -i input.mp4 \
-vf "select='gte(scene,0)',metadata=print" \
-f null - \
2>&1 | grep "lavfi.scene_score"
# Contar número de mudanças de cena
ffmpeg -i input.mp4 \
-vf "select='gt(scene,0.3)',showinfo" \
-f null - \
2>&1 | grep -c "pts_time"
6. Extrair forma de onda de áudio e detectar silêncio
Analise a trilha de áudio para lacunas de silêncio, níveis de volume e formas de onda visuais.
# Detectar períodos de silêncio (útil para encontrar quebras de capítulo)
ffmpeg -i input.mp4 \
-af silencedetect=noise=-30dB:d=0.5 \
-f null - \
2>&1 | grep silence
# Gerar forma de onda de áudio como imagem
ffmpeg -i input.mp4 \
-filter_complex "showwavespic=s=1920x200:colors=blue" \
-frames:v 1 \
waveform.png
# Analisar níveis de volume
ffmpeg -i input.mp4 \
-af volumedetect \
-f null - \
2>&1 | grep volume
# Extrair visualização do espectro de áudio
ffmpeg -i input.mp4 \
-filter_complex "showspectrumpic=s=1920x512:color=intensity" \
-frames:v 1 \
spectrum.png
7. Fluxo de trabalho de análise de visão de IA
Extraia quadros e depois analise-os com a capacidade de visão do Claude para extrair informações estruturadas do conteúdo do vídeo.
# Etapa 1: Sondar o vídeo
ffprobe -v quiet -print_format json -show_format -show_streams input.mp4
# Etapa 2: Extrair quadros de cena
mkdir -p analysis_frames
ffmpeg -i input.mp4 \
-vf "select='gt(scene,0.3)'" \
-vsync vfr \
-q:v 2 \
analysis_frames/frame_%04d.jpg
Após extrair os quadros, use a ferramenta Read para carregar cada imagem. A ferramenta Read suporta arquivos de imagem (PNG, JPG, etc.) e os apresentará visualmente. Para cada quadro, analise:
- Cores: Extraia valores hexadecimais de cores dominantes, cores de fundo, cores de destaque
- Tipografia: Identifique tamanhos de fonte, pesos, alturas de linha, hierarquia de cabeçalhos
- Layout: Detecte padrões de grade, layouts flexíveis, ritmos de espaçamento, margens
- Componentes: Identifique botões, cartões, cabeçalhos, navegação, formulários
- Estado de animação: Observe transições, estados de hover, indicadores de carregamento
Agregue as descobertas em todos os quadros para construir um sistema de design consistente.
8. Extração de sistema de design a partir de vídeo
Um fluxo de trabalho completo para extrair um sistema de design de uma demonstração de produto ou vídeo de passo a passo de UI.
# Etapa 1: Obter informações do vídeo
ffprobe -v quiet -print_format json -show_format input.mp4
# Etapa 2: Extrair quadros de cena (captura cada tela única)
mkdir -p design_frames
ffmpeg -i input.mp4 \
-vf "select='gt(scene,0.4)'" \
-vsync vfr \
-q:v 1 \
design_frames/screen_%04d.png
# Etapa 3: Extrair também em intervalos regulares para cobertura
ffmpeg -i input.mp4 \
-vf "fps=1/3" \
-q:v 1 \
design_frames/interval_%04d.png
Após a extração de quadros, analise cada quadro com visão de IA e compile:
{
"colors": {
"primary": "#2563EB",
"secondary": "#7C3AED",
"background": "#FFFFFF",
"surface": "#F3F4F6",
"text": "#111827",
"textSecondary": "#6B7280"
},
"typography": {
"headingFont": "Inter",
"bodyFont": "Inter",
"scale": ["12px", "14px", "16px", "20px", "24px", "32px", "48px"]
},
"spacing": {
"unit": "8px",
"scale": ["4px", "8px", "12px", "16px", "24px", "32px", "48px", "64px"]
},
"components": ["button", "card", "navbar", "sidebar", "input", "modal"]
}
Antipadrões / erros comuns
| Erro | Por que está errado | O que fazer em vez disso |
|---|---|---|
| Extrair todos os quadros de um vídeo | Gera milhares de arquivos, desperdiça disco e tempo de análise | Use detecção de cena ou intervalos fixos (1 fps ou menos) |
| Pular o ffprobe antes do processamento | Codecs desconhecidos ou arquivos corrompidos causam falhas silenciosas do FFmpeg | Sempre sonde primeiro para validar formato e propriedades |
| Usar PNG para extração em massa de quadros | Arquivos PNG são 5-10x maiores que JPEG com ganho mínimo de qualidade para análise | Use JPEG (-q:v 2) para análise; PNG apenas para trabalho pixel-exato |
| Definir limite de cena muito baixo (0.1) | Captura movimento da câmera, mudanças de iluminação - produz muitos quadros | Comece com 0.3-0.4 e ajuste com base nos resultados |
Ignorar -vsync vfr com o filtro select | Produz quadros duplicados preenchendo lacunas na linha do tempo | Sempre use -vsync vfr ao usar o filtro select |
| Analisar quadros sem timestamps | Não é possível correlacionar os resultados da análise de volta à linha do tempo do vídeo | Use o filtro showinfo para capturar pts_time com cada quadro |
| Executar visão de IA em centenas de quadros | Excede os limites de contexto e desperdiça tokens | Limite a 10-20 quadros representativos por passada de análise |
| Codificar caminhos do ffmpeg | Quebra entre SO e métodos de instalação | Use ffmpeg e ffprobe diretamente, confiando no PATH |
Armadilhas
-
-vsync vfré necessário com filtros select - Sem-vsync vfr, o FFmpeg preenche quadros "faltantes" entre quadros selecionados com duplicatas para manter uma taxa de quadros constante. Isso significa que extrair 5 quadros de mudança de cena pode produzir 500 arquivos de saída, a maioria deles duplicatas. Sempre emparelhe filtrosselectcom-vsync vfr. -
O limite de detecção de cena varia por conteúdo - Um limite de 0.3 funciona bem para cortes em vídeo narrativo, mas conteúdo animado ou gravações de tela podem precisar de 0.4-0.5 porque transições graduais produzem pontuações de cena mais baixas. Sempre verifique a contagem de quadros após a extração e ajuste o limite.
-
A contagem de quadros do ffprobe é lenta - Usar
-count_framescom ffprobe decodifica o vídeo inteiro para contar quadros com precisão. Para vídeos longos, isso pode levar minutos. Usenb_framesdos metadados do stream (menos preciso, mas instantâneo) ou estime a partir da duração e taxa de quadros. -
Os parâmetros de detecção de silêncio de áudio precisam de ajuste - O limite de ruído padrão de
-30dBpara silêncio pode ser muito sensível para gravações ambientes ou muito restritivo para conteúdo de estúdio. Comece com-30dBe ajuste com base no tipo de conteúdo.