Habilidade de Criação de Vídeos
Para motion graphics animados a partir de código — texto cinético, vídeos explicativos, vídeos de lançamento, gráficos animados, barras inferiores com opções de estilo visual — use a habilidade
motion-graphics. Esta habilidade é para filmagens, fotos, áudio e edição com ffmpeg.
Construa vídeos programaticamente com ffmpeg (mecanismo principal) e Python (Pillow para quadros/gráficos, MoviePy para edições de alto nível). Sempre planeje primeiro, construa em segundo lugar, verifique por último.
1. Planeje antes de construir
Decida estes pontos antes de escrever qualquer comando:
| Decisão | Padrão | Notas |
|---|---|---|
| Proporção | 16:9 (1920x1080) | 9:16 (1080x1920) para Reels/Shorts/TikTok, 1:1 (1080x1080) para feeds |
| Taxa de quadros | 30 fps | 24 para cinematográfico, 60 para gravações de tela/gameplay |
| Duração | Conforme solicitado | Reels/Shorts ≤ 60–90 s |
| Formato | MP4 (H.264 + AAC) | Reproduz em qualquer lugar; WebM apenas se solicitado; GIF apenas para loops curtos |
| Áudio | Opcional | Música, narração ou silencioso |
Escreva uma pequena lista de cenas: cada cena → duração, visual, texto, transição, áudio.
2. Verifique as ferramentas
which ffmpeg ffprobe || (apt-get update && apt-get install -y ffmpeg)
python3 -c "import PIL, moviepy" 2>/dev/null || pip install pillow moviepy --break-system-packages
fc-list | head # veja quais fontes estão disponíveis para texto
3. Configurações padrão de codificação
Use estas para cada renderização final, a menos que o usuário peça o contrário:
-c:v libx264 -preset veryfast -crf 23 -pix_fmt yuv420p -movflags +faststart \
-c:a aac -b:a 192k
-pix_fmt yuv420p— necessário para reprodução em celulares, QuickTime e navegadores.-movflags +faststart— permite que o vídeo comece a tocar antes de baixar completamente.-crf 18= quase sem perdas (arquivo maior),-crf 28= arquivo menor, qualidade inferior.-preset veryfastmantém as renderizações rápidas; useslowapenas quando a melhor qualidade for solicitada.- Largura e altura devem ser números pares para H.264.
3b. Renderize rápido — a pessoa está esperando
Uma renderização completa é a etapa mais lenta, então planeje uma renderização completa por solicitação:
- Veja antes de codificar. Extraia ou desenhe alguns quadros no tamanho final — os momentos mais movimentados, o primeiro e o último quadro — e verifique o enquadramento, o tamanho do texto e as cores. Para vídeos de fotos:
scripts/slideshow.py OUT.mp4 fotos… --previewfaz uma folha de contato em um segundo. - Cenas, não um gráfico gigante. Codifique cada cena em seu próprio arquivo com tamanho, fps e configurações de codificador idênticos, junte-os com o demuxer concat e
-c copy, e adicione o som por último com-c:v copy. Corrigir uma cena depois significa recodificar apenas aquela cena. - Transições vivem dentro de um arquivo de cena (fade in/out nas bordas). Fazer crossfade entre dois arquivos finalizados força uma segunda codificação completa.
- Segure uma imagem estática de forma barata. Decodifique a imagem uma vez e repita-a com o filtro
loop, em vez de-loop 1(que decodifica a imagem novamente para cada quadro):ffmpeg -framerate 30 -i still.png -vf "format=yuv420p,loop=-1:1,trim=duration=4,setpts=PTS-STARTPTS" -c:v libx264 -preset veryfast -crf 20 -pix_fmt yuv420p still.mp4 - Nunca deixe um arquivo parcial com o nome real. Escreva para
nome.part.mp4e renomeie apenas quando o ffmpeg sair com código 0 — uma renderização interrompida ainda pode ser reproduzida, apenas cortada. - Desenhe os quadros no tamanho de saída e a 30 fps, a menos que solicitado o contrário. Ao capturar uma página da web quadro a quadro, salve em JPEG (qualidade ~90), não PNG — muito mais rápido para escrever e ler.
Medido em 10 fotos → 1080p: o antigo gráfico único -loop 1 + xfade levou 13,2 s; slideshow.py --crossfade leva 6,4 s, o caminho de arquivo de cena 8,9 s incluindo música.
Alterando um vídeo finalizado:
| Alteração | Faça |
|---|---|
| Conteúdo de uma cena | re-renderize esse arquivo de cena, junte novamente com -c copy |
| Nova música / cortar o final | -c:v copy (nova música: -map 0:v -map 1:a) |
| Gravar legendas, fazer uma cópia menor | re-codifique o arquivo finalizado uma vez |
| Algo que muda em cada quadro | uma renderização completa é inevitável |
4. Receitas
4.0 Apresentação de slides de fotos em um comando
python3 scripts/slideshow.py out.mp4 fotos/*.jpg --seconds 3 --fade 0.5 --music musica.mp3 # rápido, fade via preto
python3 scripts/slideshow.py out.mp4 fotos/*.jpg --crossfade # crossfades verdadeiros
python3 scripts/slideshow.py out.mp4 fotos/*.jpg --zoom --size 1080x1920 # Ken Burns, vertical
4.1 Apresentação de slides a partir de imagens (com transições de fade), manualmente
# Cada imagem exibida por 3 s, crossfade de 0,5 s, redimensionada/preenchida para 1080p
# cada imagem estática é decodificada uma vez e repetida com o filtro loop (2x mais rápido que -loop 1)
F="scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,setsar=1,format=yuv420p,loop=-1:1,trim=duration=3,setpts=PTS-STARTPTS,fps=30"
ffmpeg -framerate 30 -i img1.jpg -framerate 30 -i img2.jpg -framerate 30 -i img3.jpg \
-filter_complex "\
[0]$F[a];[1]$F[b];[2]$F[c];\
[a][b]xfade=transition=fade:duration=0.5:offset=2.5[ab];\
[ab][c]xfade=transition=fade:duration=0.5:offset=5[out]" \
-map "[out]" -c:v libx264 -preset veryfast -crf 23 -pix_fmt yuv420p -movflags +faststart slideshow.mp4
Deslocamento para o clipe n = (soma das durações anteriores) − (n × duração do fade).
4.2 Ken Burns (zoom lento) em uma imagem estática
# d = número de quadros de saída (150 a 30 fps = 5 s); sem necessidade de -loop, zoompan gera os quadros
ffmpeg -i foto.jpg -vf "scale=3840:-2,zoompan=z='min(zoom+0.0008,1.2)':d=150:x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)':s=1920x1080:fps=30" \
-c:v libx264 -preset veryfast -crf 23 -pix_fmt yuv420p zoom.mp4
Redimensionar para 3840 primeiro evita o movimento instável que o zoompan mostra em imagens pequenas.
4.3 Sobreposição de texto / cartão de título
ffmpeg -i input.mp4 -vf "drawtext=fontfile=/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf:\
text='Meu Título':fontsize=72:fontcolor=white:box=1:[email protected]:boxborderw=20:\
x=(w-text_w)/2:y=h-150:enable='between(t,0,4)'" \
-c:v libx264 -preset veryfast -crf 23 -pix_fmt yuv420p -c:a copy titled.mp4
Para texto com apóstrofos, emojis ou scripts não latinos (Hindi, etc.), renderize o texto em PNG com Pillow usando uma fonte que suporte o script, depois sobreponha:
ffmpeg -i input.mp4 -i title.png -filter_complex "overlay=(W-w)/2:H-h-100:enable='between(t,0,4)'" ...
4.4 Cartão de título de cor sólida a partir do nada
ffmpeg -f lavfi -i color=c=0x111827:s=1920x1080:d=3:r=30 \
-vf "drawtext=fontfile=/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf:text='Capítulo 1':fontsize=96:fontcolor=white:x=(w-text_w)/2:y=(h-text_h)/2" \
-c:v libx264 -preset veryfast -crf 23 -pix_fmt yuv420p card.mp4
4.5 Cortar um clipe
# Corte preciso (re-codifica): de 00:00:05 por 10 segundos
ffmpeg -ss 00:00:05 -i input.mp4 -t 10 -c:v libx264 -preset veryfast -crf 23 -pix_fmt yuv420p -c:a aac trimmed.mp4
# Corte rápido (sem re-codificar, corta no keyframe mais próximo)
ffmpeg -ss 00:00:05 -i input.mp4 -t 10 -c copy trimmed_fast.mp4
4.6 Unir clipes
Mesmo codec/resolução/fps → demuxer concat (sem re-codificar):
printf "arquivo 'a.mp4'\narquivo 'b.mp4'\narquivo 'c.mp4'\n" > list.txt
ffmpeg -f concat -safe 0 -i list.txt -c copy joined.mp4
Fontes diferentes → normalize primeiro (scale, fps, taxa de áudio) ou use o filtro concat:
ffmpeg -i a.mp4 -i b.mp4 -filter_complex \
"[0:v]scale=1920:1080,setsar=1,fps=30[v0];[1:v]scale=1920:1080,setsar=1,fps=30[v1];\
[v0][0:a][v1][1:a]concat=n=2:v=1:a=1[v][a]" \
-map "[v]" -map "[a]" -c:v libx264 -preset veryfast -crf 23 -pix_fmt yuv420p -c:a aac joined.mp4
(Se um clipe não tiver trilha de áudio, adicione silêncio: -f lavfi -i anullsrc=r=48000:cl=stereo e use -shortest.)
4.7 Adicionar música de fundo
# Música sob o vídeo, fade out no final, para quando o vídeo terminar
# st = duração do vídeo menos duração do fade (aqui um vídeo de 30 s, fade de 3 s) — obtenha a duração com ffprobe
ffmpeg -i video.mp4 -i musica.mp3 -filter_complex \
"[1:a]volume=0.3,afade=t=out:st=27:d=3[m]" \
-map 0:v -map "[m]" -c:v copy -c:a aac -shortest with_music.mp4
# Misture música sob fala existente
ffmpeg -i video.mp4 -i musica.mp3 -filter_complex \
"[1:a]volume=0.15[m];[0:a][m]amix=inputs=2:duration=first[a]" \
-map 0:v -map "[a]" -c:v copy -c:a aac mixed.mp4
4.8 Legendas / legendas ocultas
Escreva um arquivo .srt:
1
00:00:00,000 --> 00:00:03,000
Bem-vindo ao vídeo.
2
00:00:03,000 --> 00:00:06,500
Aqui está o que cobriremos.
Grave-as:
ffmpeg -i input.mp4 -vf "subtitles=subs.srt:force_style='FontSize=24,PrimaryColour=&HFFFFFF,OutlineColour=&H000000,BorderStyle=1,Outline=2'" \
-c:v libx264 -preset veryfast -crf 23 -pix_fmt yuv420p -c:a copy captioned.mp4
4.9 Redimensionar para redes sociais (vertical 9:16)
# Fundo desfocado em vez de barras pretas
ffmpeg -i landscape.mp4 -filter_complex \
"[0]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,boxblur=20[bg];\
[0]scale=1080:-2[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2" \
-c:v libx264 -preset veryfast -crf 23 -pix_fmt yuv420p -c:a copy vertical.mp4
4.10 Acelerar / desacelerar
# Velocidade 2x (vídeo + áudio)
ffmpeg -i in.mp4 -filter_complex "[0:v]setpts=0.5*PTS[v];[0:a]atempo=2.0[a]" -map "[v]" -map "[a]" fast.mp4
4.11 Vídeo para GIF (alta qualidade)
ffmpeg -i in.mp4 -vf "fps=15,scale=640:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" -loop 0 out.gif
4.12 Renderizar quadros a partir de código (animações, gráficos, motion graphics)
Quando os filtros do ffmpeg não são suficientes, desenhe cada quadro com Python e monte-os:
from PIL import Image, ImageDraw, ImageFont
import os, subprocess
W, H, FPS, SECONDS = 1920, 1080, 30, 4
os.makedirs("frames", exist_ok=True)
font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 96)
for i in range(FPS * SECONDS):
t = i / (FPS * SECONDS)
img = Image.new("RGB", (W, H), (17, 24, 39))
d = ImageDraw.Draw(img)
x = int(-600 + t * (W + 600)) # texto desliza através
d.text((x, H // 2 - 48), "Olá!", font=font, fill=(255, 255, 255))
img.save(f"frames/{i:05d}.png")
subprocess.run(["ffmpeg", "-y", "-framerate", str(FPS), "-i", "frames/%05d.png",
"-c:v", "libx264", "-preset", "veryfast", "-crf", "23",
"-pix_fmt", "yuv420p", "-movflags", "+faststart", "animation.mp4"], check=True)
Use easing (por exemplo t*t*(3-2*t)) para movimento mais suave.
4.13 MoviePy (edições rápidas de alto nível)
from moviepy import VideoFileClip, TextClip, CompositeVideoClip, concatenate_videoclips, AudioFileClip
clip1 = VideoFileClip("a.mp4").subclipped(0, 5)
clip2 = VideoFileClip("b.mp4").subclipped(2, 8)
video = concatenate_videoclips([clip1, clip2], method="compose")
music = AudioFileClip("musica.mp3")
video = video.with_audio(music.subclipped(0, min(video.duration, music.duration))) # música pode ser mais curta
video.write_videofile("out.mp4", fps=30, codec="libx264", audio_codec="aac", preset="veryfast")
(API MoviePy 2.x mostrada; 1.x usa subclip/set_audio. Verifique com pip show moviepy.)
5. Verifique antes de entregar
Nunca entregue um vídeo sem verificá-lo:
# Duração, resolução, codecs, fps
ffprobe -v error -show_entries format=duration:stream=codec_name,width,height,r_frame_rate -of default=nw=1 out.mp4
# Extraia quadros estáticos em momentos-chave e olhe para eles
ffmpeg -ss 1 -i out.mp4 -frames:v 1 check_1s.png
ffmpeg -i out.mp4 -vf "fps=1/3,scale=480:-1,tile=4x2" -frames:v 1 contact_sheet.png
Lista de verificação:
- Duração corresponde ao planejado
- Resolução e proporção estão corretas; sem barras pretas indesejadas ou esticamento
- Texto é legível, dentro das margens de segurança (mantenha ~5% das bordas; para 9:16, evite os ~15% inferiores onde fica a IU do aplicativo)
- Transições ocorrem onde pretendido
- Áudio presente (se esperado), sem distorção, termina de forma limpa
- Reproduz em celulares: H.264,
yuv420p, dimensões pares
6. Problemas comuns
| Problema | Correção |
|---|---|
| Vídeo não toca no iPhone/QuickTime | Adicione -pix_fmt yuv420p |
| "largura não divisível por 2" | Use scale=1280:-2 em vez de -1 |
Quadros pretos no início após corte com -c copy | Re-codifique, ou coloque -ss antes de -i e re-codifique |
| Áudio fora de sincronia após concat | Normalize fps e taxa de amostragem de áudio (-ar 48000) antes de unir |
| Erro xfade "inputs differ" | Todas as entradas precisam do mesmo tamanho, fps, setsar=1 e formato de pixel |
drawtext quebra com ' ou : | Escape, ou use textfile= / sobreposição PNG renderizada com Pillow |
| Texto não inglês mostra quadrados | Use uma fonte que suporte o script (por exemplo, Noto Sans Devanagari) |
| Tamanho de arquivo enorme | Aumente CRF (26–28), reduza fps ou resolução |
| Renderização muito lenta | Use -preset veryfast ou ultrafast; reduza a resolução durante o rascunho |
7. Resumo do fluxo de trabalho
- Planeje — proporção, fps, duração, lista de cenas, áudio.
- Reúna ativos — imagens, clipes, música, fontes; verifique-os com
ffprobe. - Rascunhe rápido — baixa resolução / preset
ultrafastpara verificar o tempo. - Construa o final — configurações padrão de codificação (seção 3).
- Verifique — ffprobe + folha de contato + lista de verificação (seção 5).
- Entregue — envie o arquivo final com um resumo de uma linha (duração, resolução, o que contém).