nandinishukla/talking-head-short

Talking-head → courte 9:16 terminée

Le pipeline prend un enregistrement brut (plus un fichier audio propre optionnel) pour produire edit/final.mp4 (1080×1920, 60 ips, H.264 + AAC 48 kHz). Il écrit également quatre pistes de longueur totale et un rapport. Tout se passe en code, installé localement dans le projet : ffmpeg, Python, Node et HyperFrames. Pas d'installations système ni d'applications de montage.

• La norme : references/brief.md est le cahier des charges complet, avec tous les nombres pour les niveaux, la géométrie, le timing, le type et la couleur. Si ce fichier et le brief ne sont pas d'accord sur un nombre, le brief gagne.
• À lire avant de commencer : references/lessons.md couvre les pièges qui coûtent des heures lors de la première exécution.
• Profil sonore : references/sound-profile.md contient le style et les niveaux des effets sonores du créateur, mesurés à partir de son propre montage.
• Bibliothèque de mouvements : references/motion-library.md contient les références de mouvements choisies par l'utilisateur, le look maison que les graphiques suivent.
• Exemples : references/examples/ contient les graphiques de la première courte (r1–r9 plus cta). references/example-report.md est un rapport terminé.

Posez d'abord les questions de style à la personne qui monte (étape 0b), puis travaillez de manière autonome à part une seule pause délibérée : l'approbation du storyboard à l'étape 7. Entre ces deux points, ne demandez rien à l'utilisateur : prenez chaque décision (choix de prise, mise en page, désaccord factuel, interface utilisateur inaccessible), continuez, et notez-la pour le rapport. L'approbation du storyboard est le seul moment où vous attendez l'utilisateur. Arrêtez-vous uniquement si les fichiers d'entrée sont manquants ou illisibles.

Structure d'un projet

<projet>/RAW.MP4 (+ audio propre si présent)
<projet>/edit/
  project.json        # toutes les décisions par vidéo (prises, séquences, sous-titres, couverture…)
  tools/              # bin/ffmpeg, bin/ffprobe, venv/, node_modules/ (setup.sh)
  work/               # tous les intermédiaires (gfx/ est le projet HyperFrames)
  stems/  final.mp4  final_master.wav  REPORT.md

Tous les scripts s'exécutent depuis edit/ avec export PATH="$PWD/tools/bin:$PATH" et PY=tools/venv/bin/python. $S ci-dessous est le dossier scripts/ de ce skill.

Étapes

0. Configuration et sondage

bash $S/setup.sh <projet>. Ensuite ffprobe -show_streams le fichier caméra et notez :

• la taille et la rotation (les sources portrait arrivent souvent en paysage avec un drapeau −90°) ;
• les ips ;
• le format audio.

Décodez une fois en un intermédiaire orienté. Ne re-décodez pas la 4K à chaque étape : ffmpeg -i RAW.MP4 -an -vf scale=1080:-2 -c:v libx264 -crf 13 -g 15 work/cam1080.mp4 Utilisez scale=-2:1080 pour une source paysage. Exécutez les longues commandes en arrière-plan : environ 6 min pour 90 s de 4K sur un Mac 8 Go.

0b. Questions de style (demander une fois, avant tout travail)

Demandez à la personne qui monte la vidéo, en UNE série de questions (utilisez l'outil de question si disponible), pour les choix que seul elle peut faire. Ignorez tout ce qu'elle a déjà donné, et enregistrez les réponses dans project.json → "intake" :

1. Sous-titres : le petit style quotidien, "small_style": "pill" (calme, vidéos générales) ou "mono" (machine à écrire, vidéos tech/AI/dev) ; plus si utiliser des moments héros (accroche et lignes clés avec seulement eux à l'écran).
2. Couleur d'accent : du sujet (la couleur de marque du produit principal ; vous la recherchez), assortie à leurs vêtements, ou un hex qu'ils nomment → "accent".
3. CTA : "cta_style": "box" ou "pill", le mot-clé du commentaire, et le texte du chip de lien pour la pilule (ex. "Gratuit sur GitHub · owner/repo").
4. Musique : "music": {"mode": "synth" | "file" | "none"} (+ le chemin du fichier).
5. Titre de couverture : le leur, ou écrit à partir de l'accroche.

Proposez des valeurs par défaut sensées dans les options (par exemple la couleur de marque du sujet ; pill + héros pour les vidéos générales, mono + héros pour les vidéos tech ; l'autre style de CTA de leur dernière vidéo), pour que répondre prenne quelques secondes. Si personne ne peut répondre (exécution non supervisée), utilisez ces valeurs par défaut et mentionnez-le dans le rapport.

1. Synchronisation et transcription

1. $PY $S/analyze_audio.py <caméra> [audio_propre] effectue une corrélation croisée à 16 kHz et rapporte le décalage et le rapport de pic. Il écrit la source vocale sur la timeline de la caméra, l'enveloppe RMS de 10 ms, le nombre d'échantillons écrêtés et le plancher de bruit. Sans fichier propre, il utilise la piste de la caméra et vous devez le dire dans le rapport.
2. $PY $S/transcribe.py medium.en "Noms de produits, personnes, @handles" liste chaque mot avec les écarts de plus de 250 ms signalés.
3. Ré-exécutez analyze_audio.py pour que la liste des étirements silencieux montre les mots voisins.
4. Regroupez les mots en prises par ligne. Pour chaque ligne, conservez la dernière prise complète. Utilisez une précédente uniquement si la dernière a un défaut audible (bégaiement, écrêtage ou mot incorrect, redémarrage). Supprimez les redémarrages, les auto-corrections, "okay", les syllabes errantes et les marmonnements après les prises, ainsi que le silence mort aux deux extrémités.

2. Le montage

Écrivez project.json → "lines": [[étiquette, début_src, fin_src], …] avec des bords approximatifs autour de chaque prise conservée, dans l'ordre de livraison. Les lignes contiguës peuvent partager une seule plage. Ensuite :

1. $PY $S/cut.py gère les attaques/vraies fins (−35 dB / −32 dB pendant 150 ms), les pauses de plus de 250 ms → 120 ms, une avance de 40 ms, une avance de J-cut audio de 50 ms, les queues qui s'estompent dans l'écart, les coupes image quantifiées par trame et FIN.
2. $PY $S/check_joins.py : toute jointure avec un étirement silencieux de plus de 150 ms reçoit un "gap_overrides": {"<segment>": -0.0333} négatif. Ré-exécutez cut.py. N'ajoutez jamais de silence.

3. Contact visuel

Créez un petit proxy (scale=-2:540), puis $PY $S/eyesheet.py work/proxy.mp4 et regardez work/eye/*.jpg. Ajoutez des pas de 100 ms autour de tout mouvement de tête. La caméra n'est montrée que lorsque le locuteur est en face de l'objectif. Si ils regardent ailleurs au milieu d'une ligne, divisez à la frontière du mot avant le mouvement et faites du reste un visuel complet.

4. Planifier les séquences (avant tout graphique)

$PY $S/plan.py affiche les temps de coupe image. Écrivez "runs": [[début_ms, fin_ms, mise_en_page, "R1 accroche"], …] en couvrant [0, END] (utilisez "END" pour la dernière fin), puis ré-exécutez-le. Il valide les règles :

• l'accroche est une division et l'outro (à partir du CTA) est en caméra pleine ;
• aucune séquence ne dépasse environ 8 s et les voisines ne partagent jamais une mise en page ;
• les trois mises en page sont utilisées.

Choisissez les mises en page par contenu :

• opinions et histoires directes à la caméra → cam ;
• une capture d'écran, carte, rangée de logos ou courte liste → split ;
• enregistrements d'écran, pages d'actualités, UI produit nécessitant un zoom → visuel.

Placez les limites sur les coupes image. plan.py affiche ensuite les mots de chaque séquence avec les temps relatifs à la séquence ; synchronisez les graphiques à ces temps.

5. Recherche et captures

Pour chaque produit nommé et chaque affirmation (sortie, citation, nombre), trouvez la source réelle et vérifiez les chiffres auprès de deux sources ou plus réputées. Notez tout désaccord pour le rapport.

• Capturez les pages réelles avec node $S/shot.mjs <url> <out.png> 1280 1400 0, exécuté depuis edit/. Il trouve lui-même chrome-headless-shell d'HyperFrames. Respectez les robots.txt et conditions de chaque site : capturez les pages que vous citez, ne parcourez pas.
• Les dépôts incluent souvent un GIF UI ou des captures d'écran dans docs/ ; reconstruisez l'UI à partir de ceux-ci.
• Une UI derrière un mur de connexion est reconstruite à partir de captures d'écran publiques ou de docs et notée dans le rapport.
• "Claude Code" signifie l'interface de l'application de bureau Claude sauf si le locuteur parle du terminal.

6. Sous-titres et couverture (planifiés maintenant, car le storyboard les montre)

$PY $S/captions.py work/cam1080.mp4 (la vidéo caméra est pour la couleur héros). Réglez "small_style": "mono" pour les vidéos tech / AI-outil / développeur / explainer produit (tout ce qui a des terminaux, du code ou des écrans d'application), ou "pill" pour les vidéos générales et lifestyle. Sans "captions.chunks" il imprime un brouillon automatique (le style petit partout, un héros rédigé dans l'accroche). Modifiez-le et collez-le. Il existe trois styles :

• mono [a, b, "mono", [mot_accent]] : 1–3 mots, une machine à écrire de terminal. En majuscules VT323 sur une boîte presque noire qui grandit à mesure que les lettres tapent (30 lettres/s), un mot-clé significatif sur un bloc d'accent solide, et un curseur de bloc d'accent (stable pendant la frappe, clignotant après). assemble.py le tape image par image.
• pill [a, b, "pill"] : 1–3 mots, petit Poppins Bold sur une boîte ronde sombre translucide : le style petit plus calme pour les vidéos non tech.
• héros [a, b, "hero", [indices_grands_mots]] : 2–5 mots avec 1–2 TRÈS GROS mots solides (Archivo Black) entre des petits mots au-dessus et en dessous, qui suivent le style petit de la vidéo (pills, ou boîtes mono statiques). La couleur du grand mot correspond aux vêtements du locuteur : captions.py work/cam1080.mp4 échantillonne le torse dans la première image héros et imprime la couleur choisie. Il a un contour profond de même teinte pour se lire sur ces vêtements. Remplacez avec "hero_color": "#RRGGBB" si le choix est incorrect (impressions chargées, veste sur une chemise). Utilisez-le dans l'accroche et sur les lignes importantes où seul le locuteur est à l'écran (caméra pleine, ou la carte dans une division), jamais sur un graphique et jamais deux à la suite. Choisissez des mots qui portent le sens (l'affirmation, le nombre ou l'avantage), jamais des mots vides.

Définissez "cover": [ligne1, ligne2] (écrivez-le à partir de l'accroche si l'utilisateur n'en a donné aucun, environ 14 caractères par ligne à 110 px). Réglez le centre de la pilule par mise en page dans "y" et le centre du bloc héros dans "hero_y".

• Les sous-titres ne doivent jamais reposer sur le visage, le bord de la carte ou un visuel.
• Avec une source portrait, l'écart de division est le visage, donc placez les pills vers y 1660 sur le torse, et vérifiez l'outro sur une image réelle.
• assemble.py compose les deux styles.

7. Storyboard et tableau de rythmes : STOP pour approbation

Rien n'est rendu tant que l'utilisateur n'a pas vu et approuvé le plan.

1. Choisissez des références de mouvement pour chaque beat graphique à partir de references/motion-library.md (le look maison choisi par l'utilisateur). references/motion-prompts.md contient les textes complets des invites (crédités à leurs créateurs) ; lisez le bloc pour chaque id cité. Ne grattez jamais de galeries tierces. Les entrées de la bibliothèque ont été ajoutées par l'utilisateur, et certains sites, par exemple prompt-motion.com, bloquent les robots IA.
2. Choisissez la couleur d'accent de la vidéo à partir de ce qui est enseigné : la couleur de marque du produit principal (logo, bouton primaire), sinon une couleur qui convient au sujet. Écrivez "accent": {"color": "#RRGGBB", "why": "..."} et exécutez $PY $S/accent.py. Il écrit work/gfx/assets/accent.css (remplissage d'accent, une teinte de texte 4.5:1 et une teinte de bande claire), que chaque composition reprend via base.css. Ne codez jamais en dur les valeurs hex d'accent dans les compositions : utilisez var(--clay), var(--clayText) et var(--band). La couleur du sous-titre héros est séparée (elle vient des vêtements).
3. Écrivez "beats" dans project.json, un ou plusieurs par séquence : {"run": "R1", "t": 0.0, "visual": "...", "camera": "...", "sfx": "...", "refs": ["id"], "source": "capture réelle / UI reconstruite / logo"}. Ajoutez éventuellement "storyboard_notes": {"R1": "pourquoi cette mise en page"}.
4. $PY $S/storyboard.py work/cam1080.mp4 écrit work/storyboard.html : un croquis 9:16 par séquence (zones de mise en page, l'image du locuteur, le graphique, le style et la position des sous-titres) et le tableau de rythmes (temps, séquence, mise en page, mots exacts, action à l'écran, mouvement de caméra, SFX, style de sous-titres avec chaque moment héros, références de mouvement, source).
5. Montrez-le à l'utilisateur (la page montre l'échantillon d'accent et pourquoi il a été choisi) : publiez-le comme artefact, ou envoyez le fichier, et donnez une ligne sur quoi regarder. Ensuite terminez votre tour et attendez. Appliquez leurs modifications à project.json, regénérez, et montrez-le à nouveau. Continuez uniquement sur approbation claire.

8. Graphiques (HyperFrames)

1. Copiez assets/engine.js, assets/base.css, assets/accent.css, assets/fonts/ et assets/motion/ dans work/gfx/assets/ (puis ré-exécutez accent.py pour que l'accent par vidéo remplace le défaut), plus hyperframes.json de hyperframes init.
2. Écrivez un work/gfx/compositions/<clé de séquence en minuscules>.html par séquence split/visuel. Son data-duration doit être exactement égal à la séquence.
3. Construisez exactement ce que le storyboard approuvé montre, en faisant correspondre les références de mouvement de chaque beat. Commencez à partir de l'exemple le plus proche dans references/examples/ :
   • r1, r3, r5, r7 : mondes divisés avec pas et poussées ;
   • r2 : verrouillage du logo, puis un coup de fouet vers une capture réelle dans le cadre fixe sur son clone délavé ;
   • r4, r6, r9 : fenêtres produit où seule la caméra intérieure bouge ;
   • cta : la carte de commentaire transparente (style CTA A) ; cta_pill.html : la pilule de commentaire (style CTA B) ;
   • motion/*.html : une démo par composant de mouvement (curseur, verre, morphose, inondation + iris, soulèvement de masque, cinétique, mur, coup de fouet ; expliquer-flow, expliquer-callout, expliquer-status, expliquer-loop) ; voir "Composants de mouvement" et "Composants d'explication" ci-dessous.

Comment fonctionne le moteur et les règles qui comptent :

• E.run(id, dur, render) enregistre une timeline en pause. render(t) doit être une fonction pure de t.
• E.path donne les images clés de la caméra monde. E.camera les applique et floute le viewport en fonction de la vitesse à l'écran (σ = 0.29·v·0.75/60, ≤ 40 px, zéro au repos et à t = 0).
• E.track et E.land animent les propriétés par objet (opacité, x, y, échelle, flou). Profondeur de champ : voisins jusqu'à 14 px de flou et 70% d'opacité ; l'ancien héros 9 px et 40%.
• Mouvements de caméra :
  • glide : sine.inOut, changement d'échelle ≤ 0.04 ;
  • step : 0.5 s power3.inOut, commençant 0.25 s avant le mot qui nomme l'élément suivant ;
  • push : 1.2–2 s power2.inOut, jusqu'à environ 1.6× ;
  • pull back : 1–2 s ;
  • whip : au plus un par séquence, 0.45 s out power3.in, 0.6 s in power3.out.
• L'image 0 est l'état d'atterrissage, net, avec la caméra au repos.
• Pendant qu'une fenêtre produit est le sujet, seule la caméra à l'intérieur de la fenêtre bouge (1.15–1.4×, 0.4–0.7 s power2.inOut).
• Zones de contenu :
  • les divisions gardent le contenu dans y 40–900, et le monde s'estompe à partir de y 900 ;
  • les visuels gardent le contenu au-dessus de y 1230 ;
  • sur l'image 0, le graphique d'intro reste en dessous de y 620 (la couverture se trouve au-dessus).
• Style visuel :
  • un sujet clairsemé par scène ;
  • Poppins et rien en dessous de 30 px ;
  • sol radial presque blanc et ombre à trois couches ;
  • rien de sombre, pas de grille ;
  • animez l'action, ne la labellisez jamais.
• Chaque événement visible digne d'un son va dans le <script type="application/json" id="events"> de la composition (pop / click / chime / thud pour les icônes qui atterrissent / flash pour les flashs blancs / whoosh au point médian du whip / keys / ticks, relatifs à la séquence). L'étape audio les lit, donc les SFX atterrissent toujours sur leur …