MusicProWorkshop/kinetic-film-to-resolve

Filme Cinético para DaVinci Resolve

Transforma o spec.js de um filme cinético em uma linha do tempo do Resolve onde cada take é um clipe com sua própria composição Fusion: Text+ e Text3D reais, câmeras com keyframes, a mesma temporização de batidas. Um editor pode então abrir qualquer take na página Fusion, redigitar uma palavra, cortá-la ou trocar a música.

É uma reconstrução nas ferramentas do Resolve, não uma correspondência de pixels. Informe o que mudou em relação ao original (setup retorna a lista como notes) e reporte ao usuário.

Antes de começar

• O Resolve Studio está em execução com um projeto aberto. Verifique com get_resolve_status e chame get_whats_new uma vez, conforme o servidor do Resolve solicita.
• A pasta do filme contém spec.js e os arquivos do mecanismo, com npm install playwright já executado nela.
• Python com Pillow fora do Resolve, para medir a tipografia. ffmpeg no PATH.

Pergunte ao usuário

Decida estas questões antes de construir, a partir da conversa se possível:

1. Qual projeto. A linha do tempo é adicionada ao projeto aberto. Informe ao usuário qual é. Trocar de projeto pode descartar o trabalho não salvo dele; peça para ele trocar se for o errado.
2. Nome da linha do tempo. Padrão <título> (Fusion). Veja as linhas do tempo existentes e escolha um nome livre. Nunca reutilize ou substitua uma que você não construiu nesta sessão.
3. Fonte. Text+ só vê fontes instaladas, e o Archivo do filme geralmente não está entre elas. Use a fonte da marca se o projeto mostrar uma. Chame fonts_available(resolve, 'Lato', 'Inter') para verificar; não instale fontes sem perguntar. Pesos pesados são melhores: Black, Heavy, ExtraBold.
4. Áudio. A edição de música de uma linha do tempo existente (audio_from_timeline), um arquivo (audio_from_file) ou nenhum. Se uma linha do tempo já contiver este filme com música, ofereça essa primeiro, pois preserva a edição do usuário.

Etapas

SKILL abaixo é a pasta desta skill e F é a pasta do filme. Cada etapa do Resolve passa por run_script_unsafe, que é limitada a 60 s por chamada, e começa com:

SKILL = r'<pasta da skill>'; F = r'<pasta do filme>'
exec(open(SKILL + r'\scripts\resolve_build.py', encoding='utf-8').read())

1. Exportar a especificação (a partir de um shell):

node "<SKILL>/scripts/export_film.mjs" "<F>"

Escreve <F>/resolve/film.json e o logotipo como PNGs transparentes, e imprime os blocos encontrados.

2. Criar a linha do tempo:

result = setup(resolve, project, F, 'Meu Filme (Fusion)', 'Lato', 'Black', 'Inter', 'Medium')

As duas últimas fontes são para linhas pequenas e UI simulada. Cria a linha do tempo, um compartimento Kinetic Films / <título> e um clipe placeholder preto, e retorna a contagem de takes e notes. O tamanho da linha do tempo e a taxa de quadros vêm do projeto, então um filme feito a 60 fps pode cair em uma linha do tempo de 30 fps. Só foi comprovado em 1920x1080, 60 fps; portanto, observe atentamente outros formatos.

3. Medir a tipografia (a partir de um shell, usando um Python que tenha Pillow):

python "<SKILL>/scripts/measure_fonts.py" "<F>" Lato Black

Sem isso, as palavras usam larguras estimadas e podem não preencher bem o quadro. Se reportar que não há arquivo de fonte, prossiga e verifique o enquadramento com cuidado.

4. Construir. Repita até que done seja verdadeiro; ele retoma de onde parou:

result = build_batch(project, F, 40)

Em seguida, adicione o HUD (apenas se o filme tiver um), o áudio e os marcadores de cena:

result = dict(hud=add_hud(project, F), audio=audio_from_timeline(project, F, 'Edição de Música'), markers=add_markers(project, F))

O HUD é um clipe Fusion na faixa 2 sobre todo o filme. Um editor pode desabilitar esse clipe para removê-lo.

5. Examinar os quadros. No Resolve 21.2 ou posterior, exporta folhas etiquetadas do meio de cada take diretamente da linha do tempo em alguns segundos, sem renderização e sem alterar as configurações de renderização. Elas vão para <F>/resolve/review/. Verifique se nada está preto, se as palavras permanecem no quadro, se os kickers limpam suas palavras e se as imagens cobrem o quadro. Corrija o que estiver errado antes de renderizar. frame_grid(project, F, seconds=[4.2, 9.35]) fornece momentos escolhidos em tamanho real, como o final de um whip.

result = frame_grid(project, F)

Os quadros correspondem a uma renderização do mesmo quadro, verificado na versão 21.2. Em um Resolve mais antigo sem ExportThumbnails, levanta um erro; nesse caso, avalie a partir da renderização.

6. Renderizar e medir o movimento.

result = start_render(project, F, 'meu_filme')    # escolhe um codificador H.264 de GPU quando houver
# em chamadas posteriores: result = wait_render(project, result_job_id, 50)

Espere cerca de 2 a 4 minutos para 30 s a 1080p60 em uma GPU potente. Depois, remova apenas seu próprio job com remove_job. A fila pode conter jobs do usuário. start_render altera as configurações de renderização do projeto; avise sobre isso.

O movimento só pode ser medido a partir do vídeo. Execute holds.py e dyn.py dos scripts de scenario-kinetic-film na renderização, se estiverem instalados. As metas são 40% de quadros parados ou menos, nenhuma pausa acima de 0,6 s antes do cartão final e movimento mediano de 2,5 ou mais. Relate os números, incluindo as falhas.

Para mudar algo, corrija e reconstrua com setup(..., replace=True), somente em uma linha do tempo construída por esta skill, depois repita as etapas 4 a 6. Para corrigir alguns takes, rebuild_shots(project, F, [8.2, 13]) substitui apenas as composições dos takes naqueles tempos (em segundos) ou por índice de take, e mantém todo o resto. Se as palavras do filme mudaram, execute novamente a etapa 3.

7. Finalizar. Deixe o salvamento para o usuário, a menos que ele peça: salvar também confirma quaisquer outras edições não salvas que ele tenha abertas. Informe o nome da linha do tempo, as notas, o tempo de renderização e os números da revisão. Mencione que o clipe placeholder deve permanecer em seu compartimento, caso contrário os takes podem aparecer como offline.

O que você não deve fazer e por quê

Cada um desses custa tempo real para descobrir. O detalhe está em references/fusion-traps.md; leia-o antes de alterar fusion_lib.py ou se algo der errado.

• Não bloqueie uma composição enquanto a constrói. O clipe então renderiza preto. Bloqueie apenas ao redor da criação do Loader, como Shot.loader faz; caso contrário, definir o clipe do Loader abre um seletor de arquivos modal na tela do usuário que interrompe toda a scriptagem.
• Não use ExportCurrentFrameAsStill para revisão. Ele ultrapassa o Fusion e retorna quadros pretos ou obsoletos. frame_grid, que usa Timeline.ExportFrame e ExportThumbnails, é confiável, mas apenas na linha do tempo atual: uma linha do tempo que não foi aberta exporta quadros pretos enquanto ainda relata sucesso.
• Não acumule desfoque de movimento. O desfoque no movimento de uma palavra e na câmera multiplica o trabalho. Apenas a câmera desfoca, e apenas durante movimentos rápidos.
• Não presuma que um codificador mais rápido corrige uma renderização lenta. A geração de quadros Fusion geralmente é o limite. Meça antes de alterar configurações.

Referência

• references/block-map.md: como cada um dos 14 blocos converte e o que é aproximado. Leia-o se um filme usar Graph, Counters, Progress, Chain, Prompt, Notes ou Rewind, ou se o usuário perguntar quão próximo um take estará.
• references/fusion-traps.md: comportamento da API descoberto da maneira difícil e como recuperar um Resolve travado.