Script macOS en un clic pour convertir des fichiers MP4 en animations en boucle de type GIF WebP

Pour le développement d'applications et de projets clients, j'ai souvent besoin de visualiser rapidement le contenu vidéo:

• prévisualiser les animations pour les chefs de produit
• extraits de démonstration pour la documentation ou les PRD
• Animations légères pour les publications sur les réseaux sociaux ou les pages de destination

Dans ces cas, extraire quelques images clés d'un fichier MP4 et les transformer en une animation WebP en boucle Cela suffit généralement, et c'est beaucoup plus léger que de télécharger une vidéo complète.

Cet article partage un Script shell en un clic pour macOS que:

• extrait 6 à 12 images régulièrement espacées d'un fichier MP4
• les redimensionne à une largeur de 720 px
• crée une animation WebP en boucle
• et s'installe automatiquement ffmpeg s'il manque

Tout cela s'exécute à partir d'une seule commande dans le Terminal.

1. Ce que fait le script

Sur macOS, le script extraire_les_images_pairs_webp.sh fournit :

1. Automatique ffmpeg détection et installation
   • Vérifie si ffmpeg est disponible
   • Sinon, installe Homebrew (si nécessaire) puis installe ffmpeg
2. Extraction de trames même
   • Calcule la durée de la vidéo
   • Échantillons uniformes 6 à 12 images sur l'ensemble du clip
   • La valeur par défaut est de 6 images, mais vous pouvez personnaliser ce nombre.
3. génération d'animations WebP
   • Combine les images PNG extraites en un WebP en boucle
   • La largeur de sortie est 720px par défaut (la hauteur est proportionnelle)
   • La qualité est ajustable via -q:v
4. Nettoyage automatique
   • Stocke les trames intermédiaires dans un répertoire temporaire
   • Supprime le répertoire temporaire après la génération du fichier WebP
5. Fonctionne avec les vidéos courtes et longues
   • Si la vidéo est très courte, le nombre d'images est automatiquement réduit.
   • Pour les vidéos plus longues, les images sont toujours espacées uniformément sur toute la durée.

2. Son fonctionnement interne

Voici la logique de base du script.

2.1 Vérifier les dépendances

Le script vérifie d'abord si ffmpeg est installé :

• Utilisations commande -v ffmpeg
• S'il n'est pas trouvé, il vérifie si brasser
  • Si Homebrew est absent, il installe Homebrew
  • Ensuite, utilise brew installer ffmpeg installer ffmpeg

2.2 Récupérer la durée de la vidéo

En utilisant sonde ff, le script lit le durée totale de la vidéo en secondes.
En se basant sur ces données et sur le nombre d'images souhaité, il calcule l'intervalle de temps entre les images.

2.3 Échantillonnage uniforme des images

Pour chaque index d'image, il :

• Calcule l'horodatage = index × intervalle
• Utilisations ffmpeg -ss pour passer à cette position temporelle
• Extrait exactement une image
• Il le met à l'échelle avec échelle=720:-1 La largeur est donc de 720 px et la hauteur est proportionnelle.

2.4 Créer l'animation WebP

Une fois toutes les images enregistrées au format PNG, le script appelle ffmpeg à nouveau à :

• Lisez-les dans l'ordre (%03d.png)
• Encodez-les en tant que WebP animé
• Ensemble -boucle 0 L'animation se répète donc indéfiniment.
• Contrôler la qualité avec -q:v 70 (plus bas = meilleure qualité, fichier plus volumineux)

2.5 Nettoyage

Tous les fichiers PNG intermédiaires sont stockés dans un répertoire temporaire créé par mktemp -d.
Une fois le fichier WebP généré, ce répertoire est supprimé avec rm -rf.

3. Script shell complet : extract_even_frames_webp.sh

Vous pouvez enregistrer le script suivant sous extraire_les_images_pairs_webp.sh sur votre 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. Comment utiliser le script sur macOS

1. Enregistrer le script Enregistrez le contenu ci-dessus sous extraire_les_images_pairs_webp.sh, par exemple dans votre répertoire personnel.
2. Accordez-lui l'autorisation d'exécution

chmod +x extract_even_frames_webp.sh

3. Utilisation de base

./extract_even_frames_webp.sh input.mp4 output.webp

Cela permettra de :

• Vérifier ou installer ffmpeg
• Extraire 6 cadres régulièrement espacés
• Générer output.webp à une largeur de 720 px

4. Spécifiez le nombre d'images (6–12)

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

Cela extraira 8 images au lieu des 6 par défaut.

5. Pourquoi ce flux de travail est utile

Comparé à l'ouverture manuelle d'un éditeur vidéo ou à la navigation dans un convertisseur graphique, ce script présente quelques avantages :

1. Aucune configuration manuelle
   • Installation automatique ffmpeg (et brasser soi-même si nécessaire)
   • Plus besoin de chercher des installateurs ni de se souvenir des commandes.
2. Échantillonnage intelligent des images
   • Pour les clips courts, le nombre d'images est automatiquement réduit.
   • Pour les vidéos plus longues, les images sont toujours espacées uniformément sur toute la durée.
3. Contrôle de la qualité et de la taille
   • -q:v permet d'ajuster la qualité WebP en fonction de la taille du fichier
   • échelle=720:-1 offre une largeur adaptée au web et un rapport hauteur/largeur constant
4. Boucle par défaut
   • -boucle 0 fait boucler l'animation WebP indéfiniment
   • Idéal pour les aperçus, les démos et les animations subtiles sur les documents ou les sites web.
5. Utilisation propre du disque
   • Les images PNG temporaires sont stockées dans un dossier temporaire et supprimées ensuite.
   • Aucun fichier résiduel ne s'accumule au fil du temps.

6. Exemple : convertir un fichier MP4 de 20 secondes en aperçu WebP

Imaginez que vous ayez un Vidéo de démonstration de 20 secondes et courir :

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

Le script va :

• Calculez un intervalle d'environ 3,33 secondes
• Extraire 6 images à 0 s, 3,33 s, 6,66 s, 10 s, 13,33 s, 16,66 s
• Redimensionnez-les à une largeur de 720 px
• Construire un WebP en boucle animation

Vous pouvez ensuite déposer ce fichier WebP dans :

• Documents produits ou documents Feishu / Notion en tant que aperçu léger
• Publications sur les réseaux sociaux ou pages de destination en tant que vignette animée à lecture automatique
• Présentations PowerPoint et démonstrations internes où une vidéo complète serait superflue.

7. Idées d'extension

Ce script est un point de départ ; vous pouvez facilement l’adapter à votre propre flux de travail :

1. Nombre d'images dynamiques
   • Sélection automatique entre 6 et 12 images en fonction de la durée de la vidéo
   • Par exemple, davantage d'images pour les clips plus longs afin de montrer plus d'états.
2. Tailles personnalisées
   • Changement échelle=720:-1 à la largeur que votre équipe produit préfère
   • Ou exposer la largeur comme paramètre : ./script.sh in.mp4 out.webp 8 1080
3. Traitement par lots
   • Intégrez ce script dans une autre boucle pour traiter tout. .mp4 fichiers dans un dossier
   • Utile lorsque vous exportez simultanément un lot de démonstrations de fonctionnalités.

Note de l'auteur

Ce script est issu de mon flux de travail de développement macOS réel, qui consiste à convertir des vidéos MP4 en aperçus WebP légers. Je l'utilise quotidiennement pour générer des animations de démonstration pour la documentation et les publications sur les réseaux sociaux. GPT a uniquement servi à traduire, structurer et peaufiner la version anglaise de cet article ; la logique du script, les détails d'implémentation et les exemples d'utilisation proviennent de mon expérience personnelle.

À propos de l'auteur

qinshengping

Je suis Sam Qin, développeur client et mobile spécialisé dans la création d'expériences utilisateur fluides et stables sur les plateformes applicatives et front-end. Je travaille sur l'optimisation des performances, la réduction des plantages et la simplification et la rapidité des fonctionnalités complexes pour les utilisateurs. Dans Knowledge Hub, je partage des notes de débogage, des bonnes pratiques d'architecture côté client et des conseils éprouvés issus de projets concrets, notamment sur l'utilisation des outils et de l'IA pour des mises à jour plus performantes et moins imprévues.

Voir les articles de l'auteur