🎬 Générer des Vidéos Éducatives à 0 Euros

Guide complet pour créer des vidéos professionnelles sans dépenser un centime

📚 Introduction

Dans ce cours, vous allez apprendre à créer des vidéos éducatives professionnelles en utilisant uniquement des outils gratuits et des APIs libres. Cette méthode permet de générer automatiquement des vidéos avec:

  • ✅ Synthèse vocale (Text-to-Speech)
  • ✅ Images générées par IA
  • ✅ Animations et transitions
  • ✅ Sous-titres automatiques
  • ✅ Musique de fond
💡 Le principe: Automatiser la création de vidéos éducatives en combinant plusieurs technologies gratuites (FFmpeg, APIs d'images, TTS, etc.)

🛠️ Les Outils Gratuits

🎨 Pollinations.ai

API gratuite de génération d'images par IA. Pas de clé API nécessaire, pas de limite.

Images 
https://image.pollinations.ai/prompt/
{votre_description}

🗣️ Edge-TTS

Synthèse vocale gratuite de Microsoft. Voix naturelles en français, aucune limite.

Audio 
npm install -g edge-tts

🎥 FFmpeg

Outil puissant pour créer, éditer et convertir des vidéos. Open source et gratuit.

Vidéo 
https://ffmpeg.org/download.html

🤖 ChatGPT/Claude (Gratuit)

Génération de contenu éducatif. Versions gratuites suffisantes pour créer du contenu.

Contenu

🖼️ Picsum Photos

Photos gratuites et libres de droits via API simple.

Images 
https://picsum.photos/1920/1080

📝 Node.js

Environnement JavaScript gratuit pour automatiser tout le processus.

Automation

⚙️ Workflow de Génération

1

Création du Contenu

Définir le sujet et générer le script avec ChatGPT/Claude. Structurer en slides avec texte et descriptions d'images.

2

Génération des Images

Utiliser Pollinations.ai pour générer automatiquement les images basées sur les descriptions.

3

Synthèse Vocale

Convertir chaque texte en audio avec Edge-TTS (voix française naturelle).

4

Assemblage Vidéo

Combiner images + audio avec FFmpeg, ajouter transitions, sous-titres et musique.

5

Export Final

Générer la vidéo MP4 finale, optimisée pour YouTube, TikTok ou Instagram.

💻 Structure du Code

1. Structure de Données

Voici comment structurer votre contenu de cours:

const coursData = {
  titre: "Introduction à la Photosynthèse",
  voix: "fr-FR-VivienneMultilingualNeural",
  slides: [
    {
      texte: "Qu'est-ce que la photosynthèse?",
      narration: "La photosynthèse est le processus par lequel les plantes...",
      imagePrompt: "illustration scientifique d'une plante avec le soleil, style éducatif",
      duree: 5 // secondes
    },
    {
      texte: "Les étapes clés",
      narration: "La photosynthèse se déroule en deux phases principales...",
      imagePrompt: "schéma des étapes de la photosynthèse avec flèches colorées",
      duree: 7
    }
    // ... autres slides
  ]
};

2. Génération d'Images

async function genererImage(prompt, outputPath) {
  const url = `https://image.pollinations.ai/prompt/${encodeURIComponent(prompt)}?width=1920&height=1080&nologo=true`;

  const response = await fetch(url);
  const buffer = await response.buffer();

  await fs.writeFile(outputPath, buffer);
  console.log(`✅ Image générée: ${outputPath}`);
}

3. Synthèse Vocale

async function genererAudio(texte, voix, outputPath) {
  return new Promise((resolve, reject) => {
    const commande = `edge-tts --voice "${voix}" --text "${texte}" --write-media "${outputPath}"`;

    exec(commande, (error, stdout, stderr) => {
      if (error) {
        reject(error);
      } else {
        console.log(`✅ Audio généré: ${outputPath}`);
        resolve();
      }
    });
  });
}

4. Assemblage Vidéo avec FFmpeg

async function creerVideoSlide(imagePath, audioPath, outputPath) {
  const commande = `ffmpeg -loop 1 -i "${imagePath}" ` +
    `-i "${audioPath}" ` +
    `-c:v libx264 -tune stillimage -c:a aac -b:a 192k ` +
    `-pix_fmt yuv420p -shortest ` +
    `-vf "scale=1920:1080:force_original_aspect_ratio=decrease,` +
    `pad=1920:1080:(ow-iw)/2:(oh-ih)/2,fade=t=in:st=0:d=0.5,fade=t=out:st=duration-0.5:d=0.5" ` +
    `"${outputPath}"`;

  return new Promise((resolve, reject) => {
    exec(commande, (error) => {
      if (error) reject(error);
      else {
        console.log(`✅ Slide vidéo créée: ${outputPath}`);
        resolve();
      }
    });
  });
}

5. Fusion de Tous les Segments

async function fusionnerVideos(videoPaths, outputPath) {
  // Créer un fichier liste
  const listeContenu = videoPaths
    .map(path => `file '${path}'`)
    .join('\n');

  await fs.writeFile('liste_videos.txt', listeContenu);

  const commande = `ffmpeg -f concat -safe 0 -i liste_videos.txt ` +
    `-c copy "${outputPath}"`;

  return new Promise((resolve, reject) => {
    exec(commande, (error) => {
      if (error) reject(error);
      else {
        console.log(`✅ Vidéo finale créée: ${outputPath}`);
        resolve();
      }
    });
  });
}

🎮 Démo Interactive: Générer une Image

⚡ Optimisations et Astuces

🚀 Performance

  • Parallélisation: Générer images et audio en parallèle avec Promise.all()
  • Cache: Stocker les images générées pour réutilisation
  • Compression: Optimiser les vidéos avec les bons paramètres FFmpeg
// Génération parallèle de toutes les images
const imagePromises = slides.map((slide, index) =>
  genererImage(slide.imagePrompt, `images/slide_${index}.png`)
);

const audioPromises = slides.map((slide, index) =>
  genererAudio(slide.narration, voix, `audio/slide_${index}.mp3`)
);

// Attendre que tout soit généré
await Promise.all([...imagePromises, ...audioPromises]);
console.log('✅ Toutes les ressources générées!');

🎯 Sous-titres Automatiques

function genererSousTitres(slides) {
  let srtContent = '';
  let startTime = 0;

  slides.forEach((slide, index) => {
    const endTime = startTime + slide.duree;

    srtContent += `${index + 1}\n`;
    srtContent += `${formatTemps(startTime)} --> ${formatTemps(endTime)}\n`;
    srtContent += `${slide.texte}\n\n`;

    startTime = endTime;
  });

  return srtContent;
}

function formatTemps(secondes) {
  const h = Math.floor(secondes / 3600).toString().padStart(2, '0');
  const m = Math.floor((secondes % 3600) / 60).toString().padStart(2, '0');
  const s = Math.floor(secondes % 60).toString().padStart(2, '0');
  const ms = Math.floor((secondes % 1) * 1000).toString().padStart(3, '0');
  return `${h}:${m}:${s},${ms}`;
}

📊 Comparaison: Gratuit vs Payant

Fonctionnalité Solution Gratuite Solution Payante Économie
Génération Images IA Pollinations.ai DALL-E 3 ($0.04/image) ~$4/vidéo
Text-to-Speech Edge-TTS ElevenLabs ($22/mois) $22/mois
Montage Vidéo FFmpeg Adobe Premiere ($24/mois) $24/mois
Génération Contenu ChatGPT Free ChatGPT Plus ($20/mois) $20/mois
Total mensuel 0€ ~66€ 792€/an

⚖️ Avantages et Limites

✅ Avantages

  • Coût zéro absolu
  • Automatisation complète
  • Scalabilité infinie
  • Contrôle total du code
  • Pas de watermark
  • Open source et modifiable
  • Apprentissage des technologies

⚠️ Limites

  • Configuration initiale nécessaire
  • Qualité d'images variable
  • Temps de traitement plus long
  • Nécessite connaissances techniques
  • Moins de contrôle créatif direct
  • Debug parfois complexe

📦 Script Complet Fonctionnel

Voici un script Node.js complet et prêt à l'emploi:

const fs = require('fs').promises;
const { exec } = require('child_process');
const util = require('util');
const execPromise = util.promisify(exec);

// Configuration du cours
const coursData = {
  titre: "Les Planètes du Système Solaire",
  voix: "fr-FR-VivienneMultilingualNeural",
  slides: [
    {
      texte: "Le Système Solaire",
      narration: "Notre système solaire contient huit planètes fascinantes",
      imagePrompt: "beautiful solar system with 8 planets, space illustration",
      duree: 4
    },
    {
      texte: "Mercure - La Plus Proche",
      narration: "Mercure est la planète la plus proche du Soleil",
      imagePrompt: "planet Mercury close up, realistic space photography",
      duree: 4
    },
    {
      texte: "Jupiter - Le Géant",
      narration: "Jupiter est la plus grande planète de notre système",
      imagePrompt: "massive Jupiter with great red spot, stunning space view",
      duree: 4
    }
  ]
};

// Fonction principale
async function genererVideo() {
  console.log('🎬 Démarrage de la génération...');

  // 1. Créer les dossiers
  await fs.mkdir('images', { recursive: true });
  await fs.mkdir('audio', { recursive: true });
  await fs.mkdir('videos', { recursive: true });

  // 2. Générer toutes les images en parallèle
  console.log('🎨 Génération des images...');
  const imagePromises = coursData.slides.map(async (slide, i) => {
    const url = `https://image.pollinations.ai/prompt/${encodeURIComponent(slide.imagePrompt)}?width=1920&height=1080&nologo=true`;
    const response = await fetch(url);
    const buffer = Buffer.from(await response.arrayBuffer());
    await fs.writeFile(`images/slide_${i}.png`, buffer);
    console.log(`  ✅ Image ${i + 1}/${coursData.slides.length}`);
  });

  // 3. Générer tous les audios en parallèle
  console.log('🗣️ Génération de l\'audio...');
  const audioPromises = coursData.slides.map(async (slide, i) => {
    await execPromise(
      `edge-tts --voice "${coursData.voix}" --text "${slide.narration}" --write-media "audio/slide_${i}.mp3"`
    );
    console.log(`  ✅ Audio ${i + 1}/${coursData.slides.length}`);
  });

  await Promise.all([...imagePromises, ...audioPromises]);

  // 4. Créer les vidéos pour chaque slide
  console.log('🎥 Création des vidéos...');
  for (let i = 0; i < coursData.slides.length; i++) {
    await execPromise(
      `ffmpeg -loop 1 -i "images/slide_${i}.png" -i "audio/slide_${i}.mp3" ` +
      `-c:v libx264 -tune stillimage -c:a aac -b:a 192k -pix_fmt yuv420p ` +
      `-vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" ` +
      `-shortest "videos/slide_${i}.mp4"`
    );
    console.log(`  ✅ Vidéo ${i + 1}/${coursData.slides.length}`);
  }

  // 5. Fusionner toutes les vidéos
  console.log('🔗 Fusion finale...');
  const liste = coursData.slides.map((_, i) => `file 'slide_${i}.mp4'`).join('\n');
  await fs.writeFile('videos/liste.txt', liste);

  await execPromise(
    `ffmpeg -f concat -safe 0 -i "videos/liste.txt" -c copy "output/${coursData.titre}.mp4"`
  );

  console.log('✅ Vidéo générée avec succès!');
  console.log(`📁 Fichier: output/${coursData.titre}.mp4`);
}

// Lancer la génération
genererVideo().catch(console.error);

🚀 Pour utiliser ce script:

  1. Installer Node.js
  2. Installer FFmpeg
  3. Installer edge-tts: npm install -g edge-tts
  4. Sauvegarder le script en generer-video.js
  5. Exécuter: node generer-video.js

🎯 Cas d'Usage Réels

1. YouTube Shorts Éducatifs

Créer des vidéos de 60 secondes sur des sujets variés (histoire, science, culture).

2. Cours en Ligne

Générer automatiquement des vidéos de cours à partir de scripts.

3. Contenu Social Media

Produire du contenu engageant pour Instagram, TikTok, Facebook.

4. Formation Entreprise

Créer des modules de formation interne rapidement.

5. Contenu Multilingue

Générer la même vidéo dans plusieurs langues en changeant simplement la voix.

// Exemple: générer en plusieurs langues
const langues = [
  { code: 'fr-FR-VivienneMultilingualNeural', nom: 'français' },
  { code: 'en-US-JennyNeural', nom: 'anglais' },
  { code: 'es-ES-ElviraNeural', nom: 'espagnol' }
];

for (const langue of langues) {
  coursData.voix = langue.code;
  await genererVideo();
  console.log(`✅ Version ${langue.nom} créée!`);
}

📚 Ressources et Documentation

📖 FFmpeg Documentation

Guide complet des commandes FFmpeg

ffmpeg.org/documentation.html

🎨 Pollinations API

Documentation de l'API d'images

pollinations.ai

🗣️ Edge-TTS Voix

Liste des voix disponibles

edge-tts --list-voices

💻 Node.js Docs

Documentation complète Node.js

nodejs.org/docs

🎓 Conclusion

Vous avez maintenant toutes les connaissances pour créer des vidéos éducatives professionnelles sans aucun coût. Cette méthode vous permet de:

  • ✅ Automatiser la production de contenu vidéo
  • ✅ Scaler votre création de contenu sans limites
  • ✅ Économiser des centaines d'euros par mois
  • ✅ Apprendre des technologies utiles (Node.js, FFmpeg, APIs)
  • ✅ Personnaliser complètement vos vidéos

Prochaines étapes:

  1. Installer les outils nécessaires
  2. Tester le script de base
  3. Créer votre premier cours
  4. Optimiser et personnaliser
  5. Publier et partager!