Script para macOS com um clique para transformar MP4 em animações em loop no estilo WebP GIF.

Para trabalhos de desenvolvimento de aplicativos e para clientes, muitas vezes preciso de visualizar conteúdo de vídeo rapidamente:

• Pré-visualização de animações para gerentes de produto
• Clipes de demonstração para documentos ou PRDs
• Animações leves para posts em redes sociais ou páginas de destino.

Nesses casos, Extraindo alguns quadros-chave de um arquivo MP4 e transformando-os em uma animação WebP em loop. Geralmente é suficiente — e muito mais leve do que enviar um vídeo completo.

Este artigo compartilha um Script de shell de um clique para macOS que:

• Extrai de 6 a 12 quadros uniformemente espaçados de um arquivo MP4.
• redimensiona-os para 720px de largura.
• Cria uma animação WebP em loop.
• e instala automaticamente ffmpeg se estiver faltando

Tudo isso é executado a partir de um único comando no Terminal.

1. O que o roteiro faz

No macOS, o script extrair_quadros_pares_webp.sh fornece:

1. Automático ffmpeg detecção e instalação
   • Verifica se ffmpeg está disponível
   • Caso contrário, instale o Homebrew (se necessário) e depois instale o ffmpeg
2. Extração de quadros uniforme
   • Calcula a duração do vídeo.
   • Amostras uniformes 6–12 quadros ao longo de todo o clipe
   • O padrão é de 6 quadros, mas você pode personalizar o número.
3. Geração de animação WebP
   • Combina os quadros PNG extraídos em um WebP em loop
   • A largura de saída é 720px Por padrão (a altura é dimensionada proporcionalmente)
   • A qualidade é ajustável através de -q:v
4. Limpeza automática
   • Armazena quadros intermediários em um diretório temporário.
   • Exclui o diretório temporário após a geração do WebP.
5. Funciona tanto com vídeos curtos quanto longos.
   • Se o vídeo for muito curto, a contagem de quadros é reduzida automaticamente.
   • Em vídeos mais longos, os frames são sempre espaçados uniformemente ao longo de toda a duração.

2. Como funciona por baixo do capô

Eis a lógica básica por trás do script.

2.1 Verificar dependências

O script primeiro verifica se ffmpeg está instalado:

• Usos comando -v ffmpeg
• Caso não seja encontrado, verifica se... cerveja
  • Se o Homebrew estiver faltando, ele o instala.
  • Em seguida, usa brew install ffmpeg para instalar ffmpeg

2.2 Recuperar a duração do vídeo

Usando ffprobe, o roteiro lê o duração total do vídeo em segundos.
Com base nisso e na quantidade de quadros desejada, calcula o intervalo de tempo entre os quadros.

2.3 Amostrar uniformemente os quadros

Para cada índice de quadro, ele:

• Calcula o carimbo de data/hora = índice × intervalo
• Usos ffmpeg -ss para saltar para essa posição temporal
• Extrai exatamente um quadro.
• Dimensiona-o com escala=720:-1 Portanto, a largura é de 720px e a altura é proporcional.

2.4 Criar a animação WebP

Assim que todos os frames forem salvos como PNGs, o script chama ffmpeg novamente para:

• Leia-os em ordem (%03d.png)
• Codifique-os como um WebP animado.
• Definir -loop 0 assim a animação se repete indefinidamente
• Controle a qualidade com -q:v 70 (menor = maior qualidade, arquivo maior)

2.5 Limpeza

Todos os arquivos PNG intermediários são armazenados em um diretório temporário criado por mktemp -d.
Após a geração do WebP, esse diretório é removido com rm -rf.

3. Script shell completo: extract_even_frames_webp.sh

Você pode salvar o seguinte script como extrair_quadros_pares_webp.sh No seu Mac:

#!/bin/bash

# Usage: ./extract_even_frames_webp.sh input.mp4 output.webp [frames]
# frames is optional, default 6, maximum 12

INPUT="$1"
OUTPUT="$2"
FRAMES="${3:-6}"

# Cap maximum frames at 12
if [ "$FRAMES" -gt 12 ]; then
    FRAMES=12
fi

if [ -z "$INPUT" ] || [ -z "$OUTPUT" ]; then
    echo "Usage: $0 input.mp4 output.webp [frames]"
    exit 1
fi

# ---------------------------------
# 1️⃣ Check ffmpeg
# ---------------------------------
if ! command -v ffmpeg >/dev/null 2>&1; then
    echo "⚠️ ffmpeg not found, starting installation..."
    if ! command -v brew >/dev/null 2>&1; then
        echo "⚠️ Homebrew not found, installing Homebrew..."
        /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
        echo "✅ Homebrew installed"
    else
        echo "✅ Homebrew already installed"
    fi
    brew update
    brew install ffmpeg
    if ! command -v ffmpeg >/dev/null 2>&1; then
        echo "❌ ffmpeg installation failed, please check manually"
        exit 1
    fi
    echo "🎉 ffmpeg installed successfully!"
else
    echo "✅ ffmpeg is already installed"
fi

# ---------------------------------
# 2️⃣ Get video duration
# ---------------------------------
DURATION=$(ffprobe -v error -show_entries format=duration -of csv=p=0 "$INPUT")
if [[ -z "$DURATION" ]]; then
    echo "❌ Failed to get video duration"
    exit 1
fi
DURATION=${DURATION%.*}  # integer seconds

# If video is shorter than requested frames, match frame count to duration
if [ "$DURATION" -lt "$FRAMES" ]; then
    FRAMES=$DURATION
fi

echo "📹 Video length: ${DURATION}s, extracting $FRAMES frames evenly"

# ---------------------------------
# 3️⃣ Create temporary directory
# ---------------------------------
TMPDIR=$(mktemp -d)

# ---------------------------------
# 4️⃣ Calculate interval
# ---------------------------------
INTERVAL=$(echo "scale=6; $DURATION/$FRAMES" | bc)
echo "⏱ Frame interval: $INTERVAL seconds"

# ---------------------------------
# 5️⃣ Extract frames
# ---------------------------------
for i in $(seq 0 $(($FRAMES-1))); do
    TIME=$(echo "$i * $INTERVAL" | bc)
    printf -v FILENAME "%03d.png" $((i+1))
    ffmpeg -ss "$TIME" -i "$INPUT" -frames:v 1 -vf "scale=720:-1" \
        "$TMPDIR/$FILENAME" -hide_banner -loglevel error
done

# ---------------------------------
# 6️⃣ Generate animated WebP
# ---------------------------------
ffmpeg -y -i "$TMPDIR/%03d.png" -vcodec libwebp -lossless 0 -q:v 70 \
    -loop 0 -preset picture "$OUTPUT" -hide_banner -loglevel error

# ---------------------------------
# 7️⃣ Clean up
# ---------------------------------
rm -rf "$TMPDIR"

echo "🎉 Done! Generated file: $OUTPUT"

4. Como usar o script no macOS

1. Salve o script Salve o conteúdo acima como extrair_quadros_pares_webp.sh, por exemplo, no seu diretório pessoal.
2. Conceda permissão de execução.

chmod +x extract_even_frames_webp.sh

3. Uso básico

./extract_even_frames_webp.sh input.mp4 output.webp

Isto irá:

• Verifique ou instale ffmpeg
• Extraia 6 quadros com espaçamento uniforme.
• Gerar saída.webp com 720px de largura

4. Especifique o número de quadros (6–12)

./extract_even_frames_webp.sh input.mp4 output.webp 8

Isso extrairá 8 quadros em vez dos 6 padrão.

5. Por que esse fluxo de trabalho é útil

Comparado com a abertura manual de um editor de vídeo ou o uso de um conversor com interface gráfica, este script apresenta algumas vantagens:

1. Configuração manual zero
   • Instala-se automaticamente ffmpeg (e cerveja caseira, se necessário)
   • Não precisa procurar instaladores nem memorizar comandos.
2. Amostragem de quadros inteligentes
   • Para vídeos curtos, ele reduz automaticamente a contagem de quadros.
   • Em vídeos mais longos, os frames são sempre espaçados uniformemente ao longo da duração.
3. Controle de qualidade e tamanho
   • -q:v Permite ajustar a qualidade do WebP em relação ao tamanho do arquivo.
   • escala=720:-1 Oferece uma largura adequada para a web e uma proporção consistente.
4. Repetição por padrão
   • -loop 0 faz com que a animação WebP entre em loop infinito.
   • Ideal para pré-visualizações, demonstrações e animações sutis em documentos ou sites.
5. Limpeza do uso do disco
   • Os frames PNG temporários são armazenados em uma pasta temporária e excluídos posteriormente.
   • Sem acúmulo de arquivos residuais ao longo do tempo.

6. Exemplo: converter um MP4 de 20 segundos em uma pré-visualização WebP.

Imagine que você tem um Vídeo de demonstração do recurso com 20 segundos de duração e executar:

./extract_even_frames_webp.sh demo.mp4 demo-preview.webp 6

O roteiro irá:

• Calcule um intervalo de aproximadamente 3,33 segundos
• Extraia 6 quadros em 0s, 3,33s, 6,66s, 10s, 13,33s, 16,66s
• Redimensione-os para 720px de largura.
• Construa um WebP em loop animação

Em seguida, você pode inserir este WebP em:

• Documentos de produto ou documentos Feishu/Notion como um pré-visualização leve
• Postagens em redes sociais ou páginas de destino como um miniatura de movimento com reprodução automática
• Apresentações em PowerPoint e demonstrações internas onde um vídeo completo seria excessivo.

7. Ideias para extensão

Este script é um ponto de partida — você pode facilmente adaptá-lo ao seu próprio fluxo de trabalho:

1. Contagem de quadros dinâmica
   • Seleção automática entre 6 e 12 quadros com base na duração do vídeo.
   • Por exemplo, mais frames para clipes mais longos para mostrar mais estados.
2. Tamanhos personalizados
   • Mudar escala=720:-1 para qualquer largura que sua equipe de produto preferir.
   • Ou exponha a largura como um parâmetro: ./script.sh in.mp4 out.webp 8 1080
3. Processamento em lote
   • Envolva este script em outro loop para processar tudo. .mp4 arquivos em uma pasta
   • Útil quando você exporta um lote de demonstrações de recursos de uma só vez.

Nota do autor

Este script faz parte do meu fluxo de trabalho real de desenvolvimento para macOS, que consiste em converter vídeos MP4 em pré-visualizações WebP leves. Eu o utilizo diariamente no desenvolvimento de projetos para clientes, gerando animações de demonstração para documentação e publicações em redes sociais. O GPT foi usado apenas para auxiliar na tradução, estruturação e aprimoramento da versão em inglês deste artigo — a lógica do script, os detalhes de implementação e os padrões de uso são todos baseados na minha própria experiência em projetos.

Sobre o autor

qinshengping

Sou Sam Qin, desenvolvedor de aplicativos e dispositivos móveis, focado em criar experiências fluidas e estáveis em plataformas de aplicativos e front-end. Trabalho com otimização de desempenho, redução de travamentos e em tornar recursos complexos simples e rápidos para usuários reais. No Knowledge Hub, compartilho notas de depuração, práticas de arquitetura do lado do cliente e dicas testadas e aprovadas em projetos reais, incluindo como utilizo ferramentas e IA para lançar versões melhores com menos surpresas.

Veja as publicações do autor