Film cinétique vers DaVinci Resolve

Que fait Film cinétique vers DaVinci Resolve ?

Transforme le spec.js d'un film cinétique en une timeline Resolve où chaque plan est un clip avec son propre compositing Fusion : Text+ et Text3D réels, caméras animées, le même timing rythmique. Un éditeur peut ensuite ouvrir n'importe quel plan dans la page Fusion, retaper un mot, le couper ou changer la musique.

C'est une reconstruction dans les outils de Resolve, pas une correspondance pixel par pixel. Dites ce qui a changé par rapport à l'original (setup renvoie la liste sous forme de notes), et rapportez-le à l'utilisateur.

Avant de commencer

• Resolve Studio est en cours d'exécution avec un projet ouvert. Vérifiez avec get_resolve_status, et appelez get_whats_new une fois, comme le demande le serveur Resolve.
• Le dossier du film contient spec.js et les fichiers du moteur, avec npm install playwright effectué à l'intérieur.
• Python avec Pillow en dehors de Resolve, pour mesurer la typographie. ffmpeg dans le PATH.

Demander à l'utilisateur

Décidez de ces éléments avant de construire, à partir de la conversation si possible :

1. Quel projet. La timeline est ajoutée au projet ouvert. Dites à l'utilisateur lequel c'est. Changer de projet pourrait perdre leur travail non sauvegardé, demandez-leur donc de changer si ce n'est pas le bon.
2. Nom de la timeline. Par défaut <titre> (Fusion). Regardez les timelines existantes et choisissez un nom libre. Ne réutilisez jamais et ne remplacez jamais une timeline que vous n'avez pas construite dans cette session.
3. Police. Text+ ne voit que les polices installées, et Archivo (celle du film) ne l'est généralement pas. Utilisez la police de la marque si le projet en montre une. Appelez fonts_available(resolve, 'Lato', 'Inter') pour vérifier ; n'installez pas de polices sans demander. Les graisses lourdes sont les plus lisibles : Black, Heavy, ExtraBold.
4. Audio. Le montage musical d'une timeline existante (audio_from_timeline), un fichier (audio_from_file), ou rien. Si une timeline contient déjà ce film avec de la musique, proposez-la d'abord, car cela conserve l'édition de l'utilisateur.

Étapes

SKILL ci-dessous est le dossier de cette compétence et F est le dossier du film. Chaque étape Resolve passe par run_script_unsafe, qui est limité à 60 s par appel, et commence par :

SKILL = r'<ce dossier de compétence>'; F = r'<dossier du film>'
exec(open(SKILL + r'\scripts\resolve_build.py', encoding='utf-8').read())

1. Exporter le cahier des charges (depuis un shell) :

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

Écrit <F>/resolve/film.json et le logo en PNG transparent, et affiche les blocs trouvés.

2. Créer la timeline :

result = setup(resolve, project, F, 'Mon Film (Fusion)', 'Lato', 'Black', 'Inter', 'Medium')

Les deux dernières polices sont pour les petites lignes et l'UI simulée. Cela crée la timeline, un dossier Kinetic Films / <titre> et un clip de substitution noir, et renvoie le nombre de plans et les notes. La taille de la timeline et la fréquence d'images proviennent du projet, donc un film fait à 60 fps peut atterrir sur une timeline à 30 fps. Cela n'est prouvé qu'en 1920x1080, 60 fps, donc examinez attentivement les autres formats.

3. Mesurer la typographie (depuis un shell, en utilisant un Python qui a Pillow) :

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

Sans cela, les mots utilisent des largeurs estimées et peuvent ne pas bien remplir le cadre. Si le script signale l'absence de fichier de police, continuez et vérifiez attentivement le cadrage.

4. Construire. Répétez jusqu'à ce que done soit vrai ; il reprend là où il s'est arrêté :

result = build_batch(project, F, 40)

Ajoutez ensuite le HUD (uniquement si le film en a un), l'audio et les marqueurs de scène :

result = dict(hud=add_hud(project, F), audio=audio_from_timeline(project, F, 'Montage Musical'), markers=add_markers(project, F))

Le HUD est un seul clip Fusion sur la piste 2 couvrant tout le film. Un éditeur peut désactiver ce clip pour le supprimer.

5. Examiner les images. Sur Resolve 21.2 ou ultérieur, cela exporte des feuilles étiquetées du milieu de chaque plan directement depuis la timeline en quelques secondes, sans rendu et sans modifier les paramètres de rendu. Elles vont dans <F>/resolve/review/. Vérifiez que rien n'est noir, que les mots restent dans le cadre, que les kickers effacent leurs mots et que les images couvrent le cadre. Corrigez ce qui ne va pas avant de rendre. frame_grid(project, F, seconds=[4.2, 9.35]) donne des moments choisis en taille réelle, comme la fin d'un whip.

result = frame_grid(project, F)

Les images correspondent à un rendu de la même image, vérifié sur 21.2. Sur un Resolve plus ancien sans ExportThumbnails, cela génère une erreur, jugez donc à partir du rendu.

6. Rendre et mesurer le mouvement.

result = start_render(project, F, 'mon_film')    # choisit un encodeur H.264 GPU quand il y en a un
# dans les appels suivants : result = wait_render(project, result_job_id, 50)

Prévoyez environ 2 à 4 minutes pour 30 s en 1080p60 sur un GPU puissant. Ensuite, supprimez uniquement votre propre travail avec remove_job. La file d'attente peut contenir les travaux de l'utilisateur. start_render modifie les paramètres de rendu du projet, prévenez-en l'utilisateur.

Le mouvement ne peut être mesuré qu'à partir de la vidéo. Exécutez holds.py et dyn.py depuis les scripts de scenario-kinetic-film sur le rendu, s'ils sont installés. Les objectifs sont 40 % d'images fixes ou moins, pas de maintien supérieur à 0,6 s avant la carte de fin, et un mouvement médian de 2,5 ou plus. Rapportez les chiffres, y compris les échecs.

Pour changer quelque chose, corrigez-le et reconstruisez avec setup(..., replace=True), uniquement sur une timeline construite par cette compétence, puis répétez les étapes 4 à 6. Pour une correction sur quelques plans, rebuild_shots(project, F, [8.2, 13]) remplace uniquement les compositings des plans à ces instants (en secondes), ou par index de plan, et conserve tout le reste. Si les mots du film ont changé, relancez l'étape 3.

7. Terminer. Laissez la sauvegarde à l'utilisateur sauf s'il le demande : sauvegarder valide également toutes les autres modifications non sauvegardées qu'il a ouvertes. Rapportez le nom de la timeline, les notes, le temps de rendu et les chiffres de révision. Mentionnez que le clip de substitution doit rester dans son dossier, sinon les plans peuvent s'afficher comme hors ligne.

Ce qu'il ne faut pas faire, et pourquoi

Chacun de ces points coûte un temps réel à trouver. Les détails sont dans references/fusion-traps.md ; lisez-le avant de modifier fusion_lib.py ou si quelque chose ne va pas.

• Ne verrouillez pas un compositing pendant sa construction. Le clip s'affiche alors en noir. Verrouillez uniquement autour de la création du Loader, comme le fait Shot.loader ; sinon, définir le clip du Loader ouvre un sélecteur de fichier modal sur l'écran de l'utilisateur qui stoppe tout script.
• N'utilisez pas ExportCurrentFrameAsStill pour la révision. Il dépasse Fusion et renvoie des images noires ou périmées. frame_grid, qui utilise Timeline.ExportFrame et ExportThumbnails, est fiable, mais uniquement sur la timeline courante : une timeline qui n'a pas été ouverte exporte des images noires tout en signalant un succès.
• N'empilez pas le flou de mouvement. Le flou sur le déplacement d'un mot et sur la caméra multiplie le travail. Seule la caméra floute, et uniquement pendant les mouvements rapides.
• Ne supposez pas qu'un encodeur plus rapide résout un rendu lent. La génération d'images par Fusion est généralement la limite. Mesurez avant de modifier les paramètres.

Référence

• references/block-map.md : comment chacun des 14 blocs se convertit et ce qui est approximé. Lisez-le si un film utilise Graph, Counters, Progress, Chain, Prompt, Notes ou Rewind, ou si l'utilisateur demande à quel point un plan sera proche.
• references/fusion-traps.md : comportement de l'API découvert à la dure, et comment récupérer un Resolve bloqué.