Communitygithub.com

smooth-video

Faça com que vídeos de IA unidos sejam reproduzidos suavemente com correspondência de ritmo: cada quadro é um quadro real ou um quadro intermediário de fluxo óptico, nunca um quadro pulado ou repetido.

O que é smooth-video?

Esta skill resolve o problema comum de vídeos gerados por IA (Seedance, Kling, Luma, v2v) que, ao serem inseridos em um filme ou combinados entre si, apresentam travamentos, quadros congelados, saltos ou repetições. A técnica central é o 'pace-match' (correspondência de ritmo), que garante que cada quadro de saída seja um quadro fonte real ou um quadro intermediário calculado por fluxo óptico, eliminando quadros pulados ou repetidos. A skill oferece um conjunto de scripts em Python (que dependem de opencv-python, numpy e ffmpeg) para medir a suavidade de clipes, ajustar o ritmo de cada parte individualmente (com ou sem referência de um filme original), e depois unir as partes em um filme ou em um único vídeo. Ela também inclui uma ferramenta para encontrar o momento exato de um evento (como um objeto começando a se mover) para realizar cortes precisos. A verificação final compara o novo vídeo com a referência original, garantindo que as taxas de quadros congelados e saltos estejam dentro dos limites da referência. Suporta os motores de fluxo óptico OpenCV DIS (padrão, sem necessidade de GPU) e RIFE (mais nítido, mas mais lento e requer download adicional), e pode ser combinada com o Topaz Video AI para casos extremos.

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

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Vídeo suave (pace-match)

Ferramentas de vídeo com IA raramente retornam a duração que receberam e adicionam travamentos (um quadro que mal difere do anterior) próprios. Ajustar um clipe a um espaço selecionando o quadro mais próximo pula alguns quadros e repete outros: isso é a gagueira. Pace-match faz o oposto: cada quadro de saída é um quadro fonte ou um quadro intermediário de fluxo óptico desenhado no momento exato necessário e, quando o clipe substitui uma parte de um filme, sincronizado para se mover exatamente como a parte que substitui.

Ferramentas: scripts/ ao lado deste arquivo. Elas precisam de Python com opencv-python + numpy e ffmpeg no PATH. Cada script escreve um novo arquivo; o vídeo fonte permanece intacto.

Passos

  1. Medir. Execute python scripts/check_smooth.py <clipe> em cada clipe envolvido e no filme (--ref o original quando houver um). Ele compara os quadros com brilho e contraste equalizados, para que uma mudança de luz (uma lâmpada piscando no set, um abajur, uma mudança de grade) seja listada sob mudanças de luz, não como saltos: estas são intencionais, não gagueira. Quando imprimir VERDICT already smooth, não há nada para fazer o pace-match: diga isso e pule o passo 2 para aquele clipe. Concluído quando você souber, para cada parte: sua contagem de quadros versus o espaço que deve preencher, onde estão seus cortes e seus quadros congelados.
  2. Fazer pace-match em cada parte. Escolha o ramo:
    • Substitui uma parte de um filme (a parte original existe): corte exatamente esse trecho do filme (ffmpeg -ss <inicio> -t <duracao>, reencodificado para que os quadros sejam exatos), depois python scripts/pace_match.py --edit <parte_ia> --ref <trecho_original> --out <parte_ajustada>. Os planos e cortes são emparelhados automaticamente; quando as contagens de cortes diferirem, passe --shots ref_de-ref_para:clip_de-clip_para,....
    • Um clipe sem referência (unindo clipes de IA brutos ou um clipe com gagueira): python scripts/pace_match.py --edit <clipe> --out <clipe_ajustado> remove os travamentos e o redistribui uniformemente em seu próprio comprimento, ou para --frames N. Um clipe sem travamentos é copiado inalterado (--force o redesenha de qualquer forma). Ele não pode reconstruir quadros que a IA pulou; um salto que permanece precisa de --ref ou RIFE/Topaz. O som vem automaticamente (--audio-from pega outro arquivo, --no-audio o descarta), preenchido ou cortado para a contagem exata de quadros; o script para se a contagem de quadros escrita for diferente. Concluído quando cada parte ajustada imprime exatamente a contagem de quadros do seu espaço, plano por plano, com cada corte no mesmo quadro do original.
    • Cortar antes de algo acontecer ("cortar antes da pipoca pular"): python scripts/find_moment.py <clipe> --roi x,y,w,h --from <s> --to <s> --out sheet.jpg. --roi é a área a ser observada, como frações do quadro. Ele imprime a mudança local de cada quadro com a luz equalizada e a deriva da câmera subtraída, classifica os eventos prováveis e escreve uma folha de contato com o tempo e o número de cada quadro. Olhe a folha: o corte vai no último quadro antes da coisa começar a se mover, geralmente um ou dois quadros antes do melhor classificado. Depois ffmpeg -i <clipe> -frames:v <N> ... -af apad -t <N/fps> (reencodificado; nunca -shortest). Verifique o quadro do evento em cada versão separadamente: uma finalização em 1080p pode iniciar o evento um ou dois quadros antes do que seu rascunho em 480p.
  3. Montar tudo.
    • Partes em um filme: python scripts/splice_parts.py --film <filme> --out <filme_v2> --part <inicio_s>:<fim_s>:<parte_ajustada> .... Ele ajusta as cores de cada plano ao que substitui, mantém o áudio do filme e todos os quadros, e recusa uma parte cuja contagem de quadros não corresponda.
    • Clipe em um vídeo: primeiro faça todos os clipes terem o mesmo tamanho e fps, depois junte-os com ffmpeg -f concat ou o filtro concat, reencodificando. Concluído quando o novo arquivo tiver a contagem total de quadros esperada (ffprobe -count_frames).
  4. Verificar contra a referência. Execute python scripts/check_smooth.py <novo> --ref <original> --ranges <cada trecho editado>, e o mesmo no original (sem --ref) para suas próprias contagens. Concluído quando, em cada trecho editado que tem movimento:
    • quadros congelados estão no máximo na contagem da referência (uma pose mantida está congelada também na referência);
    • saltos não são maiores que os da referência;
    • "segue ref" é 0,85 ou mais onde o sujeito se move. Um trecho onde apenas a câmera deriva (um plano vazio, um zoom lento e suave), ou com movimento abaixo de cerca de 2, pontua menos em "segue" porque a IA redesenha a deriva da câmera; julgue visualmente, quadros congelados e saltos ainda no máximo os da referência. Em seguida, mostre ao usuário uma comparação lado a lado e uma versão em câmera lenta dos trechos editados (setpts=2*PTS), antes de declarar concluído.

Pegadinhas (vistas em execuções reais)

  • Seedance video edit altera a duração. Uma entrada de 3 s retornou 4,04 s (desacelerada 1,35×); uma entrada de 6 s retornou 5,7 s. Suas saídas também tiveram 1 a 3 travamentos próprios. Envie entradas de 4 s ou mais que comecem e terminem em cortes. Nunca confie na duração retornada: faça pace-match toda vez.
  • Substitua planos inteiros. Trocar quadros editados no meio de um plano mostra um salto onde o original e a edição se encontram. Corte cada parte de corte a corte.
  • Uma faixa de áudio mais curta que o vídeo faz com que ffmpeg -shortest descarte os últimos quadros (um corte de 95 quadros saiu com 93). splice_parts.py e pace_match.py mantêm todos os quadros; ao remuxar manualmente, use -af apad -t <quadros/fps> em vez de -shortest.
  • Mudanças de luz não são gagueira. Uma oscilação de luz de filme, um abajur ou uma mudança de grade costumavam ser lidos como 'saltos'. As verificações agora equalizam primeiro o brilho e listam essas como mudanças de luz; julgue apenas os saltos restantes.
  • Links de ativos do Higgsfield (higgsfield.ai/asset/all/<id>): o id é o id do job de geração; leia seu result_url com o conector Higgsfield jobs_wait e faça o download.
  • Cor: combine por plano e comece do zero em cada corte, para que a correção de cor de um plano nunca se infiltre no próximo.

Motores

  • Fluxo óptico OpenCV DIS (padrão, --engine opencv): escolhido como padrão após um teste lado a lado. É tão suave quanto RIFE, já instalado, sem necessidade de GPU.
  • RIFE (--engine rife --rife <rife-ncnn-vulkan.exe> --gpu 1): cerca de 10% mais nítido durante movimentos rápidos, como zoom de crash, mas cerca de 2,5 s por quadro. Precisa de rife-ncnn-vulkan (github.com/nihui/rife-ncnn-vulkan, cerca de 430 MB), que não é mantido instalado: pergunte antes de baixá-lo novamente. Escolha o índice da GPU discreta com --gpu (em um laptop, geralmente 1; 0 geralmente é o chip integrado).
  • Ainda não está suave o suficiente: Topaz Video AI (Apollo ou Chronos) executado nos clipes de IA brutos. O usuário o executa; prepare os clipes e as contagens exatas de quadros para eles.

Habilidades Relacionadas