Une image n’a pas besoin de rentrer à la maison : comment KwaFlux garde la vidéo sur le GPU du décodage à l’encodage

L’essentiel

Un pipeline vidéo tout-GPU garde les pixels dans la mémoire du GPU du décodage à l’encodage, en passant par le traitement d’image et l’inférence IA, au lieu de les copier entre la mémoire système et la carte graphique. Moins de copies, ce sont des exports plus rapides, des aperçus plus fluides et un CPU au repos.

Dans ce guide, vous verrez comment le moteur multimédia de KwaFlux y parvient : un adaptateur d’images qui fait parler la même langue à neuf types d’image, la façon dont les décodeurs et encodeurs matériels de trois fabricants de GPU sont notés et choisis, l’échelle d’interopérabilité à cinq barreaux entre D3D11 et OpenGL, VideoToolbox et Metal sur Mac, et la manière dont le lecteur affiche le HDR. Nous terminons par le parcours complet d’un pixel au cours d’un export et par les réglages que vous pouvez modifier dans KwaFlux.

• Une image 4K en 10 bits et 4:2:0 pèse environ 24,9 Mo. À 60 i/s, chaque trajet entre la mémoire système et la mémoire du GPU déplace environ 1,5 Go par seconde. Plus il y a de trajets, plus l’export ralentit et plus l’aperçu saccade.
• Le moteur multimédia de KwaFlux donne à chaque image une carte d’identité : pointeur CUDA, texture D3D11, texture Metal ou mémoire système. Les couches supérieures ne voient qu’« une image », et quand une autre API en a besoin, le moteur choisit la passerelle la moins coûteuse.
• Sous Windows, le décodage et l’encodage matériels pour NVIDIA, Intel, AMD ainsi que D3D11 et D3D12 du système sont livrés sous forme de plug-ins. Ils sont notés selon le GPU, la mémoire et la résolution ; si l’un échoue, le suivant prend le relais, et le décodage logiciel récupère le reste.
• Une texture D3D11 rejoint OpenGL par une échelle à cinq barreaux : sans copie chez NVIDIA, presque sans copie chez AMD et Intel, un détour par CUDA, un transfert asynchrone et un repli sur le CPU. Les machines rapides prennent les barreaux du haut, les plus anciennes ceux du bas, et l’image continue de s’afficher dans les deux cas.
• Le sans-copie ne vaut pas pour tous les chemins : les deux barreaux du bas passent par la mémoire système. Un pipeline tout-GPU, c’est rester sur le GPU autant que possible et redescendre d’un cran quand ce n’est pas possible, plutôt qu’échouer.

Pourquoi renvoyer un pixel à la maison coûte cher

Un pixel rentre à la maison quand une image est copiée de la mémoire du GPU vers la mémoire système, traitée, puis renvoyée. Les décodeurs matériels écrivent l’image dans la mémoire du GPU, les modèles d’IA et les filtres d’image tournent sur le GPU, et les encodeurs matériels y lisent aussi. Il suffit qu’une seule étape intermédiaire n’accepte que des pixels en mémoire système pour que l’image fasse l’aller-retour par le PCIe.

Voici la taille d’une image (en 4:2:0, la chrominance ajoute la moitié de la taille de la luma) :

Le PCIe 4.0 x16 offre en théorie environ 31,5 Go/s dans chaque sens. Cela semble large, mais c’est un pic ; chaque copie attend aussi que le GPU termine son travail en cours et que le pilote se synchronise, et le CPU doit tout orchestrer. La moitié supérieure de la figure montre une approche courante : décodage, effets, IA et encodage veulent chacun leur mémoire, et une même image traverse cinq fois le PCIe pendant un seul export. En 4K 10 bits à 60 i/s, cela représente environ 7,5 Go par seconde rien qu’en copies.

L’adaptateur d’images : neuf types d’image, une seule interface

L’adaptateur d’images est une couche du moteur multimédia de KwaFlux qui fait qu’une image se présente de la même façon au lecteur, aux effets et aux encodeurs, quelle que soit la mémoire où elle se trouve réellement. Le logiciel multimédia est plein de dialectes : FFmpeg parle AVFrame, NVIDIA parle pointeurs de périphérique CUDA, les décodeurs matériels d’Intel et d’AMD livrent des textures D3D11, Vulkan parle VkImage et Apple CVPixelBuffer. Chacun a sa propre durée de vie, son alignement et sa disposition des couleurs.

Les couches supérieures reçoivent une seule interface d’image et, quand elles ont besoin d’une autre forme, la demandent ; c’est le moteur qui choisit la passerelle la moins coûteuse sur la machine. Quelques choix de conception évitent que l’ensemble se disloque au troisième fabricant de GPU :

• Les types sont fixés à la compilation. Une requête entre interfaces est une conversion statique, pas de l’information de type à l’exécution, donc rien ne se heurte aux frontières des DLL.
• Seules les images qui possèdent des ressources GPU portent des opérations GPU. Cloner, convertir et exporter vers une matrice appartiennent aux types d’image concrets, pas à l’interface commune.
• La propriété est explicite. Qui alloue libère, et les handles partagés ne sont pas libérés deux fois. Quand un périphérique GPU est reconstruit, les ressources d’interopérabilité qui en dépendent sont invalidées et reconstruites avec lui, si bien qu’aucune texture de l’ancien périphérique ne reste accrochée au nouveau.

Windows : décodage et encodage matériels chez trois fabricants de GPU

Sous Windows, KwaFlux installe huit plug-ins de décodage vidéo et six plug-ins d’encodage vidéo, chacun dans sa propre DLL. Après le démultiplexage, le sélecteur suit la configuration ; en mode automatique, il note chaque candidat, essaie d’abord celui qui a la note la plus haute, puis passe au suivant si l’initialisation échoue. Le décodage logiciel récupère tout ce qui reste.

Le tableau indique ce que gère chaque plug-in ; la capacité de votre GPU à décoder un codec en matériel dépend de sa génération. Selon la matrice de prise en charge de NVIDIA, par exemple, les cartes grand public ne décodent l’AV1 en matériel qu’à partir de la série RTX 30.

Ce que prend en compte la note. Un mauvais fabricant est éliminé d’emblée : sur un GPU qui n’est pas de NVIDIA, NVDEC n’obtient aucun point. Les décodeurs matériels perdent des points quand la mémoire du GPU est limitée, et avec un CPU puissant le décodage logiciel peut l’emporter, pour ne pas alourdir la machine juste pour pouvoir dire « matériel ». La 4K donne des points au matériel, car c’est précisément là que les unités à fonction fixe doivent travailler. Si l’affichage passe par D3D11, D3D11VA gagne des points, et décoder sur un autre GPU que celui qui pilote l’écran en fait perdre, car les copies entre GPU sont pénalisées.

L’encodage : l’encodeur prend ce que le décodeur a produit.

NVENC montre le plus clairement l’intérêt de l’adaptateur d’images : il n’exige pas que chaque image devienne d’abord CUDA. Une image CUDA fait une copie 2D sur le périphérique, une image D3D11 passe par l’interopérabilité, D3D12 passe par D3D11 pour atteindre CUDA, Vulkan utilise la mémoire externe et OpenGL une passerelle par tampon de pixels. Seule une image qui se trouvait déjà en mémoire système est transférée une fois vers le GPU. En HEVC et en AV1, les données de mastering HDR et de luminosité du contenu vont dans la configuration de l’encodeur ; H.264 n’a pas de champ natif pour cela, le plug-in les écrit donc lui-même dans les SEI.

À noter : selon la matrice de prise en charge de NVIDIA, les cartes GeForce dotées d’un encodeur acceptent au plus 12 sessions d’encodage simultanées. Quand elles sont épuisées, le plug-in NVENC de KwaFlux se retire et confie le travail à l’encodeur suivant, au lieu d’échouer en plein export.

Les plug-ins portent un contrôle de version et ne sont pas chargés en cas de différence, et la détection des capacités peut noter un plug-in sans le charger. Une nouvelle génération de GPU, c’est un plug-in de plus ; le lecteur et le convertisseur au-dessus ne changent pas.

L’échelle à cinq barreaux : faire passer une texture D3D11 dans OpenGL

Le décodeur et l’API d’affichage souvent, ne correspondent pas : NVIDIA décode en CUDA ou en D3D11 alors que l’image doit aller dans OpenGL, Intel décode en D3D11 alors qu’un filtre travaille sur une texture OpenGL. Le cœur graphique de KwaFlux construit la passerelle, et entre D3D11 et OpenGL c’est une échelle à cinq barreaux, gravie aussi haut que la machine le permet :

1. Sans copie chez NVIDIA. L’extension WGL_NV_DX_interop2 enregistre une texture D3D11 comme objet OpenGL ; une fois verrouillée, OpenGL la lit et l’écrit directement, sans passer par la mémoire système.
2. Presque sans copie chez AMD et Intel. Un handle partagé DXGI et l’extension GL_EXT_memory_object_win32 permettent aux deux API de voir la même mémoire GPU.
3. Détour par CUDA. D’abord vers CUDA, puis vers OpenGL ; les deux copies ont lieu sur le GPU.
4. Transfert asynchrone par pixel buffer objects (PBO). Fonctionne avec tous les fabricants ; le transfert chevauche la soumission des commandes, et le CPU ne fait que relayer.
5. Repli sur le CPU. Sur une machine sans aucune extension d’interopérabilité, l’image arrive malgré tout, simplement plus lentement.

À côté de l’échelle, il existe des passerelles dédiées. CUDA et D3D11 s’enregistrent mutuellement. D3D12 et D3D11 partagent leurs ressources par un handle partagé DXGI avec synchronisation par fence, si bien que D3D12 n’a pas besoin d’une passerelle directe vers chaque autre API. Vulkan et D3D11 utilisent la mémoire externe. Les noyaux CUDA de conversion des couleurs sont compilés dans la bibliothèque : NV12 et P016 deviennent du BGRA sur le GPU, et les images 10 bits peuvent rester en RGBA 16 bits au lieu d’être réduites à 8 bits dès l’entrée.

Mac : VideoToolbox décode, Metal affiche

Sous macOS, on ne se mesure pas à la longueur de la liste de plug-ins. Apple a intégré l’encodage et le décodage au moteur multimédia de ses puces, et KwaFlux branche ce moteur sur le même langage d’images :

• Le décodage passe par VideoToolbox, qui livre un CVPixelBuffer encapsulé en image CVPixel. Il couvre H.264, HEVC, VP9 et ProRes.
• L’encodage utilise h264_videotoolbox, hevc_videotoolbox et prores_videotoolbox ; les exports ProRes passent donc eux aussi par VideoToolbox.
• L’affichage passe par Metal. CAMetalLayer vérifie si l’écran prend en charge la plage dynamique étendue (EDR) : si oui, le HDR s’affiche via l’EDR ; sinon, les mêmes calculs de tone mapping que sous Windows ramènent le PQ ou le HLG en SDR.

Pour le lecteur, les effets et la conversion, une texture D3D11 sous Windows et un CVPixelBuffer sur Mac sont tous deux simplement « une image » : les fonctions ne se dédoublent pas en deux bases de code selon le système.

Le lecteur : l’audio donne l’heure, le HDR change à chaque image

L’audio sert d’horloge maîtresse. L’oreille tolère bien moins les à-coups que l’œil, donc l’image suit le son et non l’inverse. Entre deux rappels audio, l’horloge est interpolée linéairement sur le temps système et lissée par une moyenne mobile exponentielle, et les seuils sont proportionnels à l’intervalle entre images plutôt qu’à un nombre fixe de millisecondes. Chaque image reçoit l’une de trois décisions : attendre, dessiner ou abandonner. Ce qui est abandonné, c’est une image arrivée trop tard, pas votre position dans la vidéo.

Un déplacement dans la vidéo est une transaction. Le décodage est interrompu, les images périmées sont vidées, un numéro de génération tient les anciennes images à l’écart et l’horloge est réinitialisée ; l’horloge audio ne repart qu’une fois l’image à la nouvelle position réellement dessinée. Vous voyez l’endroit où vous êtes allé, pas la dernière seconde restée dans la file d’attente.

Le HDR ne s’active pas pour tout un fichier d’un coup. Chaque image est jugée selon sa propre caractéristique de transfert : seuls le PQ et le HLG demandent une swap chain HDR, et si la section suivante est en SDR, la swap chain repasse en SDR, pour qu’une image ordinaire ne soit pas traitée comme un signal PQ et ne devienne pas grise. Le HLG est converti en PQ dans un shader avant d’être envoyé à l’écran.

Le HDR sur un écran ordinaire. Les quatre backends partagent un seul tone mapper : le PQ ou le HLG est converti en luminance réelle en nits, passé en IPT, traité par des tables de tons et de gamut, puis restitué en BT.709 et sRGB. La table de tons suit le pic de l’image, mesuré sur une minuscule cible hors écran et relu sans bloquer le GPU, avec un lissage aux changements de scène. Quand un fichier n’indique pas de luminance de mastering, le mapper part de 1 000 nits plutôt que d’une constante flatteuse. Les sous-titres qui passent du sRGB à une swap chain HDR sont remontés au blanc de référence PQ, pour que le texte blanc ne paraisse pas gris sur les scènes lumineuses.

La lecture comparative sépare l’original et l’image traitée en deux pipelines, et chaque côté du séparateur garde son propre historique de luminosité : une scène de nuit à gauche n’assombrit donc pas la lumière du jour à droite. Pendant la lecture, les tâches de fond cèdent leur part du GPU et la reprennent progressivement à l’arrêt : la lecture en temps réel passe d’abord, les exports attendent leur tour.

libplacebo : mise à l’échelle, tone mapping et débanding

libplacebo est la bibliothèque de qualité d’image GPU issue du lecteur mpv. KwaFlux l’intègre comme nœud d’effet et choisit son backend selon l’image qui arrive : les images OpenGL, décodées par logiciel, CUDA et CVPixel passent par OpenGL ; le NV12 D3D11 va directement au backend D3D11, ce qui épargne une conversion de couleur aller-retour ; les images Vulkan restent dans Vulkan.

• L’agrandissement utilise EWA Lanczos et la réduction Lanczos, avec le bilinéaire quand la vitesse compte.
• Pour passer du HDR au SDR, on peut choisir les courbes BT.2390, Reinhard, Spline ou Hable, avec un pic mesuré sur l’image.
• Le débanding, le tramage et l’anti-ringing évitent que les dégradés du ciel ne se transforment en bandes.
• Le désentrelacement utilise une fenêtre temporelle composée de l’image précédente, de l’image courante et de la suivante, au lieu de deviner chaque image isolément.
• Les préréglages sont Rapide et Haute qualité : Rapide pour les aperçus et la mise à l’échelle avant encodage, Haute qualité pour le rendu final.

Les corrections automatiques (rotation, rapport d’aspect des pixels, entrelacement, position de la chrominance) et la mise à l’échelle avant encodage sont confiées d’abord à libplacebo. Quand un upscaling change la résolution, le nœud de mise à l’échelle reste placé avant l’encodeur, qui reçoit donc la taille cible. Si libplacebo ne démarre pas, les filtres FFmpeg scale, zscale et yadif prennent le relais, et un module manquant n’arrête pas le travail.

Le parcours idéal d’un pixel au cours d’un export

Mis bout à bout, un export sous Windows se déroule ainsi :

1. Le fichier est démultiplexé en paquets, et le sélecteur choisit le décodeur matériel adapté à la machine.
2. Les images naissent sous forme de pointeurs CUDA ou de textures D3D11, pas de blocs alloués en mémoire système.
3. La rotation, la correction du rapport d’aspect, le désentrelacement ou le tone mapping pour une version SDR sont faits par libplacebo sur le GPU.
4. Les modèles d’IA (upscaling, Réparation de qualité, SDR vers HDR et d’autres) traitent chaque image sur le GPU ; le type de l’image peut changer en route sans que le travail ait à savoir quelle passerelle elle a empruntée.
5. Si la résolution doit correspondre à une cible, une mise à l’échelle rapide supplémentaire a lieu.
6. Chaque encodeur reçoit les images à sa manière : NVENC prend du CUDA, oneVPL et AMF prennent du D3D11.
7. Les paquets entrent dans le multiplexeur, les horodatages sont ordonnés et le fichier est écrit.

En une phrase : le décodage matériel laisse une texture, l’interopérabilité en donne une vue à une autre API, le traitement d’image reste sur le GPU, et l’encodeur matériel lit ses images dans la même mémoire GPU. La mémoire système n’entre en jeu que si la machine n’a pas de passerelle plus haute, ou si une étape a réellement besoin de lire les pixels sur le CPU. C’est un repli, pas le centre de la conception.

Sur Mac, c’est la même phrase dans un autre dialecte : VideoToolbox décode dans le moteur multimédia, les images entrent dans le pipeline sous forme de CVPixelBuffer, Metal affiche le HDR via l’EDR, et les exports ProRes et HEVC repassent par VideoToolbox.

Les exports parallèles par segments découpent la timeline en morceaux, et chaque morceau suit ce même pipeline, pas un raccourci qui sauterait le traitement des couleurs pour aller plus vite.

Ce que vous pouvez régler dans KwaFlux

L’essentiel est automatique. Ces réglages modifient le fonctionnement :

• Décodage matériel (Paramètres › Performances) : Auto (par défaut), Activé ou Désactivé. Si un fichier se décode avec des défauts ou des erreurs, passez sur Désactivé pour diagnostiquer avec le décodage logiciel. Le changement s’applique après le redémarrage de l’app.
• Processeur d’IA (Paramètres › Performances) : utiliser le GPU pour le traitement IA ou laisser l’app décider. Le GPU est généralement plus rapide ; le choix s’applique au prochain export, au prochain aperçu ou à la prochaine génération de masque.
• Ressources utilisées par l’export IA : Charge légère (un seul flux, et un seul GPU sur les machines qui en ont plusieurs), Équilibré (par défaut), Pleine vitesse, ou un mode personnalisé (choix des GPU et du nombre de flux par GPU). Baisser le niveau s’applique tout de suite à un export en cours, sans perdre les segments déjà terminés.

Problèmes courants

Ce que cette architecture ne peut pas faire

• Le sans-copie sur tous les chemins. Les barreaux 4 et 5 de l’échelle passent par la mémoire système, et les GPU anciens ou les pilotes sans extensions d’interopérabilité y aboutissent.
• Reproduire le Dolby Vision. Côté HDR, ce qui tient la route, ce sont le HDR10 statique et le HLG.
• Une interopérabilité aussi complète que sous Windows sur Mac. Les points forts du Mac sont VideoToolbox, ProRes, les images CVPixel et l’EDR de Metal, pas autant de passerelles que sous Windows.
• Promettre un facteur d’accélération. Le gain apporté par moins de copies dépend du GPU, du pilote, de la résolution et des étapes de traitement ; prévisualisez et mesurez avec vos propres images.

Conclusion

Un pipeline tout-GPU n’est pas un slogan, c’est une table de routage capable de redescendre. Les machines rapides gardent les pixels sur le GPU de bout en bout, les plus lentes redescendent d’un cran à la fois et terminent quand même le travail. Au prochain export, jetez un œil à la charge du GPU et du CPU : vous saurez quel chemin vos pixels ont pris.

Testez sur vos propres images

KwaFlux exécute la Conversion de format et tous les outils d’IA sur votre propre GPU, en gardant le décodage, le traitement et l’encodage sur la carte graphique autant que possible. Le traitement IA tourne sur votre propre GPU et vos fichiers média ne sont pas envoyés pour être traités. KwaFlux fonctionne sous Windows 10 (64 bits, version 1809 ou plus récente), Windows 11 et macOS 12 ou plus récent sur Apple Silicon. Les aperçus ne demandent pas de compte : rendez un aperçu de 1, 3 ou 5 secondes sur n’importe quel clip. Une connexion avec un forfait payant n’est requise que pour exporter, convertir, réparer un fichier ou télécharger un fichier depuis un lien.

Télécharger KwaFlux · Voir les offres