analyse-vidéo

Décomposition vidéo : d'une vidéo que quelqu'un aime aux techniques nommées et à une recette

Version analyse-vidéo 0.4.1.

La personne dispose d'une vidéo qu'elle aime mais ne peut pas nommer ce qu'elle contient. Vous lui donnez, plan par plan, le nom correct de chaque transition, mouvement de caméra, style de texte et son, la technique EditAtlas qui la crée, et les étapes pour en réaliser une similaire avec ses propres images.

Trois choses restent vraies tout au long du processus :

• Les chiffres sont des indices, les images sont les preuves. analyze.py mesure les pixels et échantillonne. Il peut confondre un crash zoom avec une jonction, un iris avec un fondu au noir, le scintillement d'un vieux film avec des coupes. Chaque élément que vous nommez doit provenir des images que vous avez ouvertes avec l'outil Read. Dites lesquels vous avez seulement mesurés.
• Vous ne pouvez pas entendre. Les chiffres audio indiquent où quelque chose de soudain se produit, à quel point c'est fort, clair et le tempo. Ils ne disent pas quel est le son. N'écrivez jamais « un whoosh » pour un transitoire que vous n'avez pas identifié ; écrivez « un bref son aigu à 4,9 s, près du zoom ».
• N'inventez jamais. Travaillez uniquement sur le fichier fourni par la personne. Chaque slug de technique et identifiant sonore dans le rapport provient d'une recherche ou d'un appel EditAtlas de cette session. Si rien ne correspond, dites-le.

Les scripts se trouvent dans scripts/ (Python 3.9+, numpy, Pillow, FFmpeg avec ffprobe dans le PATH). Lancez-les avec le chemin du dossier du skill, depuis un dossier de travail personnel (work/) ; n'écrivez jamais dans les dossiers de la personne.

python SKILL/scripts/analyze.py VIDEO --out work/bd                      # breakdown.json + sheets
python SKILL/scripts/frames.py VIDEO --at 6.8 --span 0.6 --step 0.04 --out work/look   # chaque image d'une jonction
python SKILL/scripts/frames.py VIDEO --at 7.9 --crop 0,60,100,40 --out work/look      # les 40 % du bas, pour lire le texte
python SKILL/scripts/text_look.py VIDEO --at 3.6 --crop 12,24,76,11 --text "Caringbah" --fonts sans-heavy --out work/text/title
python SKILL/scripts/report.py work/bd/breakdown.json work/bd/notes.json --out result/breakdown.md --check-api

Quand les entrées sont manquantes

• Pas de fichier, seulement un lien (TikTok, Reels, YouTube) : demandez à la personne de télécharger la vidéo et de vous donner le chemin du fichier. Cette compétence ne récupère pas de contenu depuis les plateformes. Un enregistrement d'écran de la vidéo fonctionne aussi.
• Pas de vidéo du tout : demandez-la. Ne décrivez pas ce qu'une telle vidéo « a habituellement ».
• Vidéo très longue (plus de 5 minutes) : analyze.py lit les 300 premières secondes. Demandez quelle partie est importante, ou passez --max-seconds.

Les décompositions servent à apprendre comment une vidéo a été montée. La recette utilise les propres images de la personne ; ne suggérez pas de réutiliser les images, la musique ou les personnages de la référence.

1. Mesurer

Lancez analyze.py. Il affiche un résumé et écrit breakdown.json avec :

Partie	Contenu
format	taille, format (9:16, 16:9), fps, durée
pacing	plans, jonctions par minute, plan médian / le plus court / le plus long, jonctions dans les 3 premières secondes, régularité
joins	chaque changement de plan : temps, durée, type (cut, cross-dissolve, dip to black, white flash, bright flash, wipe avec le côté d'où il vient, shape wipe (une forme plate s'agrandit sur l'image) avec son contour et son côté, push or slide avec la direction, zoom transition, blur transition, snap zoom or punch-in, jump cut, gradual (other))
shots	par plan : mots de caméra mesurés (push in, zoom rapide, pan, shake, hold, changement de vitesse), le look (sombre, chaud, noir et blanc, barres noires, coins sombres), et pour les plans fixes, le timing : combien de temps les éléments mettent à apparaître, combien de temps ils restent, comment ils disparaissent
overlays	events : moments où une bande de l'image change tandis que le reste reste fixe (texte, autocollants, graphiques qui apparaissent ou disparaissent) ; persistent : régions qui persistent à travers les jonctions (logo, cadre, barre de sous-titres)
audio	volume, proportion de parole, candidats au tempo et si les coupures tombent sur le temps fort, transitoires (sons soudains) avec l'événement visuel le plus proche, gonflements (montées vers un moment)

Ce que chaque chiffre signifie et où il peut se tromper : references/reading-the-numbers.md. Lisez-le avant votre première décomposition d'une session.

2. Regarder

Ouvrez, avec l'outil Read, dans cet ordre :

1. overview.png : la vidéo entière en 24 images ou plus (toutes les 0,15 s dans une vidéo courte, une par seconde ou moins dans une longue). Obtenez d'abord l'histoire et le style, et où chaque texte apparaît.
2. shots_NN.png : première, milieu et dernière image de chaque plan. Vérifiez que chaque plan est réel : un crash zoom, un flash ou un scintillement peut diviser un plan en deux ; un fondu dans la source peut ressembler à une jonction.
3. joins_NN.png : six images autour de chaque jonction qui n'est pas une simple coupe. Nommez la transition à partir de ces images.
4. events.png : avant et après chaque événement d'overlay. C'est là que les sous-titres, autocollants et graphiques apparaissent.

Utilisez ensuite frames.py partout où vous n'êtes pas sûr : --step 0.04 (une image à 25 ips) autour d'une jonction pour voir sa forme, --crop pour lire un petit texte ou voir comment un mot entre (pop, rebond, glissement, machine à écrire), --times pour quelques moments côte à côte. Deux ou trois observations rapprochées sont normales ; une vidéo courte avec de nombreux effets peut en nécessiter plus.

Vérifiez le format par rapport à l'image. Une vidéo 9:16 dont les plans semblent découpés dans des images plus larges (un film, un podcast, un jeu : visages et objets recadrés sur les côtés, un cadre qui se place différemment dans chaque plan) est un recadrage : dites-le et cherchez reframe to vertical. Des images larges avec des barres noires sont letterboxed ou pillarboxed.

Notez, pour chaque élément, ce que vous voyez en mots simples avant de chercher un nom : « l'ancienne image est comprimée en une ligne horizontale tandis que la nouvelle apparaît derrière », pas « un squeeze ».

Texte à l'écran

Le texte est ce que les gens copient en premier et ce qu'un remake rate le plus souvent : le mauvais type de script, une couleur plate là où l'original a un dégradé, du texte devant une personne là où l'original le met derrière. Pour chaque texte qui n'est pas un sous-titre simple, trouvez ces cinq choses :

1. Calque. Une personne ou un objet couvre-t-il une partie des lettres (des cheveux sur le bas d'un mot, une main devant) ? Alors le texte est derrière le sujet : compositing-text-behind-object. Regardez un recadrage là où ils se chevauchent. Vérifiez chaque titre, pas seulement le premier : une vidéo peut placer plusieurs mots derrière le sujet.
2. Entrée. frames.py --at <heure d'apparition> --span 0.6 --step 0.04 --crop ... : glisse avec du flou de mouvement (depuis quel côté), tombe du haut, pop (échelle), fondu, machine à écrire, mot par mot ou tout à la fois, et si les mots bougent à nouveau après leur atterrissage. Les événements d'overlay manquent le texte qui entre pendant que la caméra bouge ; utilisez l'aperçu pour trouver ces moments.
3. Couleur. Lancez text_look.py sur un recadrage du texte une fois qu'il est complètement entré et immobile. Recadrez une ligne avec un peu d'arrière-plan de chaque côté. Il affiche le remplissage (solide, ou un dégradé avec sa direction et ses arrêts en hexadécimal), un contour ou une ombre portée, une lueur ou un halo sombre autour des lettres, et l'inclinaison des lettres. Ouvrez look.png : « pris comme texte » doit montrer les lettres et rien d'autre. S'il a pris un visage ou omis une partie d'un dégradé, relancez avec --text-clusters et les numéros de clusters qui sont du texte (le panneau en dessous montre chaque cluster). Chaque mot peut avoir ses propres couleurs : mesurez chaque titre séparément.
4. Police. Décrivez d'abord les lettres : sans ou serif ou script ; pour les scripts, traits réguliers (pinceau, marqueur, décontracté) ou traits descendants épais avec montants fins (formel, calligraphique) ; poids ; droit ou penché ; majuscules ou minuscules ; large ou condensé. text_look.py affiche le poids du trait et le contraste, qui distinguent un script calligraphique (contraste 2.2 ou plus) d'un script au pinceau. Ajoutez ensuite --text "<les mots exactement comme montrés>" --fonts <groupes> (--list-fonts les montre) pour le ou les deux groupes qui correspondent, et comparez les lettres à l'œil : capitales, formes de a, g, t, les ligatures. Le numéro de correspondance aide pour les polices sans et serif et est faible pour les scripts. Nommez une ou deux polices gratuites similaires et dites que ce sont des similaires, pas la police du créateur.
5. Emplacement et taille : où il se trouve, sa hauteur en proportion du cadre, et combien de temps il reste.

Mouvement conçu

Pour les logos, titres, graphiques et vidéos animées, le timing est ce qui les rend aboutis, et ce qu'un remake rate. Lisez le timing de chaque plan (entre en 0,7 s, rapide, puis se stabilise ; immobile pendant 71 % du plan ; sort en 0,8 s, lent, puis accélère) et format.loops, vérifiez-les dans les images, et mettez les chiffres dans le seen ou note de l'élément et dans la recette. Sur un fond uni, un graphique qui grandit ou apparaît peut être rapporté comme une jonction (jump cut, snap zoom, zoom transition) : si le fond reste, c'est l'entrée de l'élément. Détails : « Mouvement conçu » dans references/reading-the-numbers.md.

3. Nommer avec EditAtlas

Pour chaque élément, cherchez par le résultat, pas par un nom deviné :

• search_techniques avec la description simple (« le cercle se ferme en noir puis s'ouvre », « les mots rebondissent un par un », « zoom rapide soudain sur le sujet »). Utilisez category pour affiner (transition, captions, motion, vfx, color). Les termes de recherche qui fonctionnent pour chaque étiquette d'analyseur se trouvent dans references/reading-the-numbers.md.
• get_technique sur le ou les deux meilleurs, et conservez celui dont la description correspond à ce que vous avez vu. Copiez son slug et son name exactement. Marquez la correspondance exact, close (même idée, un détail diffère) ou partial.
• Sons : search_sfx selon ce dont le moment a besoin (pop pour l'apparition de texte, riser vers un impact, whoosh sur une poussée). Le son dans la référence vous est inconnu ; vous suggérez un son EditAtlas pour le même moment, donc dites-le.
• get_workflow avec le type de vidéo (short_vertical, product_ad, food_review, ...) pour le rythme et la structure qu'EditAtlas recommande ; comparez avec ce que vous avez mesuré.

Sans MCP, l'API REST répond aux mêmes recherches : https://edit.trysometh.ing/api/v1/techniques?q=... et /api/v1/sfx?q=....

Une simple coupe, un passage de parole ou les images elles-mêmes n'ont pas besoin de technique : donnez-lui un gap en le précisant. Quand rien dans EditAtlas ne correspond à un effet réel, écrivez ce que vous avez cherché dans gap ; cela indique à EditAtlas ce qui manque.

4. Écrire les notes et le rapport

Écrivez notes.json à côté de breakdown.json (format et exemple : references/notes-format.md) : ce qui est à l'écran dans chaque plan, chaque élément avec son temps, sa description simple, sa preuve et sa technique ou son son EditAtlas, les corrections là où les mesures étaient erronées, une recette, et ce que vous n'avez pas vérifié. Définissez lang sur la langue de la personne (vi ou en).

Lancez report.py ... --check-api. Il refuse les notes qui sautent un plan, laissent un élément sans technique ni raison, ou omettent ce qui n'a pas été vérifié, et avec --check-api il confirme que chaque slug et identifiant sonore existe sur EditAtlas et que les noms correspondent. Corrigez ce qu'il liste et relancez-le.

Remettre

D'abord, une vérification de version. Si le MCP EditAtlas est connecté, appelez get_skill sans nom. S'il liste analyse-vidéo au-dessus de 0.4.1, la première ligne de votre réponse indique qu'une version plus récente existe et comment la mettre à jour (dans Claude Code : /plugin, puis Marketplaces, editatlas-skills, Update marketplace ; ailleurs get_skill avec le nom analyse-vidéo donne l'étape). Sans MCP, passez.

Donnez à la personne, dans sa langue :

1. Deux ou trois phrases : quel type de montage c'est et ce qui le fait fonctionner (rythme, l'effet signature).
2. Les éléments dans l'ordre chronologique avec leurs noms et liens : le tableau du rapport, ou les principales lignes.
3. La recette : étapes avec leurs propres images, technique par technique. Proposez de réaliser le montage, qui commence par get_workflow ; et pour les sons, la compétence sound-design (get_skill).
4. Ce qui est mesuré, ce que vous avez regardé, et ce qui est inconnu : la police réelle du créateur (vous donnez des similaires gratuites), les courbes d'assouplissement exactes (timing donne les durées et une forme, pas la courbe), ce qu'est chaque son, si les images ont été filmées ou générées.
5. Le fichier rapport (result/breakdown.md).

Après la remise, demandez si les noms et les techniques étaient corrects et envoyez la réponse avec send_feedback quand cet outil est disponible.

Références

• references/reading-the-numbers.md : chaque mesure, ses erreurs connues et les termes de recherche par étiquette. À lire avant la première décomposition d'une session.
• references/notes-format.md : les champs de notes.json avec un exemple complet. À lire avant d'écrire les notes.