nandinishukla/talking-head-short

Gravação de cabeça falante → short 9:16 finalizado

O pipeline leva uma gravação crua (mais um arquivo de áudio limpo opcional) para edit/final.mp4 (1080×1920, 60 fps, H.264 + AAC 48 kHz). Também escreve quatro stems completos e um relatório. Tudo acontece em código, instalado localmente dentro do projeto: ffmpeg, Python, Node e HyperFrames. Sem instalações em todo o sistema e sem aplicativos de edição.

• O padrão: references/brief.md é o briefing completo da casa, com todos os números para níveis, geometria, tempo, tipo e cor. Quando este arquivo e o briefing discordam em um número, o briefing vence.
• Leia antes de começar: references/lessons.md cobre as armadilhas que custaram horas na primeira execução.
• Perfil de som: references/sound-profile.md tem o estilo de efeitos sonoros e níveis do criador, medidos a partir de sua própria edição.
• Biblioteca de movimento: references/motion-library.md contém as referências de movimento selecionadas pelo usuário, o visual da casa que os gráficos seguem.
• Exemplos: references/examples/ contém os gráficos do primeiro short (r1–r9 mais cta). references/example-report.md é um relatório finalizado.

Pergunte ao editor as perguntas de estilo primeiro (etapa 0b), depois trabalhe de forma autônoma, com exceção de uma parada deliberada: a aprovação do storyboard na etapa 7. Entre esses dois pontos, não pergunte nada ao usuário: tome cada decisão (escolha de tomada, layout, discordância factual, interface inatingível), continue e registre para o relatório. A aprovação do storyboard é o único ponto em que você espera pelo usuário. Só pare se os arquivos de entrada estiverem faltando ou forem ilegíveis.

Layout de um projeto

<project>/RAW.MP4 (+ áudio limpo se houver)
<project>/edit/
  project.json        # toda decisão por vídeo fica aqui (tomadas, execuções, legendas, capa…)
  tools/              # bin/ffmpeg, bin/ffprobe, venv/, node_modules/ (setup.sh)
  work/               # todos os intermediários (gfx/ é o projeto HyperFrames)
  stems/  final.mp4  final_master.wav  REPORT.md

Todos os scripts são executados a partir de edit/ com export PATH="$PWD/tools/bin:$PATH" e PY=tools/venv/bin/python. $S abaixo é a pasta scripts/ deste skill.

Etapas

0. Configuração e sondagem

bash $S/setup.sh <projeto>. Depois ffprobe -show_streams o arquivo da câmera e anote:

• o tamanho e a rotação (fontes em retrato geralmente chegam como paisagem com uma bandeira de −90°);
• o fps;
• o layout de áudio.

Decodifique uma vez em um intermediário orientado. Não redecodifique 4K para cada etapa: ffmpeg -i RAW.MP4 -an -vf scale=1080:-2 -c:v libx264 -crf 13 -g 15 work/cam1080.mp4 Use scale=-2:1080 para uma fonte em paisagem. Execute comandos longos em segundo plano: cerca de 6 min por 90 s de 4K em um Mac de 8 GB.

0b. Coleta de estilo (pergunte uma vez, antes de qualquer trabalho)

Pergunte à pessoa que está editando o vídeo, em UMA rodada de perguntas (use a ferramenta de perguntas quando a tiver), as escolhas que somente ela pode fazer. Pule qualquer coisa que ela já deu e registre as respostas em project.json → "intake":

1. Legendas: o pequeno estilo do dia a dia, "small_style": "pill" (calmo, vídeos gerais) ou "mono" (máquina de escrever, tech/AI/dev); mais se usar hero (momentos de gancho e linhas-chave com apenas eles na tela).
2. Cor de destaque: do tópico (a cor da marca do produto principal; você a pesquisa), combinada com suas roupas, ou um hex que eles nomeiem → "accent".
3. CTA: "cta_style": "box" ou "pill", a palavra-chave do comentário e o texto do chip do link para a pílula (por exemplo, "Free on GitHub · owner/repo").
4. Música: "music": {"mode": "synth" | "file" | "none"} (+ o caminho do arquivo).
5. Título da capa: deles, ou escrito a partir do gancho.

Ofereça padrões sensatos nas opções (por exemplo, a cor da marca do tópico; pill + hero para vídeos gerais, mono + hero para tech; o outro estilo de CTA do último vídeo deles), para que responder leve segundos. Se ninguém puder responder (uma execução desassistida), use esses padrões e diga isso no relatório.

1. Sincronizar e transcrever

1. $PY $S/analyze_audio.py <câmera> [clean_audio] faz correlação cruzada a 16 kHz e relata o deslocamento e a relação de pico. Ele escreve a fonte de voz na linha do tempo da câmera, o envelope RMS de 10 ms, a contagem de amostras recortadas e o piso de ruído. Sem arquivo limpo, ele usa a faixa da câmera e você deve dizer isso no relatório.
2. $PY $S/transcribe.py medium.en "Nomes de produtos, pessoas, @handles" lista cada palavra com lacunas acima de 250 ms sinalizadas.
3. Execute novamente analyze_audio.py para que a listagem de trechos silenciosos mostre as palavras vizinhas.
4. Agrupe as palavras em tomadas por linha. Para cada linha, mantenha a última tomada completa. Use uma anterior apenas se a última tiver um defeito audível (gagueira, palavra recortada ou errada, reinício). Descarte reinícios, autocorreções, "ok", sílabas perdidas e murmúrios após as tomadas, mais ar morto em ambas as extremidades.

2. O corte

Escreva project.json → "lines": [[label, src_start, src_end], …] com bordas aproximadas ao redor de cada tomada mantida, em ordem de entrega. Linhas contíguas podem compartilhar um intervalo. Depois:

1. $PY $S/cut.py lida com início/fim verdadeiro (−35 dB / −32 dB por 150 ms), pausas acima de 250 ms → 120 ms, um lead-in de 40 ms, um J-cut de áudio de 50 ms, caudas que desaparecem dentro do intervalo, cortes de imagem quantizados por quadro e FIM.
2. $PY $S/check_joins.py: qualquer junção com um trecho silencioso acima de 150 ms recebe um "gap_overrides": {"<segment>": -0.0333} negativo. Execute novamente cut.py. Nunca adicione silêncio.

3. Contato visual

Faça um proxy pequeno (scale=-2:540), depois $PY $S/eyesheet.py work/proxy.mp4 e olhe work/eye/*.jpg. Adicione passos de 100 ms ao redor de qualquer virada de cabeça. A câmera mostra apenas enquanto o falante está olhando para a lente. Se eles desviarem o olhar no meio de uma linha, divida no limite da palavra antes da virada e torne o resto um visual completo.

4. Planejar as execuções (antes de qualquer gráfico)

$PY $S/plan.py imprime os tempos de corte de imagem. Escreva "runs": [[start_ms, end_ms, layout, "R1 hook"], …] cobrindo [0, END] (use "END" para o último fim), depois execute novamente. Valida as regras:

• o gancho é uma tela dividida e o final (CTA em diante) é câmera cheia;
• nenhuma execução tem mais de cerca de 8 s e vizinhos nunca compartilham um layout;
• todos os três layouts são usados.

Escolha layouts por conteúdo:

• opiniões e histórias diretas para a câmera → câmera;
• uma captura de tela, cartão, linha de logotipo ou lista curta → dividido;
• gravações de tela, páginas de notícias, UI de produto que precisa de zoom → visual.

Coloque limites nos cortes de imagem. plan.py então imprime as palavras de cada execução com tempos relativos à execução; cronometre os gráficos para esses tempos.

5. Pesquisa e capturas

Para cada produto nomeado e cada afirmação (lançamento, citação, número), encontre a fonte real e verifique os números com duas ou mais fontes confiáveis. Anote qualquer discordância para o relatório.

• Capture páginas reais com node $S/shot.mjs <url> <out.png> 1280 1400 0, executado a partir de edit/. Ele encontra o chrome-headless-shell do HyperFrames por conta própria. Respeite robots.txt de cada site e termos: capture as páginas que você cita, não rastreie.
• Repositórios geralmente fornecem um GIF de UI ou capturas de tela em docs/; reconstrua a UI a partir deles.
• Uma UI com acesso restrito é reconstruída a partir de capturas de tela públicas ou documentos e anotada no relatório.
• "Claude Code" significa a interface do aplicativo desktop Claude, a menos que o falante esteja falando sobre o terminal.

6. Legendas e capa (planejadas agora, porque o storyboard as mostra)

$PY $S/captions.py work/cam1080.mp4 (o vídeo da câmera é para a cor herói). Defina "small_style": "mono" para vídeos tech / ferramentas de IA / desenvolvedor / explicadores de produto (qualquer coisa com terminais, código ou telas de aplicativos), ou "pill" para vídeos gerais e de estilo de vida. Sem "captions.chunks" ele imprime um rascunho automático (o estilo pequeno em toda parte, um herói esboçado no gancho). Edite e cole de volta. Existem três estilos:

• mono [a, b, "mono", [palavra de destaque]]: 1–3 palavras, uma máquina de escrever de terminal. Caixa alta VT323 em uma caixa quase preta que cresce conforme as letras são digitadas (30 letras/s), uma palavra-chave significativa em um bloco de destaque sólido e um cursor de bloco de destaque (constante enquanto digita, piscando depois). assemble.py digita quadro a quadro.
• pill [a, b, "pill"]: 1–3 palavras, Poppins Bold pequeno em uma caixa arredondada translúcida escura: o estilo pequeno mais calmo para vídeos não tech.
• hero [a, b, "hero", [índices de palavras grandes]]: 2–5 palavras com 1–2 palavras GRANDES sólidas (Archivo Black) entre palavras pequenas acima e abaixo, que seguem o estilo pequeno do vídeo (pílulas ou caixas mono estáticas). A cor da palavra grande combina com a roupa do falante: captions.py work/cam1080.mp4 amostra o tronco no primeiro quadro herói e imprime a cor que escolheu. Tem um contorno profundo do mesmo matiz para que seja legível sobre essas roupas. Substitua com "hero_color": "#RRGGBB" se a escolha estiver errada (estampas ocupadas, uma jaqueta sobre uma camisa). Use-o no gancho e em linhas importantes onde apenas o falante está na tela (câmera cheia ou o cartão em uma tela dividida), nunca sobre um gráfico e nunca duas seguidas. Escolha palavras que carreguem o significado (a afirmação, número ou benefício), nunca palavras funcionais.

Defina "cover": [linha1, linha2] (escreva a partir do gancho se o usuário não deu nenhum, cerca de 14 caracteres por linha a 110 px). Defina o centro da pílula por layout em "y" e o centro do bloco herói em "hero_y".

• As legendas nunca devem ficar sobre o rosto, a borda do cartão ou um visual.
• Com uma fonte em retrato, a lacuna da tela dividida é o rosto, então coloque as pílulas em cerca de y 1660 no tronco e verifique o final em um quadro real.
• assemble.py compõe ambos os estilos.

7. Storyboard e tabela de batidas: PARE para aprovação

Nada é renderizado até que o usuário tenha visto e aprovado o plano.

1. Escolha referências de movimento para cada batida gráfica de references/motion-library.md (o visual da casa selecionado pelo usuário). references/motion-prompts.md contém os textos completos do prompt (atribuídos a seus criadores); leia o bloco para cada id citado. Nunca raspe galerias de terceiros. As entradas da biblioteca foram adicionadas pelo usuário, e alguns sites, por exemplo, prompt-motion.com, bloqueiam rastreadores de IA.
2. Escolha a cor de destaque do vídeo do que está sendo ensinado: a cor da marca do produto principal (logotipo, botão primário), senão uma cor que se adapte ao assunto. Escreva "accent": {"color": "#RRGGBB", "why": "..."} e execute $PY $S/accent.py. Ele escreve work/gfx/assets/accent.css (preenchimento de destaque, um tom de texto 4.5:1 e um tom de faixa clara), que toda composição capta através de base.css. Nunca codifique valores hex de destaque em composições: use var(--clay), var(--clayText) e var(--band). A cor da legenda herói é separada (vem das roupas).
3. Escreva "beats" em project.json, um ou mais por execução: {"run": "R1", "t": 0.0, "visual": "...", "camera": "...", "sfx": "...", "refs": ["id"], "source": "captura real / UI reconstruída / logotipo"}. Opcionalmente adicione "storyboard_notes": {"R1": "por que este layout"}.
4. $PY $S/storyboard.py work/cam1080.mp4 escreve work/storyboard.html: um esboço 9:16 por execução (zonas de layout, o quadro do falante, o gráfico, estilo e posição da legenda) e a tabela de batidas (tempo, execução, layout, palavras exatas, ação na tela, movimento da câmera, SFX, estilo de legenda com cada momento herói, referências de movimento, fonte).
5. Mostre ao usuário (a página mostra a amostra de destaque e por que foi escolhida): publique como um artefato, ou envie o arquivo e dê uma linha sobre o que olhar. Em seguida, termine sua vez e espere. Aplique as alterações deles a project.json, regenere e mostre novamente. Continue apenas com uma aprovação clara.

8. Gráficos (HyperFrames)

1. Copie assets/engine.js, assets/base.css, assets/accent.css, assets/fonts/ e assets/motion/ para work/gfx/assets/ (então execute novamente accent.py para que o destaque por vídeo substitua o padrão), mais hyperframes.json de hyperframes init.
2. Escreva um work/gfx/compositions/<chave da execução em minúsculas>.html por execução dividida/visual. Seu data-duration deve ser igual exatamente à execução.
3. Construa exatamente o que o storyboard aprovado mostra, combinando as referências de movimento de cada batida. Comece a partir do exemplo mais próximo em references/examples/:
   • r1, r3, r5, r7: mundos divididos com passos e pushes;
   • r2: trava de logotipo, depois um whip para uma captura real no quadro fixo em seu clone lavado;
   • r4, r6, r9: janelas de produto onde apenas a câmera interna se move;
   • cta: o cartão de comentário transparente (CTA estilo A); cta_pill.html: a pílula de comentário (CTA estilo B);
   • motion/*.html: uma demonstração por componente de movimento (cursor, glass, morph, flood + iris, maskrise, kinetic, wall, whip; explain-flow, explain-callout, explain-status, explain-loop); veja "Componentes de movimento" e "Componentes explicadores" abaixo.

Como o motor funciona e as regras que importam:

• E.run(id, dur, render) registra uma linha do tempo pausada. render(t) deve ser uma função pura de t.
• E.path fornece os keyframes da câmera mundial. E.camera os aplica e desfoca a janela de visualização ao longo da velocidade da tela (σ = 0.29·v·0.75/60, ≤ 40 px, zero em repouso e em t = 0).
• E.track e E.land animam propriedades por objeto (opacidade, x, y, escala, desfoque). Profundidade de campo: vizinhos com até 14 px de desfoque e 70% de opacidade; o antigo herói com 9 px e 40%.
• Movimentos da câmera:
  • glide: sine.inOut, mudança de escala ≤ 0.04;
  • step: 0.5 s power3.inOut, começando 0.25 s antes da palavra que nomeia o próximo item;
  • push: 1.2–2 s power2.inOut, até cerca de 1.6×;
  • pull back: 1–2 s;
  • whip: no máximo um por execução, 0.45 s out power3.in, 0.6 s in power3.out.
• O quadro 0 é o estado de aterrissagem, nítido, com a câmera em repouso.
• Enquanto uma janela de produto é o assunto, apenas a câmera dentro da janela se move (1.15–1.4×, 0.4–0.7 s power2.inOut).
• Zonas de conteúdo:
  • telas divididas mantêm o conteúdo em y 40–900, e o mundo desaparece a partir de y 900;
  • telas visuais mantêm o conteúdo acima de y 1230;
  • no quadro 0, o gráfico de introdução permanece abaixo de y 620 (a capa fica acima dele).
• Estilo visual:
  • um assunto esparso por cena;
  • Poppins e nada abaixo de 30 px;
  • chão radial quase branco e a sombra de três camadas;
  • nada escuro, sem grade;
  • anime a ação, nunca a rotule.
• Cada evento audível visível vai no <script type="application/json" id="events"> da composição (pop / clique / chim / thud para ícones pousando / flash para flashes brancos / whoosh no ponto médio do whip / teclas / ticks, relativo à execução). A etapa de áudio lê estes, então os SFX sempre caem em seus quadros exatos.

9. Montagem de áudio

$PY $S/sfx.py compõe todos os eventos da etapa 8: sintetiza arquivos .wav em work/audio/ (ruído de emissão de texto, tecla de guitarra, quebra de vidro, chimbau, chimbau aberto, chim, bumbo, clique, click tictoc, zumbido elétrico, explosão rápida, flash, fluxo, vidro, sinos, impacto, chave, baixo, pop, riser 3 s, percussão, quem, crina, íman, slide, tique, tique-taque, sussurro). Leia $S/sfx.py para a lista completa. Música sintetizada: $PY $S/music.py gera work/audio/music.wav. Ele escreve os detalhes de áudio em project.json → "audio", então $PY $S/mix.py limita todos os stems a -14 LUFS curto e integrado, um verdadeiro pico de -2 dB e uma faixa estéreo de 3.5 dB, demanda e renderiza edit/final_master.wav e edit/final.mp4. O relatório registra os níveis reais.

10. Relatório

$PY $S/report.py imprime um relatório de uma página com: comprimento da fonte, escolhas de design, problemas encontrados, fontes verificadas, níveis de áudio e quaisquer desvios do briefing/lições ou decisões desassistidas. Escreva como edit/stems/REPORT.md.

Pontos de parada

• O usuário aprova o storyboard (etapa 7).
• Os arquivos de entrada estão faltando ou são ilegíveis.
• Se um usuário disser para parar, pare. Sempre termine sua vez depois que o storyboard for mostrado, mesmo que...

(Tradução concluída para o escopo solicitado.)