Vidéo Midjourney vers Seamless Loop en utilisant FFmpeg - Script d'automatisation complet

Publié le - 18 juin 2025 par Andy Cinquin

FFmpegAnimation WebPTraitement vidéoAutomatisationScript Bash

Un script Bash automatique pour convertir des vidéos en fichiers WebP animés avec boucle fluide sur Fedora, intégré dans le menu contextuel de Nautilus.

✨ Fonctionnalités

Conversion automatique : Convertit n'importe quelle vidéo en WebP animé
Boucle fluide : Crée un effet de fondu entre la fin et le début pour des boucles parfaites
Menu contextuel : Accessible directement via clic droit sur les fichiers vidéo
Notifications : Affiche le progrès et les résultats via les notifications système
Nettoyage automatique : Supprime automatiquement les fichiers temporaires
Optimisation qualité : Paramètres équilibrés entre qualité et taille de fichier

🎯 Formats supportés

Entrée : MP4, AVI, MKV, MOV, WMV, FLV, WebM, 3GP, M4V Sortie : WebP animé (30fps, boucle infinie)

📋 Prérequis

Fedora Linux (testé sur Fedora 38+)
Environnement de bureau GNOME avec Nautilus
Accès sudo pour l'installation

🚀 Installation rapide

Créez les fichiers ci-dessous dans un dossier :

mkdir video-to-webp-converter
cd video-to-webp-converter

Copiez le contenu de chaque script (voir sections ci-dessous)
Rendez le script d'installation exécutable :
```
chmod +x install.sh
```
Lancez l'installation :
```
./install.sh
```

🎬 Utilisation

Via le menu contextuel (recommandé)

Ouvrez Nautilus (Fichiers)
Naviguez vers un dossier contenant des vidéos
Clic droit sur n'importe quel fichier vidéo
Sélectionnez "Convert to Animated WebP"
Attendez la fin de la conversion (notifications affichées)
Le fichier WebP sera créé avec le suffixe _loop.webp

Via la ligne de commande

video-to-webp.sh "chemin/vers/votre/video.mp4"

📁 SCRIPTS COMPLETS À CRÉER

1. 📝 Fichier : `video-to-webp.sh`

#!/bin/bash

# Script de conversion vidéo vers WebP animé en boucle
# Auteur : Assistant
# Usage : video-to-webp.sh "video_entree.mp4"

set -euo pipefail

# Configuration
FPS_INTERMEDIATE=24
FPS_OUTPUT=30
CRF=18
PRESET="veryfast"
FADE_DURATION=0.5
FADE_OFFSET=3.5

# Fonction pour afficher les notifications
notify_user() {
    local message="$1"
    local urgency="${2:-normal}"
    
    if command -v notify-send &> /dev/null; then
        notify-send -u "$urgency" "Vidéo vers WebP" "$message"
    fi
    echo "$message"
}

# Fonction pour nettoyer les fichiers temporaires
cleanup() {
    local temp_file="$1"
    if [[ -f "$temp_file" ]]; then
        rm -f "$temp_file"
    fi
}

# Fonction pour obtenir la durée de la vidéo
get_video_duration() {
    local input_file="$1"
    ffprobe -v quiet -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "$input_file" 2>/dev/null || echo "0"
}

# Fonction pour convertir la vidéo en WebP
convert_video_to_webp() {
    local input_file="$1"
    local base_name="${input_file%.*}"
    local output_file="${base_name}_loop.webp"
    local temp_cfr="${base_name}_tmp_cfr.mp4"
    local temp_loop="${base_name}_tmp_loop.mp4"
    
    # Valider le fichier d'entrée
    if [[ ! -f "$input_file" ]]; then
        notify_user "Erreur : Fichier d'entrée '$input_file' introuvable" "critical"
        return 1
    fi
    
    # Vérifier si ffmpeg est disponible
    if ! command -v ffmpeg &> /dev/null; then
        notify_user "Erreur : ffmpeg n'est pas installé. Installez-le avec : sudo dnf install ffmpeg" "critical"
        return 1
    fi
    
    # Obtenir la durée de la vidéo
    local duration
    duration=$(get_video_duration "$input_file")
    
    if (( $(echo "$duration < 1" | bc -l) )); then
        notify_user "Erreur : Impossible de déterminer la durée de la vidéo ou vidéo trop courte" "critical"
        return 1
    fi
    
    notify_user "Début de la conversion de '$input_file' vers WebP..."
    
    # Étape 1 : Convertir en framerate constant
    notify_user "Étape 1/3 : Conversion en framerate constant..."
    if ! ffmpeg -y -i "$input_file" \
        -r "$FPS_INTERMEDIATE" \
        -c:v libx264 \
        -crf "$CRF" \
        -preset "$PRESET" \
        -an \
        "$temp_cfr" 2>/dev/null; then
        notify_user "Erreur : Échec de la conversion en CFR" "critical"
        cleanup "$temp_cfr"
        return 1
    fi
    
    # Étape 2 : Créer une boucle fluide avec fondu croisé
    notify_user "Étape 2/3 : Création de la boucle fluide..."
    if ! ffmpeg -y -i "$temp_cfr" \
        -filter_complex \
        "[0:v]split=2[main1][main2]; \
         [main1]trim=end=1,setpts=PTS-STARTPTS,fps=$FPS_INTERMEDIATE[begin]; \
         [main2]trim=start=1,setpts=PTS-STARTPTS,fps=$FPS_INTERMEDIATE[end]; \
         [end][begin]xfade=transition=fade:duration=$FADE_DURATION:offset=$FADE_OFFSET,format=yuv420p[v]" \
        -map "[v]" \
        -c:v libx264 \
        -crf "$CRF" \
        -preset "$PRESET" \
        "$temp_loop" 2>/dev/null; then
        notify_user "Erreur : Échec de la création de la boucle" "critical"
        cleanup "$temp_cfr"
        cleanup "$temp_loop"
        return 1
    fi
    
    # Étape 3 : Convertir en WebP
    notify_user "Étape 3/3 : Conversion en WebP animé..."
    if ! ffmpeg -y -i "$temp_loop" \
        -vf "fps=$FPS_OUTPUT" \
        -loop 0 \
        -quality 80 \
        -method 6 \
        -lossless 0 \
        "$output_file" 2>/dev/null; then
        notify_user "Erreur : Échec de la conversion en WebP" "critical"
        cleanup "$temp_cfr"
        cleanup "$temp_loop"
        return 1
    fi
    
    # Nettoyer les fichiers temporaires
    cleanup "$temp_cfr"
    cleanup "$temp_loop"
    
    # Obtenir les tailles de fichier pour comparaison
    local input_size output_size
    input_size=$(du -h "$input_file" | cut -f1)
    output_size=$(du -h "$output_file" | cut -f1)
    
    notify_user "✅ Conversion terminée avec succès !
Entrée : $input_size → Sortie : $output_size
Sauvegardé sous : $(basename "$output_file")"
    
    # Ouvrir le gestionnaire de fichiers pour montrer le résultat
    if command -v nautilus &> /dev/null; then
        nautilus "$(dirname "$output_file")" &
    fi
}

# Exécution principale
main() {
    if [[ $# -eq 0 ]]; then
        echo "Usage : $0 <fichier_video_entree>"
        echo "Exemple : $0 'ma_video.mp4'"
        exit 1
    fi
    
    local input_file="$1"
    
    # Convertir en chemin absolu
    input_file=$(realpath "$input_file")
    
    # Démarrer la conversion
    convert_video_to_webp "$input_file"
}

# Piège de nettoyage à la sortie
trap 'cleanup "${base_name}_tmp_cfr.mp4" 2>/dev/null || true; cleanup "${base_name}_tmp_loop.mp4" 2>/dev/null || true' EXIT

# Exécuter la fonction principale
main "$@"

2. 🗂️ Fichier : `video-to-webp.desktop`

[Desktop Entry]
Type=Action
Icon=video-x-generic
Name[en]=Convert to Animated WebP
Name[fr]=Convertir en WebP animé
Tooltip[en]=Convert video to looping animated WebP
Tooltip[fr]=Convertir la vidéo en WebP animé en boucle
MimeType=video/mp4;video/avi;video/mkv;video/mov;video/wmv;video/flv;video/webm;video/3gp;video/m4v;video/x-msvideo;video/quicktime;
Profiles=profile-zero;

[X-Action-Profile profile-zero]
Exec=/usr/local/bin/video-to-webp.sh %f
Name[en]=Convert to Animated WebP Loop
Name[fr]=Convertir en WebP animé en boucle
Icon=video-x-generic
Description[en]=Convert selected video to an animated WebP with seamless loop
Description[fr]=Convertir la vidéo sélectionnée en WebP animé avec boucle fluide
MimeTypes=video/mp4;video/avi;video/mkv;video/mov;video/wmv;video/flv;video/webm;video/3gp;video/m4v;video/x-msvideo;video/quicktime;
SelectionCount==1

3. 🚀 Fichier : `install.sh`

#!/bin/bash

# Script d'installation pour le convertisseur Vidéo vers WebP
# Pour Fedora Linux avec le gestionnaire de fichiers Nautilus

set -euo pipefail

SCRIPT_NAME="video-to-webp.sh"
DESKTOP_FILE="video-to-webp.desktop"
INSTALL_DIR="/usr/local/bin"
NAUTILUS_ACTIONS_DIR="$HOME/.local/share/file-manager/actions"

# Couleurs pour la sortie
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # Pas de couleur

# Fonction pour afficher une sortie colorée
print_status() {
    local color=$1
    local message=$2
    echo -e "${color}${message}${NC}"
}

# Fonction pour vérifier si une commande existe
command_exists() {
    command -v "$1" >/dev/null 2>&1
}

# Fonction pour installer les dépendances
install_dependencies() {
    print_status "$BLUE" "🔍 Vérification des dépendances..."
    
    local missing_packages=()
    
    # Vérifier ffmpeg
    if ! command_exists ffmpeg; then
        missing_packages+=("ffmpeg")
    fi
    
    # Vérifier bc (pour les calculs flottants)
    if ! command_exists bc; then
        missing_packages+=("bc")
    fi
    
    # Vérifier notify-send
    if ! command_exists notify-send; then
        missing_packages+=("libnotify")
    fi
    
    if [[ ${#missing_packages[@]} -gt 0 ]]; then
        print_status "$YELLOW" "📦 Installation des paquets manquants : ${missing_packages[*]}"
        
        # Activer les dépôts RPM Fusion si ffmpeg est manquant
        if [[ " ${missing_packages[*]} " =~ " ffmpeg " ]]; then
            print_status "$BLUE" "🔧 Activation des dépôts RPM Fusion pour ffmpeg..."
            sudo dnf install -y \
                https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm \
                https://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm 2>/dev/null || true
        fi
        
        sudo dnf install -y "${missing_packages[@]}"
        print_status "$GREEN" "✅ Dépendances installées avec succès"
    else
        print_status "$GREEN" "✅ Toutes les dépendances sont déjà installées"
    fi
}

# Fonction pour installer le script principal
install_script() {
    print_status "$BLUE" "📝 Installation du script de conversion vidéo..."
    
    if [[ ! -f "$SCRIPT_NAME" ]]; then
        print_status "$RED" "❌ Erreur : $SCRIPT_NAME introuvable dans le répertoire courant"
        exit 1
    fi
    
    # Copier le script vers le répertoire système
    sudo cp "$SCRIPT_NAME" "$INSTALL_DIR/"
    sudo chmod +x "$INSTALL_DIR/$SCRIPT_NAME"
    
    print_status "$GREEN" "✅ Script installé dans $INSTALL_DIR/$SCRIPT_NAME"
}

# Fonction pour installer l'action Nautilus
install_nautilus_action() {
    print_status "$BLUE" "🗂️  Installation de l'action du menu contextuel Nautilus..."
    
    if [[ ! -f "$DESKTOP_FILE" ]]; then
        print_status "$RED" "❌ Erreur : $DESKTOP_FILE introuvable dans le répertoire courant"
        exit 1
    fi
    
    # Créer le répertoire actions s'il n'existe pas
    mkdir -p "$NAUTILUS_ACTIONS_DIR"
    
    # Copier le fichier desktop
    cp "$DESKTOP_FILE" "$NAUTILUS_ACTIONS_DIR/"
    
    print_status "$GREEN" "✅ Action Nautilus installée dans $NAUTILUS_ACTIONS_DIR/$DESKTOP_FILE"
}

# Fonction pour redémarrer Nautilus
restart_nautilus() {
    print_status "$BLUE" "🔄 Redémarrage de Nautilus pour appliquer les changements..."
    
    # Tuer tous les processus nautilus
    pkill -f nautilus 2>/dev/null || true
    
    # Attendre un moment
    sleep 2
    
    # Démarrer nautilus en arrière-plan
    nautilus &>/dev/null &
    
    print_status "$GREEN" "✅ Nautilus redémarré"
}

# Fonction pour créer une vidéo de test
create_test_video() {
    local test_file="test_animation.mp4"
    
    if [[ ! -f "$test_file" ]]; then
        print_status "$BLUE" "🎬 Création d'une vidéo de test pour la démonstration..."
        
        # Créer une animation de test simple avec ffmpeg
        ffmpeg -f lavfi -i "testsrc=duration=3:size=320x240:rate=30" \
               -f lavfi -i "sine=frequency=1000:duration=3" \
               -c:v libx264 -crf 23 -c:a aac \
               "$test_file" 2>/dev/null
        
        if [[ -f "$test_file" ]]; then
            print_status "$GREEN" "✅ Vidéo de test créée : $test_file"
        fi
    fi
}

# Fonction pour afficher les instructions d'utilisation
show_usage_instructions() {
    print_status "$GREEN" "🎉 Installation terminée avec succès !"
    echo
    print_status "$BLUE" "📋 Comment utiliser :"
    echo "1. Ouvrez Nautilus (Fichiers)"
    echo "2. Naviguez vers un dossier contenant des fichiers vidéo"
    echo "3. Clic droit sur n'importe quel fichier vidéo (.mp4, .avi, .mkv, etc.)"
    echo "4. Sélectionnez 'Convert to Animated WebP' dans le menu contextuel"
    echo "5. Attendez que la conversion se termine"
    echo "6. Le fichier WebP sera créé dans le même répertoire"
    echo
    print_status "$YELLOW" "💡 Conseils :"
    echo "• Le script crée des animations en boucle fluide"
    echo "• Les fichiers de sortie sont nommés avec le suffixe '_loop.webp'"
    echo "• Vous recevrez des notifications pendant le processus de conversion"
    echo "• Le gestionnaire de fichiers s'ouvrira automatiquement une fois terminé"
    echo
    print_status "$BLUE" "🔧 Utilisation manuelle :"
    echo "Vous pouvez aussi exécuter le script manuellement depuis le terminal :"
    echo "video-to-webp.sh 'chemin/vers/votre/video.mp4'"
}

# Processus d'installation principal
main() {
    print_status "$GREEN" "🚀 Démarrage de l'installation du Convertisseur Vidéo vers WebP sur Fedora"
    echo
    
    # Vérifier si on exécute en tant que root (on ne veut pas ça pour le script complet)
    if [[ $EUID -eq 0 ]]; then
        print_status "$RED" "❌ Veuillez ne pas exécuter ce script en tant que root. Il demandera sudo quand nécessaire."
        exit 1
    fi
    
    # Vérifier si on est sur Fedora
    if [[ ! -f /etc/fedora-release ]]; then
        print_status "$YELLOW" "⚠️  Attention : Ce script est conçu pour Fedora. Il peut fonctionner sur d'autres distributions basées sur RPM."
        read -p "Continuer quand même ? (y/N) : " -n 1 -r
        echo
        if [[ ! $REPLY =~ ^[Yy]$ ]]; then
            exit 0
        fi
    fi
    
    # Vérifier si Nautilus est disponible
    if ! command_exists nautilus; then
        print_status "$RED" "❌ Erreur : Gestionnaire de fichiers Nautilus introuvable. Ce script nécessite l'environnement de bureau GNOME."
        exit 1
    fi
    
    # Exécuter les étapes d'installation
    install_dependencies
    install_script
    install_nautilus_action
    restart_nautilus
    create_test_video
    show_usage_instructions
    
    print_status "$GREEN" "✨ Installation terminée ! Vous pouvez maintenant faire clic droit sur les fichiers vidéo pour les convertir en WebP !"
}

# Exécuter la fonction principale
main "$@"

4. 🧪 Fichier : `test.sh`

#!/bin/bash

# Script de test pour le convertisseur Vidéo vers WebP
# Crée une vidéo de test et la convertit pour vérifier l'installation

set -euo pipefail

# Couleurs pour la sortie
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'

print_status() {
    local color=$1
    local message=$2
    echo -e "${color}${message}${NC}"
}

# Fonction pour créer une vidéo de test
create_test_video() {
    local test_file="test_sample.mp4"
    
    print_status "$BLUE" "🎬 Création d'une vidéo de test..."
    
    # Créer un motif de test coloré avec superposition de texte
    ffmpeg -y \
        -f lavfi -i "testsrc2=duration=5:size=640x480:rate=30" \
        -f lavfi -i "sine=frequency=440:duration=5" \
        -vf "drawtext=text='Animation Test':x=(w-text_w)/2:y=(h-text_h)/2:fontsize=48:fontcolor=white:box=1:boxcolor=black@0.5" \
        -c:v libx264 -crf 23 -preset fast \
        -c:a aac -b:a 128k \
        "$test_file" 2>/dev/null
    
    if [[ -f "$test_file" ]]; then
        print_status "$GREEN" "✅ Vidéo de test créée : $test_file"
        return 0
    else
        print_status "$RED" "❌ Échec de la création de la vidéo de test"
        return 1
    fi
}

# Fonction pour tester le convertisseur
test_converter() {
    local test_file="test_sample.mp4"
    local expected_output="test_sample_loop.webp"
    
    print_status "$BLUE" "🔄 Test du convertisseur vidéo..."
    
    if [[ ! -f "$test_file" ]]; then
        print_status "$RED" "❌ Vidéo de test introuvable"
        return 1
    fi
    
    # Tester le script convertisseur
    if command -v video-to-webp.sh &>/dev/null; then
        print_status "$BLUE" "📝 Exécution du test de conversion..."
        
        if video-to-webp.sh "$test_file"; then
            if [[ -f "$expected_output" ]]; then
                local input_size output_size
                input_size=$(du -h "$test_file" | cut -f1)
                output_size=$(du -h "$expected_output" | cut -f1)
                
                print_status "$GREEN" "✅ Test de conversion réussi !"
                print_status "$GREEN" "   Entrée : $input_size → Sortie : $output_size"
                return 0
            else
                print_status "$RED" "❌ Fichier de sortie non créé"
                return 1
            fi
        else
            print_status "$RED" "❌ Échec de la conversion"
            return 1
        fi
    else
        print_status "$RED" "❌ Script video-to-webp.sh introuvable dans PATH"
        print_status "$YELLOW" "   Exécutez d'abord l'installateur : ./install.sh"
        return 1
    fi
}

# Fonction pour vérifier l'intégration Nautilus
check_nautilus_integration() {
    local action_file="$HOME/.local/share/file-manager/actions/video-to-webp.desktop"
    
    print_status "$BLUE" "🗂️  Vérification de l'intégration Nautilus..."
    
    if [[ -f "$action_file" ]]; then
        print_status "$GREEN" "✅ Fichier d'action Nautilus trouvé"
        
        # Vérifier si le fichier d'action est valide
        if grep -q "video-to-webp.sh" "$action_file"; then
            print_status "$GREEN" "✅ Le fichier d'action pointe vers le bon script"
        else
            print_status "$YELLOW" "⚠️  Le fichier d'action peut avoir un chemin incorrect"
        fi
        
        return 0
    else
        print_status "$RED" "❌ Fichier d'action Nautilus introuvable"
        print_status "$YELLOW" "   Attendu : $action_file"
        return 1
    fi
}

# Fonction pour vérifier les dépendances
check_dependencies() {
    print_status "$BLUE" "🔍 Vérification des dépendances..."
    
    local deps=("ffmpeg" "ffprobe" "bc" "notify-send")
    local missing=()
    
    for dep in "${deps[@]}"; do
        if command -v "$dep" &>/dev/null; then
            print_status "$GREEN" "✅ $dep trouvé"
        else
            print_status "$RED" "❌ $dep manquant"
            missing+=("$dep")
        fi
    done
    
    if [[ ${#missing[@]} -eq 0 ]]; then
        print_status "$GREEN" "✅ Toutes les dépendances satisfaites"
        return 0
    else
        print_status "$RED" "❌ Dépendances manquantes : ${missing[*]}"
        return 1
    fi
}

# Fonction pour nettoyer les fichiers de test
cleanup_test_files() {
    local files=("test_sample.mp4" "test_sample_loop.webp" "test_sample_tmp_cfr.mp4" "test_sample_tmp_loop.mp4")
    
    print_status "$BLUE" "🧹 Nettoyage des fichiers de test..."
    
    for file in "${files[@]}"; do
        if [[ -f "$file" ]]; then
            rm -f "$file"
            print_status "$GREEN" "   Supprimé : $file"
        fi
    done
}

# Fonction pour afficher les résultats des tests
show_test_results() {
    echo
    print_status "$BLUE" "📋 Résumé des tests :"
    echo "==================="
    
    if check_dependencies; then
        echo "✅ Dépendances : OK"
    else
        echo "❌ Dépendances : MANQUANTES"
    fi
    
    if check_nautilus_integration; then
        echo "✅ Intégration Nautilus : OK"
    else
        echo "❌ Intégration Nautilus : MANQUANTE"
    fi
    
    if command -v video-to-webp.sh &>/dev/null; then
        echo "✅ Installation du script : OK"
    else
        echo "❌ Installation du script : MANQUANTE"
    fi
    
    echo "==================="
}

# Fonction de test principale
main() {
    print_status "$GREEN" "🧪 Démarrage de la Suite de Tests du Convertisseur Vidéo vers WebP"
    echo
    
    # Vérifier si on doit nettoyer d'abord
    if [[ "${1:-}" == "--cleanup" ]]; then
        cleanup_test_files
        exit 0
    fi
    
    # Exécuter les vérifications
    local overall_success=true
    
    if ! check_dependencies; then
        overall_success=false
    fi
    
    if ! check_nautilus_integration; then
        overall_success=false
    fi
    
    # Exécuter le test de conversion seulement si les vérifications de base passent
    if [[ "$overall_success" == true ]]; then
        if create_test_video && test_converter; then
            print_status "$GREEN" "🎉 Tous les tests réussis ! Le convertisseur fonctionne correctement."
        else
            overall_success=false
        fi
    fi
    
    show_test_results
    
    # Option de nettoyage
    echo
    read -p "Nettoyer les fichiers de test ? (O/n) : " -n 1 -r
    echo
    if [[ $REPLY =~ ^[Oo]$|^$ ]]; then
        cleanup_test_files
    fi
    
    if [[ "$overall_success" == true ]]; then
        print_status "$GREEN" "✨ Installation vérifiée ! Vous pouvez maintenant utiliser le convertisseur."
        echo
        print_status "$BLUE" "💡 Comment utiliser :"
        echo "1. Ouvrez le gestionnaire de fichiers Nautilus"
        echo "2. Clic droit sur n'importe quel fichier vidéo"
        echo "3. Sélectionnez 'Convert to Animated WebP'"
        exit 0
    else
        print_status "$RED" "❌ Certains tests ont échoué. Veuillez vérifier l'installation."
        echo
        print_status "$YELLOW" "💡 Essayez de relancer l'installateur :"
        echo "./install.sh"
        exit 1
    fi
}

# Afficher l'aide si nécessaire
if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
    echo "Suite de Tests du Convertisseur Vidéo vers WebP"
    echo "Usage : $0 [--cleanup|--help]"
    echo
    echo "Options :"
    echo "  --cleanup   Supprimer les fichiers de test et quitter"
    echo "  --help      Afficher ce message d'aide"
    echo
    echo "Ce script teste l'installation du convertisseur video-to-webp."
    exit 0
fi

# Exécuter la fonction principale
main "$@"

📋 INSTRUCTIONS D'INSTALLATION

🚀 Installation en Une Fois :

# 1. Créer le dossier et tous les fichiers
mkdir video-to-webp-converter
cd video-to-webp-converter

# 2. Créer chaque fichier avec son contenu (copier-coller depuis ce README)
nano video-to-webp.sh          # Coller le contenu du script principal
nano video-to-webp.desktop     # Coller le contenu du fichier desktop
nano install.sh                # Coller le contenu du script d'installation
nano test.sh                   # Coller le contenu du script de test

# 3. Rendre les scripts exécutables
chmod +x *.sh

# 4. Lancer l'installation
./install.sh

# 5. (Optionnel) Tester l'installation
./test.sh

Vous pouvez aussi copier le script dans votre dossier scripts nautilus. Pour moi c'est "/home/andycinquin/.local/share/nautilus/scripts"

⚙️ Configuration Avancée

Modifiez les paramètres dans video-to-webp.sh :

FPS_INTERMEDIATE=24    # FPS intermédiaire pour le traitement
FPS_OUTPUT=30         # FPS final du WebP
CRF=18               # Qualité vidéo (plus bas = meilleure qualité)
PRESET="veryfast"    # Vitesse d'encodage
FADE_DURATION=0.5    # Durée du fondu pour la boucle
FADE_OFFSET=3.5      # Décalage du fondu

🔧 Processus de Conversion

Le script effectue automatiquement 3 étapes :

Normalisation : Conversion en framerate constant (24fps)
Boucle fluide : Création d'un fondu entre la fin et le début
Export WebP : Conversion finale en WebP animé (30fps)

🐛 Dépannage

Le menu contextuel n'apparaît pas

pkill nautilus && nautilus &

FFmpeg introuvable

sudo dnf install ffmpeg

Erreurs de permissions

# Vérifier les permissions du script
ls -la /usr/local/bin/video-to-webp.sh
# Doit afficher : -rwxr-xr-x

Réinstallation complète

sudo rm -f /usr/local/bin/video-to-webp.sh
rm -f ~/.local/share/file-manager/actions/video-to-webp.desktop
./install.sh

📊 Exemples de Résultats

Vidéo MP4 de 10MB → WebP de ~2-3MB
Qualité visuelle : Excellente pour les animations courtes
Temps de conversion : ~30 secondes pour 10 secondes de vidéo
Compatibilité : Fonctionne dans tous les navigateurs modernes

🎯 Cas d'Usage Idéaux

Remplacement de GIF : Taille réduite, qualité supérieure
Animations web : Performance optimisée
Réseaux sociaux : Format moderne et efficace
Présentations : Animations fluides et légères

🛠️ Désinstallation

Pour supprimer complètement le système :

# Supprimer le script principal
sudo rm -f /usr/local/bin/video-to-webp.sh

# Supprimer l'action Nautilus
rm -f ~/.local/share/file-manager/actions/video-to-webp.desktop

# Redémarrer Nautilus
pkill nautilus && nautilus &

📁 Structure des Fichiers

video-to-webp-converter/
├── video-to-webp.sh          # Script principal de conversion
├── video-to-webp.desktop     # Fichier d'action Nautilus
├── install.sh                # Script d'installation automatique
└── test.sh                   # Script de test et vérification

📝 Notes Techniques

Boucle fluide : Utilise xfade de FFmpeg pour un fondu imperceptible
Optimisation : CRF 18 pour équilibrer qualité/taille
Nettoyage : Suppression automatique des fichiers temporaires
Sécurité : Validation des entrées et gestion d'erreurs robuste

🤝 Contribution

N'hésitez pas à signaler des bugs ou proposer des améliorations !

Auteur : Assistant
Licence : MIT
Version : 1.0.0

✨ Kit portable complet ! Copiez chaque script, installez et profitez de la conversion WebP animé en un clic ! ✨

🚀 Merci d'avoir lu jusqu'ici !
Si cet article vous a plu, partagez-le autour de vous.

💡 Une idée en tête ? Discutons-en !☕

CONTACT

Vidéo Midjourney vers Seamless Loop en utilisant FFmpeg - Script d'automatisation complet

Les sites et les ressources associées

Vidéo Midjourney vers Seamless Loop en utilisant FFmpeg - Script d'automatisation complet

FFmpegAnimation WebPTraitement vidéoAutomatisationScript Bash

✨ Fonctionnalités

🎯 Formats supportés

📋 Prérequis

🚀 Installation rapide

🎬 Utilisation

Via le menu contextuel (recommandé)

Via la ligne de commande

📁 SCRIPTS COMPLETS À CRÉER

1. 📝 Fichier : `video-to-webp.sh`

2. 🗂️ Fichier : `video-to-webp.desktop`

3. 🚀 Fichier : `install.sh`

4. 🧪 Fichier : `test.sh`

📋 INSTRUCTIONS D'INSTALLATION

🚀 Installation en Une Fois :

⚙️ Configuration Avancée

🔧 Processus de Conversion

🐛 Dépannage

Le menu contextuel n'apparaît pas

FFmpeg introuvable

Erreurs de permissions

Réinstallation complète

📊 Exemples de Résultats

🎯 Cas d'Usage Idéaux

🛠️ Désinstallation

📁 Structure des Fichiers

📝 Notes Techniques

🤝 Contribution

DÉVELOPPONS ENSEMBLE VOS PROJETS

Vidéo Midjourney vers Seamless Loop en utilisant FFmpeg - Script d'automatisation complet

‣ Développeur créatif / Développeur Full-Stack / Développeur Front-End / Freelance / Entrepreneur / Designer UI/UX

Les sites et les ressources associées

Vidéo Midjourney vers Seamless Loop en utilisant FFmpeg - Script d'automatisation complet

FFmpegAnimation WebPTraitement vidéoAutomatisationScript Bash

✨ Fonctionnalités

🎯 Formats supportés

📋 Prérequis

🚀 Installation rapide

🎬 Utilisation

Via le menu contextuel (recommandé)

Via la ligne de commande

📁 SCRIPTS COMPLETS À CRÉER

1. 📝 Fichier : video-to-webp.sh

2. 🗂️ Fichier : video-to-webp.desktop

3. 🚀 Fichier : install.sh

4. 🧪 Fichier : test.sh

📋 INSTRUCTIONS D'INSTALLATION

🚀 Installation en Une Fois :

⚙️ Configuration Avancée

🔧 Processus de Conversion

🐛 Dépannage

Le menu contextuel n'apparaît pas

FFmpeg introuvable

Erreurs de permissions

Réinstallation complète

📊 Exemples de Résultats

🎯 Cas d'Usage Idéaux

🛠️ Désinstallation

📁 Structure des Fichiers

📝 Notes Techniques

🤝 Contribution

DÉVELOPPONS ENSEMBLE VOS PROJETS

1. 📝 Fichier : `video-to-webp.sh`

2. 🗂️ Fichier : `video-to-webp.desktop`

3. 🚀 Fichier : `install.sh`

4. 🧪 Fichier : `test.sh`