echouchane.com

API REST pour caméras Blackmagic et Companion

2025-03-25T00:00:00Z

Les caméras Blackmagic peuvent être contrôlées soit à travers un mélangeur ATEM, soit directement via leur API REST. Dans ce dernier cas, il suffit d’envoyer des requêtes HTTP de type GET ou PUT à l’adresse IP de la caméra, en veillant à ce qu’elle soit connectée au même réseau local que votre ordinateur.

Configuration de la caméra

Pour une première configuration de la caméra, installer le logiciel Blackmagic Camera Setup sur votre ordinateur, connecter la caméra à votre ordinateur via USB-C et ouvrir le logiciel. Profitez-en pour mettre à jour le firmware. Configurer ensuite l'adresse IP, le nom de la caméra (optionnel), le masque sous-réseau et la passerelle. Ne pas oublier d'activer le web media manager (HTTP) et Allow utility administration.

S'assurer d'être sur le même réseau que la caméra envoyant un ping à l'adresse IP depuis votre ordinateur. Plusieurs caméras peuvent être connectées au même réseau, il faut s'assurer qu'elles ont des noms ou des adresses IP différentes.

Utilisation de l'API

Pour utiliser l'API, il faut envoyer des requêtes HTTP à l'adresse IP de la caméra. Voici quelques exemples de requêtes :

# Obtenir la configuration de la vidéo : format, codec, etc.
GET http://<camera_ip>/control/api/v1/system
# Avoir la valeur du shutter
GET http://<camera_ip>/control/api/v1/video/shutter

Pour les GET, les réponses sont au format JSON.

La documentation de l'API REST est disponible sur le site de Blackmagic Design. Il est possible d'utiliser des outils comme Postman pour tester les requêtes avant de les intégrer dans un script ou une application.

L'API ne permet malheureusement pas de contrôler l'alimentation de la caméra, ni l'enregistrement ou son arrêt à distance.

Utilisation avec Companion

Companion est un logiciel qui permet de contrôler des appareils via une interface web ou un StreamDeck. Il est possible d'utiliser Companion pour contrôler les caméras Blackmagic en utilisant l'API de la caméra.

Pour cela, il faut ajouter le module HTTP dans Companion et configurer les requêtes pour contrôler la caméra. Voici comment faire :

Ouvrir Companion et se rendre dans l'onglet Modules.
Ajouter le module HTTP Generic.
Vu que j'ai plusieurs caméras, je ne vais pas indiquer l'adresse IP dans la configuration du module, mais dans chaque bouton que je vais créer.
Changer Unauthorized Certificates à Accept.
Dans l'onglet Boutons, ajouter un bouton en cliquant sur le bouton Ajouter un bouton.
Dans Actions, sélectionnez le module HTTP, puis choisissez la méthode PUT.
Dans le champ URL, indiquer l'URL de la requête HTTP que vous souhaitez envoyer à la caméra. Par exemple, pour avoir l'état du système, vous pouvez utiliser l'URL suivante :
```
http://<camera_ip>/control/api/v1/system
```
Garder le reste tel quel.
Vérifiez dans le journal (log) de Companion que la requête a bien été envoyée et que la caméra a répondu.

Contrôle de l'optique

Ce qui m'intéresse avant tout avec cette méthode, c'est de pouvoir contrôler l'optique, aussi bien le zoom que le focus. Dans mes tests, j'ai utilisé la caméra Blackmagic Micro Studio 4K G2 et une optique compatible Olympus M.Zuiko ED 14-42mm f/3.5-5.6 EZ.

Petite note : Le capteur est un CMOS Four Thirds, donc l’objectif 14mm devient un équivalent 28mm (facteur x2). À prendre en considération lors du choix de l'optique.

Voici un exemple de requête pour contrôler le zoom avant dans Companion:

Actions : HTTP PUT
URL : http://<camera_ip>/control/api/v1/lens/zoom
Body : { "normalised": 0.8 }

Le normalised fait référence à une valeur de zoom représentée en float entre 0.0 et 1.0, indépendamment de la plage optique réelle de la caméra. À 0.0, le zoom est au minimum, et à 1.0, il est au maximum. À vous de faire la conversion par rapport à l'optique que vous utilisez.

Je cherche encore une méthode fiable pour incrémenter le zoom avec de ±0.1 via une variable custom, ce qui éviterait d’avoir un bouton pour chaque niveau de zoom. Si vous avez une idée, n’hésitez pas à me la transmettre!

Pour le focus, vous pouvez soit envoyer une commande AutoFocus, soit définir une valeur de focus normalisée. Consultez la documentation de l'API REST de Blackmagic pour plus de détails (Section Lens Control API, page 22).

Voici un exemple de requête pour l'AutoFocus, directement depuis Companion :

Vous remarquerez que j’utilise le nom de la caméra au lieu de son adresse IP. J’ai cependant constaté une certaine lenteur avec les noms en .local, probablement liée à la résolution du nom d’hôte. Je vous recommande donc d’utiliser directement l’adresse IP pour une communication plus rapide et fiable.

En quelques boutons, vous pouvez créer une interface simple pour vos besoins :

Note : J’utilise un switch PDU pour gérer l’alimentation des caméras, d’où la présence des boutons Allumer et Éteindre (qui devraient d’ailleurs être regroupés en un seul bouton avec changement d’état!)

Aller plus loin avec Companion

La prochaine étape, cela serait d'avoir du feedback sur les valeurs du zoom, focus, etc. directement dans Companion. Il est possible de le faire en utilisant des requêtes GET, cela permet d'avoir une interface un peu plus interactive.

N'hésitez pas à me faire part de vos retours ou de vos questions sur ce sujet!

Découvrathon - Article dans UdeMNouvelles

2024-10-31T00:00:00Z

Un grand merci à Martin LaSalle pour ce bel article dans UdeMNouvelles, qui revient sur ma participation au Découvrathon à la BnF (Paris), un moment riche en rencontres, en idées et en expérimentations.

C’est toujours un peu étrange (et touchant) de se lire à travers les mots de quelqu’un d’autre, surtout quand ils sont choisis avec autant de justesse.

Crédit photo : Béatrice Lucchese, BnF

WebP - Le format d'image du futur

2023-04-19T00:00:00Z

Depuis quelque temps, je m’intéresse au poids du web. Plus les connexions deviennent rapides, plus les sites se permettent d’être lourds… et ça pose plein de questions, surtout quand on parle d’accessibilité. Ce n’est pas juste une question de handicap : ça concerne aussi celles et ceux qui accèdent au web avec des vieux appareils ou des connexions lentes. Bref, tout le monde n’a pas la fibre et un MacBook Pro.

Un des gros coupables, ce sont les images. Et c’est là que j’ai redécouvert le format WebP. Il remplace avantageusement les classiques JPEG et PNG, avec un taux de compression bien meilleur. Moins lourd, mais visuellement presque pareil. En bonus, il gère la transparence (comme le PNG), les animations (comme le GIF), et il est pensé spécifiquement pour le web. C’est un projet open source de Google (licence ici), toujours activement maintenu (repo ici).

WebP propose deux types de compression : lossy (avec perte) et lossless (sans perte), selon le besoin. Et franchement, c’est un bon compromis. Il est même supporté par la majorité des navigateurs. Moins de bande passante utilisée, un site qui se charge plus vite, une meilleure expérience utilisateur, et même un petit coup de pouce côté SEO.

Ce qui m’intéresse aussi, c’est l’aspect écologique : réduire la bande passante, c’est consommer un peu moins d’énergie. Pas énorme à l’échelle d’une page, mais à l’échelle du web… ça compte.

Et puis, il y a aussi le stockage. Pour un petit site, ce n’est pas un enjeu majeur, mais pour une grosse plateforme avec des milliers de pages, ça commence à peser.

Bref, je garde WebP dans ma boîte à outils. Un petit geste technique, mais qui va dans le bon sens.

Comment convertir en WebP

Solution en ligne de commande avec cwebp

Sur Windows

Rendez-vous sur le site officiel du projet WebP.
Télécharger le fichier "libwebp-xxx-windows-x64.zip" (remplacez "xxx" par la version actuelle).
Extraire le fichier ZIP dans un dossier de votre choix.
Ajouter le chemin du dossier extrait à la variable d'environnement "Path" de votre système.

Sur macOS (en utilisant Homebrew)

Si vous n'avez pas Homebrew installé, vous pouvez le faire en suivant les instructions sur le site officiel (https://brew.sh).
Ouvrir le terminal et taper la commande suivante :

brew install webp

Sur Linux (Debian/Ubuntu)

Ouvrir le terminal et taper la commande suivante :

sudo apt-get install webp

Utilisation de l'outil

La syntaxe de base pour utiliser cwebp est la suivante :

cwebp [options] input_image -o output_image.webp

input_image : le fichier image d'origine (JPEG, PNG, etc.). output_image.webp : le nom du fichier WebP de sortie. [options] : les options de conversion, telles que la qualité, la méthode de compression, etc.

Pour convertir une image JPEG en WebP avec une qualité de 80% :

cwebp -q 80 input_image.jpg -o output_image.webp

et tout les fichiers dans le dossier images :

for file in images/*; do cwebp -q 80 "$file" -o "${file%.*}.webp"; done

Voici quelques options courantes pour personnaliser la conversion :

-q : définit la qualité de l'image WebP (0 à 100). Une valeur plus élevée donne une qualité d'image plus élevée et une taille de fichier plus importante. Par exemple, -q 80 définit une qualité de 80%.

-m : sélectionne la méthode de compression (0 à 6). Une valeur plus élevée offre une meilleure compression, mais nécessite plus de temps pour la conversion. Par exemple, -m 6 utilise la méthode de compression la plus lente et la plus efficace.

-lossless : convertit l'image en mode sans perte. Utilisez cette option pour conserver la qualité d'image d'origine.

-z : active le mode "sans pertes" avec une compression optimale. Cela prendra plus de temps pour la conversion, mais réduira davantage la taille du fichier.

-resize : redimensionne l'image avant la conversion. Par exemple, -resize 800 600 redimensionne l'image à 800x600 pixels.

Pour plus d'options, consultez la documentation officielle de cwebp.

Solution pour les SSG

Astro : https://docs.astro.build/en/guides/images/
Hugo : https://gohugo.io/content-management/image-processing/#target-format
Eleventy : https://www.11ty.dev/docs/plugins/image/ https://www.aleksandrhovhannisyan.com/blog/eleventy-image-plugin/

Solution logicielle

Compatible avec Photoshop 23.2 (depuis début 2022)

Futurs développements

Les formats AVIF et JPEG XL sont en développement, ainsi que WebP 2.

Datamosh - mode d’emploi

2019-01-30T00:00:00Z

1 – C’est quoi ?

Le datamoshing est le processus de manipulation des données d’un fichier média afin d’obtenir intentionnellement des erreurs de compression à des fins artistiques.

La technique est apparue au début des années 2000, inspirée par les artefacts issus des premiers codecs numériques comme le DivX. Des artistes ont commencé à exploiter ces erreurs de compression et à pirater des vidéos pour générer des effets visuels imprévisibles et organiques.

Personne ne sait avec certitude quand le mot « datamosh » a été utilisé pour la première fois, mais des artistes comme Takeshi Murata, Paper Rad, Kris Moyes ou encore David O’Reilly ont largement contribué à faire connaître cette esthétique.

Voici une sélection chronologique d’œuvres marquantes :

Owi Mahn & Laura Baginski – Pastell Kompressor – 2003
David O'Reilly – Venetian Snares – Szamar Madar – 2005
Kris Moyes – The Presets – Are You the One ? – 2005
Takeshi Murata – Untitled (Silver) – 2006
Takeshi Murata – Untitled (Pink Dot) – 2007
Paper Rad et Paul B. Davis – Umbrella Zombie Datamosh Mistake – 2007
David O'Reilly – Compression Reel – 2008
Takeshi Murata – Monster Movie – 2009

Une histoire de glitch avant le numérique

Les combinaisons d’erreurs et d’échecs à but artistique ne datent pas d’hier. Dès les années 60, des cinéastes du cinéma structurel comme Paul Sharits, George Landow ou Tony Conrad filmaient volontairement hors focus, utilisaient des images vides ou manipulaient la pellicule. En parallèle, des pionniers de l’image électronique comme Nam June Paik (Magnet TV), Joan Jonas (Vertical Roll) ou encore Steina et Woody Vasulka (synthétiseur vidéo Rutt/Etra) expérimentaient les distorsions vidéo. Cette exploration de la « matière » visuelle permet de mieux comprendre pourquoi des artistes comme Takeshi Murata ont été séduits par le datamosh.

Appropriation grand public

Le mainstream s’en est emparé rapidement : Kanye West dans Welcome to Heartbreak (2009), ou encore Leos Carax dans Holy Motors (2012). Même Hollywood s’est essayé au glitch avec la bande-annonce de Man of Steel (2013).

2 – I, P, B frames et GOP

Pour comprendre le datamosh, il faut se pencher sur la structure interne d’une vidéo numérique. Elle est composée de différents types d’images :

I-frame (intra-frame) : image clé complète.
P-frame (predicted-frame) : encode les différences avec une image précédente.
B-frame (bi-directional) : encode les différences entre l’image précédente et suivante.

Ces images forment un GOP (Group of Pictures). Supprimer ou corrompre une I-frame entraîne une dérive des images suivantes qui tentent de se baser dessus, ce qui crée l’effet datamosh.

3 – Détournement des I-frames

En supprimant ou corrompant une I-frame, les images suivantes (P-frames) se réfèrent à une base erronée ou ancienne. C’est ce décalage temporel qui génère le glitch.

4 – Les outils

Voici les outils nécessaires pour faire du datamosh :

ffmpeg : pour convertir les vidéos.
AVIglitch : pour supprimer les keyframes.
Moshy : pour réparer la vidéo corrompue.
(Optionnel) youtube-dl : pour télécharger des vidéos YouTube.

5 – Installation (macOS/Linux)

5.1 Installer Homebrew et ffmpeg

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install ffmpeg

5.2 Installer Ruby, Moshy et AVIglitch

brew install ruby
gem install moshy
gem install aviglitch

5.3 Bonus : youtube-dl

brew install youtube-dl

6 – Utilisation

6.1 Terminal

Crée un répertoire pour travailler :

cd Desktop
mkdir datamosh && cd $_

6.2 Télécharger une vidéo

youtube-dl -F "URL"
youtube-dl -f 313 "URL"

6.3 Conversion en AVI

ffmpeg -i input.mp4 -c:v libxvid -qscale 1 -g 150 -me_method epzs -bf 0 -mbd 0 -c:a copy output.avi

6.4 Appliquer le datamosh

datamosh output.avi -o datamoshed.avi
moshy -m bake -i datamoshed.avi -o final.avi
ffmpeg -i final.avi -c:v libx264 -crf 23 -c:a copy final.mp4

7 – Automatiser avec un script Bash

#!/bin/bash

tempfoo=`basename $0`
TMPFILE=`mktemp /tmp/${tempfoo}.XXX`
TMPFILE1=`mktemp /tmp/${tempfoo}.XXX`

for i in *.mp4;
do
  echo "||| Datamosh... conversion vers AVI avec -g $1 |||"
  ffmpeg -i "$i" -c:v libxvid -q:v 1 -g $1 -me_method epzs -bf 0 -mbd 0 -c:a copy -y $TMPFILE.avi

  echo "||| Datamosh... en cours ! |||"
  datamosh $TMPFILE.avi -o $TMPFILE1.avi
  moshy -m bake -i $TMPFILE1.avi -o $TMPFILE.avi

  echo "||| Datamosh... conversion vers mp4 |||"
  ffmpeg -i $TMPFILE.avi -strict -2 -y "${i%.*}-datamosh.mp4"

  clear
  echo "||| Datamosh... Done! |||"
done

Pour l’utiliser :

chmod a+x datamosh.sh
./datamosh.sh 100

C’est certainement l’un des effets les plus organiques et imprévisibles dans la manipulation d’une vidéo.

Configurer un serveur MQTT avec Raspberry Pi

2019-01-05T00:00:00Z

Alors que les objets connectés (IoT) transforment peu à peu notre quotidien, les arts numériques s’approprient eux aussi cette révolution technologique pour créer des installations autonomes, interactives et sans fil.

Dans cette note, nous allons configurer un Raspberry Pi pour en faire à la fois un point d’accès WiFi et un serveur MQTT, capable de relayer des messages entre capteurs, microcontrôleurs (ESP8266, ESP32…) et logiciels comme Processing ou MaxMSP.

Exemples d'utilisation

Des capteurs de présence répartis dans une pièce envoient des messages via MQTT pour déclencher un visuel ou du son.
Un analyseur audio détecte des basses fréquences et, en retour, déclenche une lumière via un microcontrôleur.

Dans tous ces cas, le protocole MQTT fait le lien entre le monde physique (capteurs/actionneurs) et le logiciel de création. Le projet peut aussi s’appliquer à des cas non artistiques : commandes vocales via Alexa, récupération de données environnementales, etc.

Étape 1 : Préparer le Raspberry Pi

Assurez-vous que la date et l’heure sont à jour. Sinon, configurez-les manuellement s'il le faut :

sudo date -s "Tue May 28 21:31:26 UTC-5 2019"

Ensuite, mettez à jour le système et redémarrez :

sudo apt-get update
sudo apt-get upgrade
sudo reboot

Étape 2 : Installer RaspAP

RaspAP est un outil qui permet de transformer le Pi en point d’accès WiFi avec interface web.

Installez-le avec la commande suivante :

wget -q https://git.io/voEUQ -O /tmp/raspap && bash /tmp/raspap

Suivez les instructions à l’écran. Une fois l’installation terminée, le Pi redémarre.

Un réseau raspi-webgui devrait apparaître. Mot de passe par défaut : ChangeMe.

Accédez à l’interface web via http://10.3.141.1, identifiants par défaut : admin / secret. N’oubliez pas de changer ces informations.

Étape 3 : Installer le broker MQTT (Mosquitto)

Mosquitto est un broker MQTT léger et très utilisé.

sudo apt-get install mosquitto
sudo /etc/init.d/mosquitto start

Après configuration du hotspot (SSID, mot de passe, reboot), vous pouvez utiliser l’adresse IP locale 10.3.141.1 pour vos tests MQTT.

Étape 4 : Tester le serveur

Installez un client MQTT :

Sous Linux (ou Raspbian)

sudo apt-get install mosquitto-clients

Sous macOS (avec Homebrew)

brew install mosquitto

Dans un premier terminal (abonné au topic) :

mosquitto_sub -h 10.3.141.1 -t 'test/topic' -v

Dans un second terminal (éditeur de message) :

mosquitto_pub -h 10.3.141.1 -t 'test/topic' -m 'hello world'

Vous devriez voir le message apparaître dans le premier terminal.

Dernière étape : désactiver la mise en veille de l’écran

Pour éviter que l’écran se mette en veille automatiquement :

sudo nano /etc/X11/xinit/xinitrc

Ajoutez à la fin du fichier :

xset s off
xset -dpms

Enregistrez avec Ctrl + X, puis validez. Enfin, redémarrez le système :

sudo reboot

Et voilà! Votre Raspberry Pi est maintenant prêt à faire office de serveur MQTT, accessible via WiFi pour tous vos projets interactifs.

Comprendre le bitrate et les options d'encodage avec ffmpeg

2018-06-11T00:00:00Z

Il est important de comprendre comment les bons paramètres ffmpeg influencent la qualité de la vidéo. En général, plus le bitrate est élevé, meilleure sera la qualité. À bitrate égal, une vidéo encodée en H.265 sera de meilleure qualité que son équivalent en H.264.

Dans cette note, on va s’intéresser à ce paramètre avec l’encodeur x264, ainsi qu’aux différentes options pour bien manipuler la compression vidéo avec ce codec.

C’est quoi le bitrate ?

Le bitrate, c’est la quantité de données par seconde. Plus il est élevé, meilleure est la qualité… mais aussi plus grande sera la taille du fichier. Par exemple, 1 mégaoctet par seconde correspond à un bitrate de 8 mégabits par seconde (8 Mbps). Une vidéo YouTube en 1080p tourne autour de 8 Mbps, un DVD autour de 6 Mbps.

Choisir le bon bitrate, c’est choisir le bon équilibre entre qualité et poids du fichier.

Choisir le bon bitrate

L’appareil cible a un rôle à jouer : smartphone, TV, web, etc. On distingue deux types de bitrate :

CBR (Constant Bitrate) : débit constant, utile pour les lives ou les diffusions par satellite.
VBR (Variable Bitrate) : s’adapte à la complexité de la scène, meilleure qualité à taille équivalente.

VBR est recommandé pour la plupart des usages car il permet une meilleure gestion de la qualité selon les moments clés de la vidéo.

Par défaut, ffmpeg utilise le CRF (voir plus bas). Si vous ne spécifiez rien, vous aurez :

-crf 23
preset medium
profile high

Encoder en CBR

ffmpeg -i video.mp4 -c:v libx264 -b:v 1500k -minrate 1000k -maxrate 2000k -bufsize 60k output.mp4

Le paramètre -bufsize est souvent : bitrate / fps. Le CBR n'est jamais totalement constant avec x264, mais on s'en approche.

Le CRF

ffmpeg -i video.mp4 -c:v libx264 -crf 23 output.mp4

Le CRF (Constant Rate Factor) permet d’équilibrer qualité et taille automatiquement. Voici quelques repères :

crf 0 → sans perte, mais fichiers énormes
crf 18-23 → excellent équilibre
crf > 23 → plus de compression, moins de qualité

Un changement de ±6 double ou divise la taille du fichier.

Les presets

Un preset influe sur la vitesse d'encodage et la compression :

veryslow → encodage lent, fichier plus petit
fast → encodage rapide, fichier plus gros

Choisissez selon votre priorité : temps ou taille.

Les profiles

Les profils assurent la compatibilité :

baseline → anciens appareils, fonctions limitées
main, high → plus de fonctionnalités, meilleure qualité

Le Tune

Un tune adapte l’encodage au contenu :

film, animation, stillimage, zerolatency...

Ces paramètres activent des filtres anti-blocs pour améliorer la qualité visuelle.

Encodage en Two-Pass

Si vous visez une taille de fichier précise, utilisez le two-pass :

Exemple de calcul :

Fichier de 200 Mo pour une vidéo de 300 secondes :

(200 × 8192) / 300 ≈ 5461 kbps

Exemple de commandes :

1ère passe :

ffmpeg -i video.mp4 -pix_fmt yuv420p -vsync 1 -sn -r 25 -threads 0 -c:v libx264 \
-b:v 5461k -bufsize 218k -maxrate 6000k -minrate 4000k -an -pass 1 -preset slow \
-profile:v high -g 48 -tune film -x264opts no-scenecut -f mp4 -y /dev/null

2ème passe :

ffmpeg -i video.mp4 -pix_fmt yuv420p -vsync 1 -sn -r 25 -threads 0 -c:v libx264 \
-b:v 5461k -bufsize 218k -maxrate 6000k -minrate 4000k -an -pass 2 -preset slow \
-profile:v high -g 48 -tune film -x264opts no-scenecut -f mp4 -y output.mp4

Ne changez aucune valeur entre les deux passes.

Et voilà ! Avec ces bases, vous êtes prêt à dompter le bitrate et encodages vidéo avec ffmpeg.

Conversion vidéo en lot avec ffmpeg

2017-07-10T00:00:00Z

Avec ffmpeg, il est possible de convertir par lot n’importe quel format de vidéo. Voici un exemple simple pour convertir des fichiers H.265 vers H.264 :

for i in *.mp4 ; do
  ffmpeg -i "$i" -c:v libx264 -vf scale=1280:-2 -c:a copy -map 0:0 -map 0:1 "H $i"
  sleep 3
done

Explication

`for i in *.mp4 ; do`

Prend tous les fichiers .mp4 dans le dossier courant. La commande for permet de boucler sur chaque fichier.

`ffmpeg -i "$i"`

Exécute ffmpeg avec le fichier d’entrée $i.

`-map 0:0 -map 0:1`

Spécifie uniquement les deux premiers flux : vidéo (0:0) et audio (0:1). Optionnel, mais utile pour éviter d’inclure des pistes inutiles.

`-c:v libx264`

Définit le codec vidéo. Peut être personnalisé avec des options comme -preset slow, -crf 23, etc.

`-vf scale=1280:-2`

Redimensionne la vidéo en largeur 1280 pixels et ajuste automatiquement la hauteur pour conserver les proportions.

`-c:a copy`

Copie directement la piste audio sans ré-encodage.

`"H $i"`

Crée un nouveau fichier avec le préfixe "H" pour éviter d’écraser le fichier original.

`sleep 3`

Pause de 3 secondes entre les conversions.

Extraire uniquement l’audio (en AAC)

for i in *.MP4; do
  ffmpeg -i "$i" -vn -acodec copy "${i%}.aac"
  sleep 3
done

-vn : ignore les flux vidéo
-acodec copy : copie l’audio sans le ré-encoder

Script bash multithread

Pour tirer parti de plusieurs cœurs du processeur et lancer plusieurs conversions en parallèle :

#!/bin/bash

function encode {
  base="${1%.*}"
  extension="${1##*.}"
  out="${base}_output.${extension}"

  ffmpeg -i "$1" -c:v libx264 -vf scale=1280:-2 -c:a copy -map 0:0 -map 0:1 "$out"
}     

encode video1.mp4 &
encode video2.mp4 &
echo "ZZzzzzzzZZzzzzz"
wait

Chaque appel à encode est lancé en arrière-plan grâce au &, et wait force le script à attendre que tous les processus soient terminés.

Pour utiliser ce script :

Copiez le code dans un fichier (par exemple convert.sh)
Donnez-lui les permissions d’exécution :
```
chmod +x convert.sh
```
Lancez-le :
```
./convert.sh
```

Premiers pas avec ffmpeg

2017-01-21T00:00:00Z

ffmpeg est un puissant convertisseur audio/vidéo en ligne de commande, open-source et multiplateforme (Linux, macOS…). Il peut impressionner au début, mais une fois adopté, on ne s’en passe plus. D’ailleurs, sans le savoir, vous l’utilisez peut-être déjà à travers des logiciels comme VLC, Kodi, OBS, ou Blender.

Installation sur macOS

La manière la plus simple consiste à passer par le gestionnaire de paquets Homebrew. Ouvrez le terminal et, si ce n’est pas déjà fait, installez Homebrew :

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Puis installez ffmpeg :

brew install ffmpeg

Pour avoir ffmpeg avec des dépendances utiles :

brew install ffmpeg --with-fdk-aac --with-libvorbis --with-libvpx --with-x265

Mettez ensuite ffmpeg à jour :

brew update && brew upgrade ffmpeg

Testez l’installation avec :

ffmpeg

Naviguer dans les dossiers

Placez une vidéo dans un dossier (par exemple un dossier conversion sur le bureau). Dans le terminal :

cd ~/Desktop/conversion
ls

Vous devriez voir votre fichier. Nous allons l’appeler ici vid0.mp4.

Extraire l’audio

ffmpeg -i vid0.mp4 -vn -f mp3 audio0.mp3

-i : fichier d’entrée
-vn : désactive la vidéo
-f mp3 : force le format de sortie

Avec plus d’options :

ffmpeg -i vid0.mp4 -ac 2 -ar 44100 -vn -b:a 256k audio1.mp3

Supprimer l’audio d’une vidéo

ffmpeg -i vid0.mp4 -an vid1.mp4

Redimensionner une vidéo (resize)

ffmpeg -i vid0.mp4 -vf scale=640:-1 vid1.mp4

La hauteur est ajustée automatiquement pour conserver les proportions.

Couper une portion de vidéo

ffmpeg -i vid0.mp4 -ss 00:00:10 -t 00:00:05 vid1.mp4

Coupe 5 secondes à partir de la 10ᵉ.

Rotation

ffmpeg -i vid0.mp4 -vf rotate=45*PI/180 vid1.mp4

Conversion de conteneur

ffmpeg -i vid0.mp4 -codec copy vid1.mov

Conversion de codec

ffmpeg -i vid0.mp4 -c:v libx264 vid1.mp4

Modifier le bitrate

ffmpeg -i vid0.mp4 -b:v 5000k vid1.mp4

Plus le bitrate est élevé, meilleure est la qualité (et plus lourd le fichier).

Coller deux vidéos

ffmpeg -i vid0.mp4 -i vid1.mp4 -filter_complex "[0:v][1:v]concat=n=2:v=1:a=0[out]" -map "[out]" vidfinal.mp4

Superposition (overlay)

Ajouter un logo PNG :

ffmpeg -i vid0.mp4 -i logo.png -filter_complex "[0:v][1:v]overlay=10:10" vid1.mp4

Découper (crop)

ffmpeg -i vid0.mp4 -filter:v crop=320:180:160:90 vid1.mp4

Extraire une série d’images

ffmpeg -i vid0.mp4 -r 24 -t 2 -f image2 img-%04d.png

Créer une vidéo à partir d’images

ffmpeg -framerate 60 -i image-%04d.jpg -start_number 1 -r 60 -c:v libx264 -crf 25 -pix_fmt yuv420p output.mp4

Loop d’une vidéo

ffmpeg -stream_loop 1 -i input.mp4 -t 30 out.mp4

Modifier la teinte ou passer en noir et blanc

ffmpeg -i vid0.mp4 -vf hue=s=0 -c:a copy vidnb.mp4

ffmpeg -i vid0.mp4 -vf hue=h=90:s=1 -c:a copy vidcolor.mp4

Appliquer un fondu (fade in)

ffmpeg -i vid0.mp4 -vf fade=in:0:30 -c:a copy vidfade.mp4

Denoise (réduction du bruit)

ffmpeg -i vid0.mp4 -vf "split [a][b]; [b] dctdnoiz=4.5 [c]; [a][c] overlay" output.mp4

Écran partagé (split screen)

ffmpeg -i vid0.mp4 -i vid1.mp4 -filter_complex "[0:v]pad=iw*2:ih[left];[left][1:v]overlay=W/2:0" out.mp4

Conclusion : ffmpeg est un outil extrêmement puissant. Il vous permet de réaliser rapidement des tâches que vous auriez confiées à des logiciels de montage bien plus lourds. Et surtout : il est libre, gratuit, scriptable, et très bien documenté.

Liens utiles

Site officiel de FFmpeg : https://ffmpeg.org/
Site officiel de Homebrew : https://brew.sh/
Tutoriels d'installation de FFmpeg sur Windows :
- (EN) : http://adaptivesamples.com/how-to-install-ffmpeg-on-windows/
- (FR) : https://fr.wikihow.com/installer-FFmpeg-sur-Windows
Vidéos d'essai H.264 : http://www.h264info.com/clips.html
Instructions de compression vidéo :
- Vimeo : https://vimeo.com/help/compression
- YouTube : https://support.google.com/youtube/answer/1722171?hl=fr
Tutoriel sur l'utilisation du terminal sous macOS : https://openclassrooms.com/courses/domptez-votre-mac-avec-mac-os-x-mavericks/le-terminal-dans-os-x