FFmpeg et SRT : référence complète des commandes

13 février 2026 · Stephane · tutorials

Support SRT dans FFmpeg

FFmpeg supporte SRT via la bibliothèque libsrt. Ce support n’est pas toujours activé par défaut dans les paquets précompilés. Avant de commencer, vérifiez que votre installation est compatible.

Vérifier la version et le support SRT

ffmpeg -version | grep srt

Vous devez voir --enable-libsrt dans la ligne de configuration. Si ce n’est pas le cas, vous devrez recompiler FFmpeg ou utiliser un paquet qui inclut libsrt.

Pour vérifier la version exacte de libsrt liée :

ffmpeg -protocols 2>/dev/null | grep srt

La sortie doit afficher srt dans la liste des protocoles d’entrée et de sortie. FFmpeg 4.4+ est recommandé pour un support SRT stable. FFmpeg 5.0+ apporte des améliorations sur la gestion des options SRT.

Compiler FFmpeg avec libsrt

Si votre distribution ne fournit pas FFmpeg avec libsrt, compilez depuis les sources :

# Installer libsrt en premier
git clone https://github.com/Haivision/srt.git
cd srt
mkdir build && cd build
cmake .. -DENABLE_ENCRYPTION=ON
make -j$(nproc)
sudo make install

# Compiler FFmpeg avec libsrt
git clone https://git.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-libsrt --enable-gpl --enable-openssl
make -j$(nproc)
sudo make install

Mode listener

En mode listener, FFmpeg ouvre un port et attend qu’un caller s’y connecte. C’est utile quand FFmpeg joue le rôle de serveur de réception.

Recevoir un flux SRT en listener

ffmpeg -i "srt://:9000?mode=listener" \
  -c copy output.ts

FFmpeg écoute sur le port 9000 et enregistre le flux entrant sans réencodage. Le flux doit être encapsulé en MPEG-TS côté émetteur.

Listener avec latence personnalisée

ffmpeg -i "srt://:9000?mode=listener&latency=500000" \
  -c copy output.ts

La latence est exprimée en microsecondes dans les URL SRT de FFmpeg. 500 ms = 500000.

Listener qui retransmet vers un lecteur

ffmpeg -i "srt://:9000?mode=listener&latency=300000" \
  -c copy -f mpegts udp://127.0.0.1:5000

Ce schéma est courant en régie : recevoir un flux SRT distant et le redistribuer localement en UDP multicast ou unicast pour les lecteurs et mélangeurs vidéo.

Mode caller

Le mode caller connecte FFmpeg vers un listener distant. C’est le mode le plus fréquent quand FFmpeg pousse un flux vers un serveur ou une passerelle SRT.

Envoyer un flux en mode caller

ffmpeg -re -i input.ts \
  -c copy -f mpegts \
  "srt://serveur-distant:9000?mode=caller&latency=500000"

Le flag -re lit le fichier source au débit réel. Sans ce flag, FFmpeg envoie les données aussi vite que possible, ce qui provoque un débordement du tampon SRT.

Envoyer une source live (caméra, carte de capture)

ffmpeg -f v4l2 -i /dev/video0 \
  -f alsa -i hw:0 \
  -c:v libx264 -preset ultrafast -tune zerolatency -b:v 5000k \
  -c:a aac -b:a 128k \
  -g 60 -keyint_min 60 \
  -f mpegts \
  "srt://serveur:9000?mode=caller&latency=500000"

Sur macOS, remplacez -f v4l2 par -f avfoundation et -f alsa par le périphérique audio CoreAudio correspondant.

Chiffrement

Le chiffrement SRT utilise AES et se configure directement dans l’URL. Les deux côtés (listener et caller) doivent utiliser la même passphrase et la même longueur de clé. Pour une explication détaillée du fonctionnement du chiffrement, consultez la page Configuration du chiffrement SRT.

Listener chiffré

ffmpeg -i "srt://:9000?mode=listener&passphrase=MaPassphrase2026Secure&pbkeylen=32" \
  -c copy output.ts

Caller chiffré

ffmpeg -re -i input.ts \
  -c copy -f mpegts \
  "srt://serveur:9000?mode=caller&passphrase=MaPassphrase2026Secure&pbkeylen=32"

Les valeurs de pbkeylen :

16 pour AES-128
24 pour AES-192
32 pour AES-256 (recommandé)

La passphrase doit comporter entre 10 et 79 caractères. Utilisez openssl rand -base64 32 pour en générer une robuste.

Transcodage avec SRT

Le transcodage est nécessaire quand le format source ne correspond pas aux exigences de la destination. FFmpeg peut recevoir en SRT, transcoder à la volée, et réémettre en SRT ou vers un autre protocole.

Recevoir en SRT, transcoder, réémettre en SRT

ffmpeg -i "srt://:9000?mode=listener&latency=500000" \
  -c:v libx264 -preset fast -b:v 4000k -g 60 \
  -c:a aac -b:a 128k \
  -f mpegts \
  "srt://destination:9001?mode=caller&latency=500000"

Transcodage avec accélération matérielle (Intel QSV)

ffmpeg -hwaccel qsv -i "srt://:9000?mode=listener" \
  -c:v h264_qsv -b:v 4000k -g 60 \
  -c:a copy \
  -f mpegts \
  "srt://destination:9001?mode=caller&latency=300000"

L’accélération matérielle réduit considérablement la charge CPU. Sur un Intel de 10e génération ou ultérieur, le transcodage d’un flux 1080p30 consomme moins de 5 % du CPU avec QSV, contre 40-60 % en logiciel.

Redimensionnement pendant le transcodage

ffmpeg -i "srt://:9000?mode=listener" \
  -vf "scale=1280:720" \
  -c:v libx264 -preset fast -b:v 2500k -g 60 \
  -c:a aac -b:a 96k \
  -f mpegts \
  "srt://destination:9001?mode=caller"

Relais RTMP vers SRT

Ce cas d’usage est omniprésent : recevoir un flux RTMP d’un encodeur ancien (ou d’une plateforme qui ne supporte que RTMP) et le relayer en SRT vers une infrastructure moderne. Pour une vue d’ensemble de cette transition, consultez le guide RTMP vers SRT.

Conversion RTMP vers SRT

ffmpeg -listen 1 -i rtmp://0.0.0.0:1935/live/stream \
  -c copy -f mpegts \
  "srt://serveur-srt:9000?mode=caller&latency=500000&passphrase=SecureKey2026&pbkeylen=32"

Le flag -listen 1 met FFmpeg en mode serveur RTMP. Le flux est recopié sans réencodage (-c copy) et réemballé de FLV (conteneur RTMP) vers MPEG-TS (conteneur SRT).

Relais SRT vers RTMP (pour les plateformes de diffusion)

ffmpeg -i "srt://:9000?mode=listener&latency=300000" \
  -c copy -f flv \
  "rtmp://a.rtmp.youtube.com/live2/votre-cle-stream"

L’opération inverse : recevoir un flux SRT et le pousser vers YouTube, Twitch ou toute autre plateforme RTMP. Pas de réencodage nécessaire si le codec source est compatible (H.264 + AAC).

SRT vers HLS

La conversion SRT vers HLS est le schéma classique pour la distribution web. FFmpeg génère les segments HLS et le manifest .m3u8 à partir d’un flux SRT entrant.

Conversion basique SRT vers HLS

ffmpeg -i "srt://:9000?mode=listener&latency=500000" \
  -c copy \
  -f hls -hls_time 4 -hls_list_size 5 -hls_flags delete_segments \
  /var/www/html/live/stream.m3u8

HLS adaptatif multi-débit depuis SRT

ffmpeg -i "srt://:9000?mode=listener" \
  -filter_complex "[0:v]split=3[v1][v2][v3]; \
    [v1]scale=1920:1080[v1out]; \
    [v2]scale=1280:720[v2out]; \
    [v3]scale=854:480[v3out]" \
  -map "[v1out]" -c:v:0 libx264 -b:v:0 5000k -g 60 \
  -map "[v2out]" -c:v:1 libx264 -b:v:1 2500k -g 60 \
  -map "[v3out]" -c:v:2 libx264 -b:v:2 1000k -g 60 \
  -map 0:a -c:a aac -b:a 128k \
  -f hls -hls_time 4 -hls_list_size 5 \
  -master_pl_name master.m3u8 \
  -var_stream_map "v:0,a:0 v:1,a:0 v:2,a:0" \
  /var/www/html/live/stream_%v.m3u8

Ce pipeline produit trois variantes (1080p, 720p, 480p) avec un manifest maître HLS. Pour approfondir le streaming adaptatif, consultez le guide SRT et protocoles.

Multi-sortie avec tee

Le muxer tee de FFmpeg permet d’envoyer un même flux vers plusieurs destinations simultanément, sans dupliquer le décodage ou l’encodage.

Deux sorties SRT depuis une seule source

ffmpeg -i "srt://:9000?mode=listener" \
  -c copy -f tee \
  "[f=mpegts]srt://dest1:9001?mode=caller|[f=mpegts]srt://dest2:9002?mode=caller"

SRT + RTMP + enregistrement local

ffmpeg -i "srt://:9000?mode=listener" \
  -c copy -f tee \
  "[f=mpegts]srt://prod-server:9001?mode=caller|\
[f=flv]rtmp://a.rtmp.youtube.com/live2/cle-stream|\
[f=mpegts]/recordings/archive_$(date +%Y%m%d_%H%M%S).ts"

Cette commande reçoit un flux SRT et le distribue vers un serveur de production en SRT, YouTube en RTMP, et un fichier local en MPEG-TS. Vajra Cast offre cette fonctionnalité de multi-destination nativement via son interface, sans ligne de commande.

Paramètres de latence

La latence est le paramètre le plus déterminant pour la qualité du transport SRT. Un tampon trop court empêche la récupération des paquets perdus. Un tampon trop long ajoute un délai inutile. Pour un réglage fin, consultez le guide d’optimisation de la latence SRT.

Paramètres recommandés par scénario

# LAN, même réseau local
"srt://:9000?latency=40000"

# Même ville, fibre
"srt://:9000?latency=200000"

# Même continent, internet
"srt://:9000?latency=500000"

# Intercontinental
"srt://:9000?latency=1000000"

# Cellulaire, satellite, SRTLA
"srt://:9000?latency=2000000"

Contrôle de la bande passante

# Limiter la bande passante totale à 10 Mbps
"srt://:9000?maxbw=10000000"

# Surcharge de bande passante pour les retransmissions (25% par défaut)
"srt://:9000?oheadbw=30"

# Mode automatique (SRT estime la bande passante)
"srt://:9000?maxbw=0"

Timeout de connexion

# Timeout de connexion à 5 secondes (en microsecondes)
"srt://serveur:9000?mode=caller&connect_timeout=5000000"

Monitoring avec ffprobe

ffprobe permet d’inspecter un flux SRT sans le consommer ni le modifier. C’est l’outil de diagnostic de première ligne.

Analyser un flux SRT

ffprobe -i "srt://serveur:9000?mode=caller" \
  -show_format -show_streams -print_format json

Cette commande affiche le codec vidéo et audio, la résolution, le débit, le nombre de programmes MPEG-TS et les métadonnées du flux.

Vérifier le débit en continu

ffprobe -i "srt://serveur:9000?mode=caller" \
  -show_entries frame=pkt_size,pkt_pts_time \
  -select_streams v:0 -of csv=p=0 2>/dev/null | \
  awk -F',' '{sum+=$1; count++} END {printf "Bitrate moyen: %.2f Mbps\n", (sum*8)/(count*0.033)/1000000}'

Vérifier la disponibilité d’un listener

ffprobe -v error -i "srt://serveur:9000?mode=caller&connect_timeout=3000000" \
  -show_entries stream=codec_name -of csv=p=0 2>&1

Si la commande renvoie un codec (par exemple h264), le listener est actif et envoie des données. Si elle échoue après le timeout, le listener est injoignable ou inactif.

Connexion à Vajra Cast

Vajra Cast fonctionne nativement comme listener et caller SRT. FFmpeg s’y connecte comme à n’importe quel endpoint SRT.

Pousser un flux vers Vajra Cast

ffmpeg -re -i source.ts \
  -c copy -f mpegts \
  "srt://vajracast.example.com:9000?mode=caller&latency=500000&passphrase=VotrePassphrase&pbkeylen=32"

Vajra Cast accepte le flux et permet ensuite de le router vers des sorties multiples (SRT, RTMP, HLS) depuis son interface web, avec surveillance des métriques SRT en temps réel.

Tirer un flux depuis Vajra Cast

ffmpeg -i "srt://vajracast.example.com:9001?mode=caller&latency=300000" \
  -c copy output.ts

Si Vajra Cast est configuré en listener sur un port de sortie, FFmpeg se connecte en caller pour récupérer le flux. Ce mode est pratique pour l’enregistrement distant ou l’alimentation d’un workflow de post-production.

Relayer vers Vajra Cast depuis un encodeur RTMP

ffmpeg -listen 1 -i rtmp://0.0.0.0:1935/live/stream \
  -c copy -f mpegts \
  "srt://vajracast.example.com:9000?mode=caller&passphrase=SecureKey&pbkeylen=32"

Cette configuration fait office de convertisseur de protocole local. Un encodeur ancien envoie du RTMP, FFmpeg le convertit et le pousse en SRT chiffré vers Vajra Cast.

Dépannage

”Protocol not found” ou “srt not found”

FFmpeg n’a pas été compilé avec libsrt. Vérifiez avec ffmpeg -protocols | grep srt. Si absent, recompilez FFmpeg avec --enable-libsrt.

”Connection rejected” côté caller

Causes possibles :

Le listener n’est pas démarré sur le port ciblé
Le pare-feu bloque le trafic UDP sur ce port
La passphrase ou pbkeylen ne correspondent pas entre caller et listener

Test rapide de connectivité UDP :

# Sur le serveur listener
nc -u -l 9000

# Depuis le caller
echo "test" | nc -u serveur 9000

Flux qui se connecte mais vidéo corrompue

Cause fréquente : le conteneur de sortie n’est pas MPEG-TS. SRT transporte du MPEG-TS, pas du FLV ni du MP4. Assurez-vous d’utiliser -f mpegts dans votre commande FFmpeg.

Latence réelle supérieure à la valeur configurée

C’est un comportement normal. Le paramètre latency contrôle uniquement le tampon de réception SRT. La latence totale inclut aussi le temps d’encodage, le tampon de gigue et le décodage. Pour la réduire, ajoutez -tune zerolatency à l’encodeur et réduisez le buffer du décodeur.

Perte de paquets élevée malgré un bon réseau

Vérifiez le paramètre maxbw. S’il est trop bas, SRT n’a pas assez de bande passante pour les retransmissions. Passez à maxbw=0 pour laisser SRT estimer automatiquement la bande passante nécessaire.

Le flux s’interrompt toutes les quelques secondes

Cause probable : absence du flag -re lors de la lecture d’un fichier. FFmpeg envoie les données à vitesse maximale, le tampon SRT déborde et le flux se coupe. Ajoutez -re avant -i pour lire au débit réel.

Dérive audio/vidéo sur les longs flux

Ajoutez -async 1 ou -fflags +genpts pour forcer la régénération des timestamps :

ffmpeg -fflags +genpts -i "srt://:9000?mode=listener" \
  -c copy -f mpegts \
  "srt://destination:9001?mode=caller"

FFmpeg reste l’outil de référence pour le traitement SRT en ligne de commande. Pour les workflows de production qui nécessitent une interface graphique, du monitoring en temps réel et du routage multi-destination sans scripts, Vajra Cast remplace avantageusement les chaînes FFmpeg complexes par une configuration visuelle.

← Retour aux Guides