Optimiser le streaming QuickTime avec Go et qt-faststart

Kevin van Zonneveld

Cofondateur · Amsterdam, Pays-Bas · Afficher la bio

Pour préparer un MP4 ou un MOV à la lecture HTTP progressive, utilisez le paquet os/exec de Go pour exécuter FFmpeg avec -c copy -movflags +faststart. Le programme ci-dessous crée un MP4 non fragmenté dont l’index de lecture précède les données multimédias, conserve le premier flux vidéo et tous les flux audio, et refuse toute sortie existante. Il utilise l’approche qtfaststart sans paquet Go tiers ni exécutable qt-faststart distinct.

Difficultés du streaming QuickTime

Les conteneurs MP4 et QuickTime stockent les informations dans des boîtes, aussi appelées atomes. La boîte moov contient les informations sur les pistes et les données temporelles ; mdat contient les données multimédias. Lorsque moov suit mdat, un lecteur peut avoir besoin d’une requête HTTP supplémentaire portant sur une plage d’octets pour récupérer l’index. Sans prise en charge de ces requêtes, il peut devoir télécharger le fichier avant de pouvoir lire cet index.

Déplacer moov avant mdat rend l’index disponible près du début d’un téléchargement séquentiel. La lecture dépend toujours de la mise en mémoire tampon, des codecs, du lecteur et du serveur HTTP. Cette opération modifie l’organisation du fichier ; elle ne constitue pas une mesure de référence du temps de démarrage ou du déplacement dans la lecture.

Utiliser l’opération de démarrage rapide de FFmpeg

FFmpeg propose à la fois l’utilitaire qt-faststart et l’option de multiplexeur -movflags +faststart. Cette dernière effectue une seconde passe pour déplacer l’index au début du fichier. Elle ne s’applique pas aux sorties fragmentées, comme l’explique la documentation du multiplexeur MOV/MP4⁠. Ce guide utilise le programme en ligne de commande FFmpeg pour le remultiplexage et confie à Go le stockage temporaire et la publication.

Configurer l’environnement Go

Utilisez un système de fichiers Linux prenant en charge les liens physiques, un répertoire de sortie accessible en écriture et un MP4 ou MOV local valide contenant de la vidéo. Les codecs vidéo et audio sélectionnés doivent être pris en charge par le multiplexeur MP4 et par le lecteur que vous comptez utiliser. La combinaison testée est une vidéo H.264 avec de l’audio AAC ; une extension .mov ne suffit pas à établir la compatibilité des codecs. Les commandes shell utilisent Bash et grep.

Installez Go⁠ et un paquet contenant à la fois FFmpeg et FFprobe⁠. FFprobe est un exécutable distinct utilisé pour l’inspection. Ces exemples ont été testés avec Go 1.26.8 et FFmpeg/FFprobe 9.0.1 sous Linux. Ce sont les versions testées, pas des versions minimales intrinsèquement requises ; utilisez des versions correctives maintenues de ces branches de versions. Les archives des versions de Go⁠ incluent la version de Go testée. Aucune initialisation de module ni dépendance Go tierce n’est nécessaire.

Avant d’enregistrer le programme, vérifiez que les trois commandes sont disponibles dans votre PATH :

go version && ffmpeg -version && ffprobe -version

Optimiser les fichiers QuickTime avec Go

Enregistrez ce programme sous le nom faststart.go dans votre répertoire de travail. Il effectue le remultiplexage dans un répertoire temporaire privé situé dans le répertoire de destination, puis crée un lien physique au chemin de sortie demandé. os.Link de Go⁠ assure cette étape de publication. Le fichier d’entrée est lu sans être remplacé, et toute sortie existante, y compris un lien symbolique, est refusée.

package main

import (
	"context"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"time"
)

func optimize(inputPath, outputPath string) error {
	input, err := filepath.EvalSymlinks(inputPath)
	if err != nil {
		return err
	}
	input, err = filepath.Abs(input)
	if err != nil {
		return err
	}
	info, err := os.Stat(input)
	if err != nil {
		return err
	}
	if !info.Mode().IsRegular() {
		return fmt.Errorf("input must be a regular local file")
	}
	parent, name := filepath.Split(outputPath)
	if name == "" {
		return fmt.Errorf("output must name a new file")
	}
	if parent == "" {
		parent = "."
	}
	parent, err = filepath.EvalSymlinks(parent)
	if err != nil {
		return err
	}
	parent, err = filepath.Abs(parent)
	if err != nil {
		return err
	}
	output := filepath.Join(parent, name)
	if _, err := os.Lstat(output); !os.IsNotExist(err) {
		return fmt.Errorf("output must not exist")
	}
	temporary, err := os.MkdirTemp(parent, ".faststart-")
	if err != nil {
		return err
	}
	defer os.RemoveAll(temporary)
	candidate := filepath.Join(temporary, "result.mp4")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
	defer cancel()
	cmd := exec.CommandContext(ctx, "ffmpeg", "-nostdin", "-n", "-i", input,
		"-map", "0:v:0", "-map", "0:a?", "-c", "copy", "-movflags", "+faststart", candidate)
	cmd.Stderr = os.Stderr
	if err := cmd.Run(); err != nil {
		return fmt.Errorf("fast-start conversion failed: %w", err)
	}
	if err := os.Link(candidate, output); err != nil {
		return fmt.Errorf("cannot publish result without overwriting: %w", err)
	}
	return nil
}

func main() {
	if len(os.Args) != 3 {
		fmt.Fprintln(os.Stderr, "Usage: go run faststart.go <input.mp4> <new-output.mp4>")
		os.Exit(1)
	}
	if err := optimize(os.Args[1], os.Args[2]); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	fmt.Println("Fast-start conversion complete")
}

Remplacez input.mp4 par le chemin de votre MP4 ou MOV local. Choisissez un nom de fichier de sortie qui n’existe pas ; la sortie est un MP4, quel que soit le conteneur d’entrée ou le suffixe du fichier de destination :

go run faststart.go input.mp4 output_optimized.mp4

En cas de réussite, le programme affiche Fast-start conversion complete. Les diagnostics de FFmpeg sont envoyés au terminal. Un échec du remultiplexage ou de la publication renvoie un code de sortie non nul ; dans ce cas, Go supprime son répertoire temporaire. Corrigez le problème signalé et réessayez avec un nouveau nom de sortie. Pour remultiplexer à nouveau la même entrée après une réussite, choisissez également un autre nom de sortie.

La sélection des flux est délibérée :

• -map 0:v:0 sélectionne le premier flux vidéo, même si un autre flux vidéo est marqué comme flux par défaut.
• -map 0:a? conserve tous les flux audio et autorise une entrée contenant uniquement de la vidéo.
• -c copy utilise la copie des flux⁠ sans réencodage.

Les sous-titres, les pistes de données et les flux vidéo supplémentaires sont exclus. Le remultiplexage peut modifier les métadonnées du conteneur et la représentation des paquets ; le fichier obtenu n’est donc pas une copie octet pour octet de l’entrée.

Vérifier le résultat

Inspectez les boîtes de premier niveau dans le nouveau fichier :

(
  set -o pipefail
  ffprobe -v trace output_optimized.mp4 2>&1 |
    grep -E "type:'(moov|mdat|moof)' parent:'root'"
)

Lisez les lignes dans l’ordre : moov doit précéder mdat, et cette sortie non fragmentée ne devrait contenir aucune boîte moof. Le format des traces est une sortie de diagnostic, pas une API stable pour un analyseur. Il s’agit d’une inspection manuelle avec la version de FFprobe testée. Remplacez le nom du fichier par celui de l’entrée pour inspecter son organisation avant de décider si un remultiplexage est nécessaire. Une entrée déjà optimisée produit tout de même un nouveau fichier lorsque vous exécutez ce programme.

Vérifiez les pistes sélectionnées, puis décodez l’intégralité de leur contenu pour détecter les erreurs qu’une inspection des en-têtes peut manquer :

ffprobe -v error -show_entries stream=codec_type,codec_name -of compact output_optimized.mp4 &&
  ffmpeg -nostdin -v error -xerror -i output_optimized.mp4 -map 0:v:0 -map '0:a?' -f null -

Vous devez obtenir un flux vidéo et le même nombre de flux audio que dans l’entrée. Le décodeur n’affiche rien lors d’une exécution sans erreur et se termine avec un code de sortie nul. Considérez tout diagnostic d’erreur comme un échec de la vérification, même si votre version compilée de FFmpeg renvoie zéro. Ces vérifications établissent l’organisation du fichier et la possibilité de le décoder avec FFmpeg, pas sa prise en charge par tous les lecteurs ; essayez le résultat dans le lecteur que vous comptez utiliser avant de le mettre à disposition.

Pièges courants et dépannage

• Codecs incompatibles : la copie des flux ne peut pas transformer un codec non pris en charge en codec pris en charge. Un MOV peut contenir de l’audio ou de la vidéo que le multiplexeur MP4 refuse. Si nécessaire, effectuez délibérément un transcodage dans un processus de traitement distinct ; ce programme ne bascule jamais vers l’encodage.
• Répertoire de sortie absent ou liens physiques non pris en charge : créez ou sélectionnez un répertoire accessible en écriture sur un système de fichiers prenant en charge les liens physiques. En cas d’erreur de publication, ce programme ne crée pas la destination demandée ; il ne remplace pas un fichier que quelqu’un d’autre y a créé.
• Espace disque et durée : prévoyez de la place pour l’original et un autre MP4 de taille approximativement similaire. Le démarrage rapide ajoute une seconde passe sur la sortie, et le programme limite l’exécution de FFmpeg à cinq minutes. Un dépassement de délai nécessite de corriger la cause ou d’ajuster délibérément cette limite.
• Entrée endommagée : la copie des flux ne décode ni ne répare la source. Un remultiplexage réussi ne prouve pas que chaque paquet était intact. Partez d’un média valide et inspectez les diagnostics de décodage.
• Processus interrompu : le nettoyage différé s’exécute lorsque la fonction Go retourne. Une interruption brutale du processus peut laisser un répertoire .faststart-* ; inspectez-le avant de le supprimer.

Le démarrage rapide prépare un fichier unique pour une diffusion progressive. HLS et DASH utilisent des manifestes et des segments multimédias ; déplacer la boîte moov de ce MP4 ne crée pas un ensemble de rendus pour le streaming adaptatif. Traitez cette tâche séparément de ce remultiplexage en MP4 non fragmenté.

Pour d’autres options de conteneur, consultez la référence des multiplexeurs FFmpeg⁠. Pour les fichiers téléversés non fiables, exécutez le traitement multimédia dans un processus isolé ; le délai maximal de l’exemple ne constitue pas à lui seul un environnement cloisonné.