Transcodage dans le développement mobile — ce que c’est, principe de fonctionnement et cas d’usage

Qu’est-ce que le Transcodage ?

Transcodage : processus de conversion d’un fichier multimédia d’un format de compression à un autre en décodant complètement le flux source dans un format PCM intermédiaire non compressé puis en encodant avec de nouveaux paramètres. Si le fichier source utilise le codec H.264 avec un débit de 10 Mbps et que la sortie nécessite du H.265 avec un débit de 3 Mbps — c’est du transcodage.

Le transcodage diffère du simple réempaquetage (transmultiplexage), où seul le conteneur change (ex. MP4 vers MKV) tandis que le flux binaire compressé reste inchangé. Le transcodage implique des opérations coûteuses en calcul : décodage de chaque image, application de filtres (mise à l’échelle, correction colorimétrique, recadrage) et ré-encodage avec de nouveaux paramètres. Cela fait du transcodage l’une des opérations les plus gourmandes en ressources lors du travail multimédia.

Le transcodage est utilisé dans une large gamme de tâches : adaptation de la vidéo aux limitations de bande passante, conversion vers un format avec décodage matériel sur l’appareil cible, création de plusieurs versions pour le streaming HLS/DASH, extraction de pistes audio dans un fichier séparé. Les services OTT (Netflix, YouTube, Twitch) transcodent chaque fichier téléchargé en des dizaines de variantes avec différents débits, résolutions et codecs pour fournir un streaming adaptatif à des millions d’utilisateurs.

Comment Fonctionne le Transcodage ?

Le processus de transcodage comprend trois étapes principales : décodage, traitement et encodage. Chaque étape peut être exécutée sur CPU ou sur des blocs GPU/matériels selon la disponibilité et les performances requises.

Étapes du Transcodage

La première étape est le décodage du flux source. Le fichier source est lu depuis le conteneur (MP4, MOV, MKV), après quoi les paquets vidéo compressés sont envoyés au décodeur. Le décodage peut être matériel (si le codec est supporté) ou logiciel via FFmpeg. La sortie du décodage est constituée d’images non compressées au format YUV420 ou BGRA — c’est à ce stade que le transcodage diffère du simple remultiplexage.

La deuxième étape est le filtrage et le traitement. Les images décodées passent par une chaîne de filtres : mise à l’échelle à la résolution cible, changement de fréquence d’images, correction colorimétrique, superposition de texte ou de graphiques. La chaîne de filtres FFmpeg est construite comme un graphe où chaque filtre est un module de traitement séparé. Par exemple, le filtre scale=1280:720 change la résolution, fps=30 change la fréquence d’images et yadif effectue le désentrelacement. Toutes les opérations sont effectuées sur des images non compressées, ce qui rend la deuxième étape la plus gourmande en ressources.

La troisième étape est l’encodage dans le format cible. Les images traitées sont envoyées à l’encodeur, qui les compresse selon l’algorithme du codec cible. L’encodeur peut être matériel (VideoToolbox sur iOS, MediaCodec sur Android) ou logiciel (libx264, libx265). Paramètres d’encodage : CRF (Constant Rate Factor) pour une qualité constante, débit binaire pour CBR/VBR, profil et niveau pour la compatibilité avec les appareils cibles.

// Schéma du pipeline de transcodage avec FFmpeg
AVFormatContext *inputCtx, *outputCtx;
AVCodecContext *decoderCtx, *encoderCtx;
AVFrame *frame = av_frame_alloc();
AVPacket packet;

while (av_read_frame(inputCtx, &packet) >= 0) {
    // 1. Décoder
    avcodec_send_packet(decoderCtx, &packet);
    avcodec_receive_frame(decoderCtx, frame);
    
    // 2. Filtrer (mise à l’échelle + changement fps)
    sws_scale(swsCtx, frame->data, frame->linesize,
              0, frame->height, scaledFrame->data,
              scaledFrame->linesize);
    
    // 3. Encoder
    avcodec_send_frame(encoderCtx, scaledFrame);
    avcodec_receive_packet(encoderCtx, &outPacket);
    av_interleaved_write_frame(outputCtx, &outPacket);
}

Le pipeline ci-dessus illustre le cycle classique de transcodage. La fonction av_read_frame lit les paquets compressés du fichier d’entrée, avcodec_send_packet les décode en images, sws_scale effectue la mise à l’échelle et avcodec_send_frame encode l’image traitée dans le format de sortie. Ce cycle en trois étapes se répète pour chaque image ou groupe d’images (GOP), selon les paramètres de l’encodeur.

Transcodage vs Transmultiplexage

La différence entre le transcodage et le transmultiplexage est l’un des points de confusion les plus courants dans l’ingénierie multimédia. Comprendre cette différence est essentiel pour choisir la bonne stratégie de traitement multimédia.

Transmultiplexage : réempaquetage d’un flux compressé dans un conteneur différent sans décodage ni ré-encodage. Si la vidéo est déjà compressée avec le codec H.265 dans un conteneur MP4 et doit être placée dans un conteneur MOV ou MKV — le transmultiplexage copie simplement les paquets du flux binaire d’un conteneur à l’autre. La qualité n’est pas affectée, le temps de traitement est minimal car aucun décodage d’image n’est nécessaire. FFmpeg effectue le transmultiplexage avec le flag -codec copy.

Transcodage, en revanche, décode et recompresse complètement le flux multimédia. Chaque fois qu’une vidéo subit un transcodage, une perte de génération (generation loss) peut se produire — une légère dégradation de la qualité due à une compression avec pertes répétée. Même au même débit, la troisième génération de transcodage est généralement moins bonne que la première. C’est pourquoi les professionnels recommandent de stocker les copies maîtres dans des formats non compressés ou minimalement compressés (ProRes, DNxHR) et de transcoder uniquement les versions finales pour la distribution.

Outils de Transcodage

Le choix de l’outil de transcodage dépend de la plateforme, des exigences de performance et du cas d’usage. Pour le développement mobile, les API natives et les bibliothèques multiplateformes sont disponibles.

FFmpeg — Outil Universel

FFmpeg est le standard de facto pour le transcodage sur toutes les plateformes. La ligne de commande FFmpeg permet d’effectuer pratiquement n’importe quelle conversion : changement de codec, ajustement de débit, découpage, concaténation, application de filtres. Pour les applications mobiles, FFmpeg est intégré via les bibliothèques libavformat, libavcodec et libavfilter. Exemple de commande typique de transcodage : ffmpeg -i input.mp4 -c:v libx265 -crf 23 -c:a aac -b:a 128k output.mp4.

API Plateforme

Sur iOS, le transcodage est effectué via AVAssetWriter et AVAssetReader. AVAssetReader décode le fichier source en lisant des images non compressées, et AVAssetWriter les encode dans le format cible. Cette approche utilise automatiquement les encodeurs matériels VideoToolbox, garantissant des performances maximales. Sur Android, des fonctionnalités similaires sont disponibles via MediaCodec associé à MediaExtractor et MediaMuxer — MediaExtractor extrait les paquets compressés, MediaCodec décode et encode, MediaMuxer écrit le résultat.

Services Cloud

Pour le transcodage côté serveur en environnement de production, des services cloud sont utilisés : AWS Elemental MediaConvert, Azure Media Services, Google Transcoder API. Ces services montent en charge automatiquement, supportent tous les formats populaires et peuvent transcoder un seul fichier d’entrée en dizaines de variantes de sortie pour le streaming adaptatif (HLS, DASH). Pour les applications mobiles, le transcodage cloud est la solution optimale car il ne sollicite pas l’appareil de l’utilisateur et permet une préparation asynchrone du contenu.

Exemples de Code de Transcodage

Examinons des exemples pratiques de transcodage sur plateformes mobiles utilisant l’accélération matérielle et la configuration des paramètres de qualité clés.

Transcodage H.264 vers H.265 sur iOS

import AVFoundation

func transcodeVideo(sourceURL: URL, destURL: URL) {
    let asset = AVAsset(url: sourceURL)
    let preset = AVAssetExportPresetHEVCHighestQuality
    
    AVAssetExportSession(asset: asset, presetName: preset)?
        .exportAsynchronously {
            switch assetExportSession?.status {
            case .completed:
                print("Transcodage terminé")
            case .failed:
                print("Erreur : " + assetExportSession.error.localizedDescription)
            default:
                break
            }
        }
    
    // Transcodage manuel avec AVAssetReader + AVAssetWriter
    let reader = try AVAssetReader(asset: asset)
    let writer = try AVAssetWriter(url: destURL,
        fileType: .mp4)
    
    let outputSettings: [String: Any] = [
        AVVideoCodecKey: AVVideoCodecType.hevc,
        AVVideoWidthKey: 1920,
        AVVideoHeightKey: 1080,
        AVVideoCompressionPropertiesKey: [
            AVVideoAverageBitRateKey: 4_000_000,
            AVVideoProfileLevelKey: AVVideoProfileLevelH265Main10
        ]
    ]
    
    let adaptor = AVAssetWriterInput(
        mediaType: .video,
        outputSettings: outputSettings
    )
    writer.add(adaptor)
}

L’exemple montre deux approches du transcodage sur iOS. AVAssetExportSession est un moyen simple avec des préréglages de qualité (HEVCHighestQuality pour H.265). Le pipeline manuel via AVAssetReader + AVAssetWriter offre un contrôle total sur les paramètres : débit, profil, niveau. Le paramètre AVVideoProfileLevelH265Main10 active le profil HDR Main10 avec une profondeur de couleur de 10 bits, ce qui est important pour le contenu HDR moderne.

Transcodage sur Android avec MediaCodec

class Transcoder(private val context: Context) {
    
    fun transcodeToHevc(inputUri: Uri, outputFile: File) {
        val extractor = MediaExtractor()
        extractor.setDataSource(context, inputUri, null)
        
        val trackFormat = extractor.getTrackFormat(videoTrackIndex)
        val mime = trackFormat.getString(MediaFormat.KEY_MIME)
        
        val decoder = MediaCodec.createDecoderByType(mime!!)
        val encoder = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_HEVC)
        
        val outputFormat = MediaFormat.createVideoFormat(
            MediaFormat.MIMETYPE_VIDEO_HEVC, 1920, 1080
        ).apply {
            setInteger(MediaFormat.KEY_BIT_RATE, 4_000_000)
            setInteger(MediaFormat.KEY_FRAME_RATE, 30)
            setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 2)
        }
        
        encoder.configure(outputFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
        encoder.start()
    }
}

Le code Android crée un pipeline de MediaExtractor — décodeur MediaCodec — encodeur MediaCodec — MediaMuxer. MediaExtractor détermine le type de codec à partir du fichier d’entrée et sélectionne le décodeur correspondant. L’encodeur est configuré pour H.265 (HEVC) avec un débit de 4 Mbps et un intervalle d’images clés de 2 secondes, ce qui est optimal pour le streaming. Important : l’encodeur MediaCodec fonctionne de manière synchrone, donc pour un transcodage en temps réel, une boucle avec une gestion correcte des horodatages (PTS) pour chaque image doit être implémentée.

Optimisation du Transcodage pour les Appareils Mobiles

Le transcodage sur les appareils mobiles est une tâche qui nécessite une optimisation minutieuse en raison des ressources CPU, GPU limitées et des contraintes thermiques. Plusieurs stratégies permettent d’effectuer le transcodage efficacement.

Utilisation de l’Encodage Matériel

Le facteur de performance clé est l’encodeur matériel. Sur iOS, VideoToolbox fournit un encodage matériel H.264 et H.265 à des vitesses 5 à 10 fois supérieures au libx264 logiciel. Sur Android, MediaCodec utilise les composants OMX matériels s’ils sont disponibles. L’activation de l’encodage matériel réduit le temps de transcodage d’une vidéo de 10 minutes de 30 à 40 minutes (logiciel) à 3 à 5 minutes (matériel) sur un appareil flagship.

Choix des Paramètres de Qualité

Pour le transcodage mobile, l’équilibre entre qualité, taille et temps de traitement est essentiel. Pour H.265 sur appareils mobiles, un débit de 4 à 8 Mbps est recommandé pour une vidéo 1080p à 30 FPS. Le mode CRF (Constant Rate Factor) dans libx265 permet de définir la qualité directement, où 23 à 28 offre une bonne qualité visuelle pour une taille de fichier modérée. Pour les encodeurs matériels, utilisez le mode CBR avec un débit cible car le CRF n’est pas supporté matériellement.

Gestion Thermique

Le transcodage continu sur un appareil mobile provoque un échauffement important. Après 5 à 7 minutes d’encodage intensif d’une vidéo 4K, la température du processeur peut atteindre 50 à 55 degrés, après quoi le throttling s’active. La solution : transcoder avec des pauses ou réduire la fréquence d’images à 30 FPS. Si l’application nécessite un transcodage par lots (ex. un éditeur vidéo), il est préférable de traiter par lots de 2 à 3 minutes avec des intervalles de refroidissement. Pour les scénarios de production, l’idéal est de déporter le transcodage côté serveur et d’utiliser des services cloud.