Communitygithub.com

smooth-video (synchronisation de rythme)

Fait en sorte qu'une vidéo IA assemblée soit fluide en synchronisant le rythme : chaque image est une image réelle ou une interpolation par flux optique, jamais une image sautée ou répétée.

Qu'est-ce que smooth-video (synchronisation de rythme) ?

Ce skill résout le problème courant des vidéos générées par IA (Seedance, Kling, Luma, etc.) qui présentent des saccades, des images figées ou des sauts lors de l'assemblage ou du remplacement de segments dans un film. Il utilise une approche de synchronisation de rythme : chaque image de sortie est soit une image source, soit une interpolation par flux optique calculée exactement au moment nécessaire, garantissant un mouvement continu sans répétition ni saut. Le skill propose une série d'outils Python (dans le dossier `scripts/`) qui nécessitent `opencv-python`, `numpy` et `ffmpeg`. Les étapes incluent la mesure de la fluidité des clips source, l'application de la synchronisation de rythme (avec ou sans référence), l'assemblage des parties dans un film ou une vidéo unique, et une vérification finale par rapport à une référence. Il prend en charge deux moteurs de flux optique : OpenCV DIS (par défaut, rapide, sans GPU) et RIFE (plus net pour les mouvements rapides, nécessite un binaire externe). Le skill est conçu pour être utilisé dans des workflows d'édition vidéo AI où la précision du nombre d'images et la fluidité sont critiques.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ido6/smooth-video/tree/HEAD/smooth-video

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Vidéo fluide (synchronisation de rythme)

Les outils vidéo IA renvoient rarement la durée qu'on leur a donnée, et ils ajoutent leurs propres figes (une image qui diffère à peine de la précédente). Adapter un clip à un emplacement en prenant l'image la plus proche saute alors certaines images et en répète d'autres : c'est la saccade. La synchronisation de rythme fait plutôt ceci : chaque image de sortie est soit une image source, soit une interpolation par flux optique dessinée exactement au moment nécessaire, et, lorsque le clip remplace une partie d'un film, chronométrée pour bouger exactement comme la partie qu'elle remplace.

Outils : scripts/ à côté de ce fichier. Ils nécessitent Python avec opencv-python + numpy, et ffmpeg dans le PATH. Chaque script écrit un nouveau fichier ; la vidéo source reste intacte.

Étapes

  1. Mesurer. Exécutez python scripts/check_smooth.py <clip> sur chaque clip concerné, et sur le film (--ref l'original s'il y en a un). Il compare les images en égalisant la luminosité et le contraste, de sorte qu'un changement de lumière (un scintillement de film sur le plateau, une lampe, un changement d'étalonnage) soit listé sous changements de lumière, pas sous sauts : ceux-ci sont intentionnels, pas des saccades. Quand il affiche VERDICT already smooth, il n'y a rien à synchroniser : dites-le et passez l'étape 2 pour ce clip. Terminé quand vous connaissez, pour chaque partie : son nombre d'images par rapport à la durée qu'elle doit remplir, où sont ses coupures, et ses images figées.
  2. Synchroniser le rythme de chaque partie. Choisissez la branche :
    • Remplace une partie d'un film (la partie originale existe) : découpez exactement cette durée du film (ffmpeg -ss <début> -t <durée>, ré-encodé pour que les images soient exactes), puis python scripts/pace_match.py --edit <partie_ia> --ref <durée_originale> --out <partie_synchronisée>. Les plans et les coupures sont appariés automatiquement ; lorsque le nombre de coupures diffère, passez --shots ref_de-ref_à:clip_de-clip_à,....
    • Un clip sans référence (assemblage de clips IA bruts, ou un clip saccadé) : python scripts/pace_match.py --edit <clip> --out <clip_synchronisé> supprime les figes et ré-espaces uniformément le clip sur sa propre durée, ou sur --frames N. Un clip sans figes est recopié tel quel (--force le redessine de toute façon). Il ne peut pas reconstruire les images que l'IA a sautées ; un saut persistant nécessite --ref ou RIFE/Topaz. Le son suit automatiquement (--audio-from choisit un autre fichier, --no-audio le supprime), complété ou tronqué pour correspondre exactement au nombre d'images ; le script s'arrête si le nombre d'images écrit diffère. Terminé quand chaque partie synchronisée affiche exactement le nombre d'images de sa durée, plan par plan, avec chaque coupure sur la même image que l'original.
    • Couper juste avant qu'un événement ne se produise (« couper avant que le popcorn ne saute ») : python scripts/find_moment.py <clip> --roi x,y,w,h --de <s> --à <s> --out planche.jpg. --roi est la zone à surveiller, en fractions de l'image. Il affiche le changement local de chaque image avec la lumière égalisée et la dérive de la caméra soustraite, classe les événements probables, et écrit une planche contact avec le temps et le numéro de chaque image. Regardez la planche : la coupure se fait sur la dernière image avant que la chose ne commence à bouger, souvent une ou deux images avant celle classée première. Ensuite ffmpeg -i <clip> -frames:v <N> ... -af apad -t <N/images_par_seconde> (ré-encodé ; jamais -shortest). Vérifiez l'image de l'événement sur chaque version séparément : une finalisation en 1080p peut démarrer l'événement une ou deux images plus tôt que son brouillon en 480p.
  3. Assembler.
    • Parties dans un film : python scripts/splice_parts.py --film <film> --out <film_v2> --part <début_s>:<fin_s>:<partie_synchronisée> .... Il harmonise les couleurs de chaque plan avec celui qu'il remplace, conserve l'audio du film et chaque image, et refuse une partie dont le nombre d'images ne correspond pas.
    • Clips en une seule vidéo : d'abord mettez tous les clips à la même taille et fréquence d'images, puis joignez-les avec ffmpeg -f concat ou le filtre concat, en ré-encodant. Terminé quand le nouveau fichier a le nombre total d'images attendu (ffprobe -count_frames).
  4. Vérifier par rapport à la référence. Exécutez python scripts/check_smooth.py <nouveau> --ref <original> --ranges <chaque durée éditée>, et la même chose sur l'original (sans --ref) pour ses propres comptes. Terminé quand, dans chaque durée éditée qui a du mouvement :
    • les images figées sont au plus égales au compte de la référence (une pose maintenue est figée aussi dans la référence) ;
    • les sauts ne dépassent pas ceux de la référence ;
    • « suit la référence » est de 0,85 ou plus là où le sujet bouge. Une durée où seule la caméra dérive (un plan vide, un zoom lent) ou avec un mouvement inférieur à environ 2, obtient un score « suit » plus faible car l'IA redessine la dérive à main levée ; jugez à l'œil, les images figées et les sauts restent au plus au niveau de la référence. Montrez ensuite à l'utilisateur une comparaison côte à côte, et une version au ralenti des durées éditées (setpts=2*PTS), avant de déclarer le travail terminé.

Pièges (observés sur des exécutions réelles)

  • Le montage vidéo Seedance modifie la durée. Une entrée de 3 s est revenue à 4,04 s (ralentie 1,35×) ; une entrée de 6 s est revenue à 5,7 s. Ses sorties avaient aussi 1 à 3 figes propres. Envoyez des entrées de 4 s ou plus qui commencent et finissent sur des coupures. Ne faites jamais confiance à la durée retournée : synchronisez le rythme à chaque fois.
  • Remplacez des plans entiers. Échanger des images éditées en plein milieu d'un plan montre un saut là où l'original et l'édition se rencontrent. Coupez chaque partie de coupure à coupure.
  • Une piste audio plus courte que la vidéo fait que ffmpeg -shortest supprime les dernières images (une coupure de 95 images est sortie à 93). splice_parts.py et pace_match.py conservent chaque image ; lorsque vous remuxez à la main, utilisez -af apad -t <images/images_par_seconde> au lieu de -shortest.
  • Les changements de lumière ne sont pas des saccades. Un scintillement de lampe de film, une lampe ou un changement d'étalonnage étaient auparavant lus comme des « sauts ». Les vérifications égalisent désormais d'abord la luminosité et listent ceux-ci comme des changements de lumière ; jugez uniquement les sauts restants.
  • Liens d'actifs Higgsfield (higgsfield.ai/asset/all/<id>) : l'id est l'identifiant du job de génération ; lisez son result_url avec le connecteur Higgsfield jobs_wait et téléchargez-le.
  • Couleur : harmonisez par plan et repartez à zéro à chaque coupure, de sorte que l'étalonnage d'un plan ne déborde jamais sur le suivant.

Moteurs

  • Flux optique DIS OpenCV (par défaut, --engine opencv) : choisi comme moteur par défaut après un test côte à côte. Il est aussi fluide que RIFE, déjà installé, aucun GPU nécessaire.
  • RIFE (--engine rife --rife <rife-ncnn-vulkan.exe> --gpu 1) : environ 10% plus net lors de mouvements rapides comme des zooms brusques, mais environ 2,5 s par image. Il nécessite rife-ncnn-vulkan (github.com/nihui/rife-ncnn-vulkan, environ 430 Mo), qui n'est pas conservé installé : demandez avant de le télécharger à nouveau. Choisissez l'index du GPU discret avec --gpu (sur un portable, souvent 1 ; 0 est généralement la puce intégrée).
  • Toujours pas assez fluide : Topaz Video AI (Apollo ou Chronos) exécuté sur les clips IA bruts. L'utilisateur l'exécute ; préparez les clips et les nombres d'images exacts pour lui.

Skills associés