Partager via

Formats YUV 8 bits recommandés pour le rendu vidéo

Gary Sullivan et Stephen Estrop

Microsoft Corporation

Avril 2002, mise à jour de novembre 2008

Cette rubrique décrit les formats de couleur YUV 8 bits recommandés pour le rendu vidéo dans le système d’exploitation Windows. Cet article présente des techniques de conversion entre les formats YUV et RVB, et fournit également des techniques pour le suréchantillonnage des formats YUV. Cet article est destiné à toute personne travaillant avec le décodage ou le rendu vidéo YUV dans Windows.

Présentation

De nombreux formats YUV sont définis dans l’industrie vidéo. Cet article identifie les formats YUV 8 bits recommandés pour le rendu vidéo dans Windows. Les fournisseurs de décodeur et les fournisseurs d’affichage sont encouragés à prendre en charge les formats décrits dans cet article. Cet article ne traite pas d’autres utilisations de la couleur YUV, telles que la photographie fixe.

Les formats décrits dans cet article utilisent tous 8 bits par emplacement de pixel pour encoder le canal Y (également appelé canal luma) et 8 bits par exemple pour encoder chaque échantillon de couleur U ou V. Toutefois, la plupart des formats YUV utilisent moins de 24 bits par pixel en moyenne, car ils contiennent moins d’échantillons de vous et de V que de Y. Cet article ne couvre pas les formats YUV avec des canaux Y 10 bits ou supérieurs.

Remarque

Dans le cadre de cet article, le terme U équivaut à Cb, et le terme V équivaut à Cr.

 

Cet article aborde les thèmes suivants :

Échantillonnage YUV

Les canaux Chroma peuvent avoir un taux d’échantillonnage inférieur à celui du canal luma, sans perte spectaculaire de qualité perceptive. Une notation appelée notation « A :B :C » est utilisée pour décrire la fréquence à laquelle U et V sont échantillonnés par rapport à Y :

  • 4:4:4 signifie pas d’échantillonnage inférieur des canaux chromaiques.
  • 4:2:2 signifie un sous-échantillonnage horizontal de 2:1, sans sous-échantillonnage vertical. Chaque ligne d’analyse contient quatre échantillons Y pour chaque deux échantillons U ou V.
  • 4:2:0 signifie un sous-échantillonnage horizontal de 2:1, avec un sous-échantillonnage vertical de 2:1.
  • 4:1:1 signifie 4:1 sous-échantillonnage horizontal, sans sous-échantillonnage vertical. Chaque ligne de balayage contient quatre échantillons Y pour chaque échantillon U et V. L’échantillonnage 4:1:1 est moins courant que d’autres formats et n’est pas abordé en détail dans cet article.

Les diagrammes suivants montrent comment la chrominance est échantillonnée pour chacun des taux de sous-échantillonnage. Les échantillons Luma sont représentés par une croix, et les échantillons de chroma sont représentés par un cercle.

figure 1. échantillonnage chromatique

La forme dominante de l’échantillonnage 4:2:2 est définie dans la Recommandation ITU-R BT.601. Il existe deux variantes courantes de l’échantillonnage 4:2:0. L’un d’eux est utilisé dans la vidéo MPEG-2, et l’autre est utilisé dans MPEG-1 et dans ITU-T les recommandations H.261 et H.263.

Par rapport au schéma MPEG-1, il est plus simple de convertir entre le schéma MPEG-2 et les grilles d’échantillonnage définies pour les formats 4:2:2 et 4:4:4. Pour cette raison, le schéma MPEG-2 est préféré dans Windows et doit être considéré comme l’interprétation par défaut des formats 4:2:0.

Définitions de surface

Cette section décrit les formats YUV 8 bits recommandés pour le rendu vidéo. Celles-ci appartiennent à plusieurs catégories :

Tout d’abord, vous devez connaître les concepts suivants pour comprendre ce qui suit :

  • Origine de la surface. Pour les formats YUV décrits dans cet article, l’origine (0,0) est toujours le coin supérieur gauche de la surface.
  • Stride. Le pas d’une surface, parfois également appelé pitch, correspond à la largeur de la surface exprimée en octets. Compte tenu d’une origine de la surface dans le coin supérieur gauche, la foulée est toujours positive.
  • Alignement. L’alignement d’une surface est à la discrétion du pilote d’affichage graphique. La surface doit toujours être alignée sur DWORD ; cela garantit que les différentes lignes à l'intérieur de la surface proviennent d'une limite de 32 bits (DWORD). L’alignement peut être supérieur à 32 bits, cependant, en fonction des besoins du matériel.
  • Format packé par rapport au format planaire. Les formats YUV sont divisés en formats emballés et en formats planaires . Dans un format pack, les composants Y, U et V sont stockés dans un tableau unique. Les pixels sont organisés en groupes de macropixels, dont la disposition dépend du format. Dans un format planaire, les composants Y, U et V sont stockés sous forme de trois plans distincts.

Chacun des formats YUV décrits dans cet article a un code FOURCC affecté. Un code FOURCC est un entier non signé de 32 bits créé en concaténant quatre caractères ASCII.

Formats 4:4:4, 32 Bits par pixel

AYUV

Un format unique 4:4:4 est recommandé, avec le code FOURCC AYUV. Il s’agit d’un format pack, où chaque pixel est encodé sous forme de quatre octets consécutifs, organisés dans la séquence illustrée dans l’illustration suivante.

figure 2. disposition de la mémoire ayuv

Les octets marqués A contiennent des valeurs pour alpha.

Formats 4:4:4, 24 Bits par pixel

I444

Au format I444, tous les exemples Y apparaissent en premier dans la mémoire sous la forme d’un tableau de valeurs char non signées. Ce tableau est suivi immédiatement par tous les échantillons U (Cb). Le pas de l’avion U est le même pas du plan Y ; et le plan U contient le même nombre de lignes que le plan Y. Le plan U est suivi immédiatement par tous les échantillons V (Cr), avec la même progression et le même nombre de lignes que le plan U. Il n'y a pas de remplissage pour les plans Y/U/V.

Diagramme illustrant la disposition de mémoire I444.

Formats 4:2:2, 16 bits par pixel

Deux formats 4:2:2 sont recommandés, avec les codes FOURCC suivants :

  • YUY2
  • UYVY

Les deux sont des formats packed, où chaque macropixel est codé en deux pixels sous la forme de quatre octets consécutifs. Cela entraîne le sous-échantillonnage horizontal de la chrominance par un facteur de deux.

YUY2

Au format YUY2, les données peuvent être traitées comme un tableau de valeurs char non signées, où le premier octet contient le premier échantillon Y, le deuxième octet contient le premier échantillon U (Cb), le troisième octet contient le deuxième échantillon Y et le quatrième octet contient le premier échantillon V (Cr), comme illustré dans le diagramme suivant.

Diagramme illustrant la disposition de mémoire yuy2

Si l’image est traitée sous la forme d’un tableau de valeurs WORD little-endian, le premier WORD contient le premier échantillon Y dans les bits les moins significatifs (LSB) et le premier échantillon U (Cb) dans les bits les plus significatifs (MSB). Le second WORD contient le deuxième échantillon Y dans les LSB et le premier échantillon V (Cr) dans les MSB.

YUY2 est le format de pixel préféré 4:2:2 pour Microsoft DirectX Video Acceleration (DirectX VA). Il s'agit d'une exigence à moyen terme pour les accélérateurs DirectX VA prenant en charge la vidéo 4:2:2.

UYVY

Ce format est identique au format YUY2, à l’exception de l’ordre d’octets inversé, c’est-à-dire que les octets chroma et luma sont retournés (Figure 4). Si l’image est traitée sous la forme d’un tableau de deux valeurs WORD little endian, la première valeur WORD contient U dans les LSB et Y0 dans les MSB, et la deuxième valeur WORD contient V dans les LSB et Y1 dans les MSB.

Diagramme illustrant la disposition de la mémoire uyvy

I422

Au format I422, tous les exemples Y apparaissent en premier dans la mémoire sous la forme d’un tableau de valeurs char non signées. Ce tableau est suivi immédiatement par tous les échantillons U (Cb). Le pas de l’avion U est la moitié du pas du plan Y ; et le plan U contient le même nombre de lignes que le plan Y. Le plan U est suivi immédiatement par tous les exemples V (Cr), avec la même progression et le même nombre de lignes que le plan U, comme illustré dans l’illustration suivante. Il n'y a pas de remplissage pour les plans Y/U/V.

Diagramme illustrant la disposition de mémoire I422.

Formats 4:2:0, 16 Bits par pixel

Deux formats de 4:2:0 16 bits par pixel (bpp) sont recommandés, avec les codes FOURCC suivants :

  • IMC1
  • IMC3

Ces deux formats YUV sont des formats planaires. Les canaux chromatiques sont sous-échantillonnés par un facteur de deux dans les dimensions horizontales et verticales.

IMC1

Tous les exemples Y apparaissent d’abord en mémoire sous la forme d’un tableau de valeurs char non signées. Ceci est suivi de tous les exemples V (Cr), puis de tous les échantillons U (Cb). Les plans V et U ont la même progression que le plan Y, ce qui entraîne des zones de mémoire inutilisées, comme illustré dans la figure 5. Les plans U et V doivent débuter sur des limites de mémoire qui sont un multiple de 16 lignes. La figure 5 montre l’origine de U et V pour une image vidéo de 352 x 240. L’adresse de départ des plans U et V sont calculées comme suit :

BYTE* pV = pY + (((Height + 15) & ~15) * Stride);
BYTE* pU = pY + (((((Height * 3) / 2) + 15) & ~15) * Stride);

où pY est un pointeur d’octet au début du tableau de mémoire, comme illustré dans le diagramme suivant.

Diagramme illustrant la disposition de mémoire imc1 (exemple)

IMC3

Ce format est identique à IMC1, sauf que les plans U et V sont échangés, comme le montre le diagramme suivant.

Diagramme illustrant la disposition de la mémoire imc3

Formats 4:2:0, 12 bits par pixel

Quatre formats 4:2:0 12-bpp sont recommandés, avec les codes FOURCC suivants :

  • IMC2
  • IMC4
  • YV12
  • NV12

Dans tous ces formats, les canaux chromatique sont sous-échantillonnés par un facteur de deux dans les dimensions horizontales et verticales.

IMC2

Ce format est identique à IMC1 à l'exception suivante : les lignes V (Cr) et U (Cb) sont entrelacées aux limites de demi-pas. En d’autres termes, chaque ligne de foulée complète dans la zone chromatique commence par une ligne d’échantillons V, suivie d’une ligne d’échantillons U qui commence à la limite de demi-foulée suivante (Figure 7). Cette disposition permet d’utiliser plus efficacement l’espace d’adressage que IMC1. Il réduit l’espace d’adressage chroma de moitié, réduisant ainsi l’espace d’adressage total de 25 pour cent. Parmi les formats 4:2:0, IMC2 est le deuxième format préféré, après NV12. Le schéma suivant illustre ce processus.

Diagramme illustrant la disposition de la mémoire imc2

IMC4

Ce format est identique à IMC2, à l’exception des lignes U (Cb) et V (Cr) qui sont échangées, comme montré dans l’illustration suivante.

Diagramme illustrant la disposition de la mémoire imc4

YV12

Tous les exemples Y apparaissent d’abord en mémoire sous la forme d’un tableau de valeurs char non signées. Ce tableau est suivi immédiatement par tous les échantillons V (Cr). Le pas du plan V est la moitié du pas du plan Y ; et le plan V contient la moitié autant de lignes que le plan Y. Le plan V est suivi immédiatement par tous les échantillons U (Cb), avec la même progression et le même nombre de lignes que le plan V, comme illustré dans l’illustration suivante.

Diagramme illustrant la disposition de la mémoire yv12

NV12

Tous les exemples Y apparaissent d’abord en mémoire sous la forme d’un tableau de valeurs de caractères non signées avec un nombre pair de lignes. Le plan Y est suivi immédiatement d’un tableau de valeurs char non signées qui contient des échantillons U (Cb) et V (Cr). Lorsque le tableau U-V combiné est traité en tant que tableau de valeurs WORD peu endiennes, les LSB contiennent les valeurs U et les MSB contiennent les valeurs V. NV12 est le format de 4:2:0 pixel préféré pour DirectX VA. Il est prévu qu’il s’agit d’une exigence intermédiaire pour les accélérateurs DirectX VA prenant en charge la vidéo 4:2:0. L'illustration suivante montre le plan Y et la matrice qui contient des échantillons U et V empaquetés.

Diagramme illustrant la disposition de mémoire nv12

Conversions d’espace de couleur et de taux d’échantillonnage chromatique

Cette section fournit des instructions pour la conversion entre YUV et RVB, et pour la conversion entre certains formats YUV différents. Nous considérons deux schémas d’encodage RVB dans cette section : RVB d’ordinateur 8 bits, également appelé RVB standard ou RVB à grande échelle, et RVB vidéo studio ou « RVB avec headroom et toeroom ». Ils sont définis comme suit :

  • Le RVB de l’ordinateur utilise 8 bits pour chaque échantillon de rouge, vert et bleu. Le noir est représenté par R = G = B = 0, et le blanc est représenté par R = G = B = 255.
  • Studio vidéo RGB utilise un nombre de bits, N, pour chaque échantillon de rouge, de vert et de bleu, avec N étant de 8 ou plus. Le RGB vidéo Studio utilise une échelle différente de celle de l’RGB d'ordinateur, et il a un décalage. Le noir est représenté par R = G = B = 16*2^(N-8), et le blanc est représenté par R = G = B = 235*2^(N-8). Toutefois, les valeurs réelles peuvent se trouver en dehors de cet intervalle.

Studio video RGB est la définition RVB préférée pour la vidéo dans Windows, tandis que l’ordinateur RVB est la définition RVB préférée pour les applications non vidéo. Sous l’une ou l’autre forme de RVB, les coordonnées de chromatique sont spécifiées dans ITU-R BT.709 pour la définition des primaires de couleur RVB. Les coordonnées (x,y) de R, G et B sont respectivement (0,64, 0,33), (0,30, 0,60) et (0,15, 0,06). Le blanc de référence est D65 avec des coordonnées (0,3127, 0,3290). Le gamma nominal est 1/0,45 (environ 2,2), avec un gamma précis défini en détail dans ITU-R BT.709.

Conversion entre RVB et 4:4:4 YUV

Nous décrivons d’abord la conversion entre RVB et 4:4:4 YUV. Pour convertir 4:2:0 ou 4:2:2 YUV en RVB, nous vous recommandons de convertir les données YUV en 4:4:4 YUV, puis de convertir de 4:4:4 YUV en RVB. Le format AYUV, qui est un format 4:4:4, utilise 8 bits chacun pour les exemples Y, U et V. YUV peut également être défini en utilisant plus de 8 bits par échantillon pour certaines applications.

Deux conversions YUV dominantes de RVB ont été définies pour la vidéo numérique. Les deux sont basés sur la spécification appelée ITU-R Recommandation BT.709. La première conversion est la forme YUV plus ancienne définie pour une utilisation à 50 Hz dans BT.709. Il est identique à la relation spécifiée dans ITU-R Recommandation BT.601, également connue par son ancien nom, CCIR 601. Il doit être considéré comme le format YUV préféré pour la résolution tv de définition standard (720 x 576) et la vidéo à résolution inférieure. Elle est caractérisée par les valeurs de deux constantes Kr et Kb :

Kr = 0.299
Kb = 0.114

La deuxième conversion est la forme YUV la plus récente définie pour une utilisation de 60-Hz en BT.709 et doit être considérée comme le format préféré pour les résolutions vidéo au-dessus de SDTV. Elle est caractérisée par des valeurs différentes pour ces deux constantes :

Kr = 0.2126
Kb = 0.0722

La conversion de RVB en YUV est définie en commençant par les éléments suivants :

L = Kr * R + Kb * B + (1 - Kr - Kb) * G

Les valeurs YUV sont ensuite obtenues comme suit :

Y =                   floor(2^(M-8) * (219*(L-Z)/S + 16) + 0.5)
U = clip3(0, (2^M)-1, floor(2^(M-8) * (112*(B-L) / ((1-Kb)*S) + 128) + 0.5))
V = clip3(0, (2^M)-1, floor(2^(M-8) * (112*(R-L) / ((1-Kr)*S) + 128) + 0.5))

où

  • M correspond au nombre de bits par échantillon YUV (M >= 8).
  • Z est la variable de niveau noir. Pour le RVB de l’ordinateur, Z est égal à 0. Pour le RVB vidéo studio, Z est égal à 16*2^(N-8), où N correspond au nombre de bits par échantillon RVB (N >= 8).
  • S est la variable de mise à l’échelle. Pour l’ordinateur RVB, S est égal à 255. Pour le schéma RVB vidéo studio, S est égal à 219*2^(N-8).

La fonction floor(x) retourne le plus grand entier inférieur ou égal à x. La fonction clip3(x, y, z) est définie comme suit :

clip3(x, y, z) = ((z < x) ? x : ((z > y) ? y : z))

Remarque

Clip3 doit être implémenté en tant que fonction plutôt qu’une macro de préprocesseur ; sinon, plusieurs évaluations des arguments se produisent.

 

L’exemple Y représente la luminosité, et les échantillons you et V représentent les écarts de couleur vers le bleu et le rouge, respectivement. La plage nominale de Y est de 16*2^(M-8) à 235*2^(M-8). Le noir est représenté sous la forme 16*2^(M-8), et le blanc est représenté comme 235*2^(M-8). La plage nominale pour vous et V est de 16*2^(M-8) à 240*2^(M-8), avec la valeur 128*2^(M-8) représentant la couleur neutre. Toutefois, les valeurs réelles peuvent se trouver en dehors de ces plages.

Pour les données d'entrée au format de RVB vidéo de studio, l'opération de clipping est nécessaire pour maintenir les valeurs U et V dans la plage de 0 à (2^M)-1. Si l'entrée est au format RVB informatique, l'opération de découpe n'est pas nécessaire, car la formule de conversion ne peut pas produire de valeurs en dehors de cette plage.

Il s’agit des formules exactes sans approximation. Tout ce qui suit dans ce document est dérivé de ces formules. Cette section décrit les conversions suivantes :

Conversion de RGB888 en YUV 4:4:4

Dans le cas de l’entrée RVB de l’ordinateur et de la sortie YUV BT.601 8 bits, nous pensons que les formules fournies dans la section précédente peuvent être raisonnablement approximatives par les éléments suivants :

Y = ( (  66 * R + 129 * G +  25 * B + 128) >> 8) +  16
U = ( ( -38 * R -  74 * G + 112 * B + 128) >> 8) + 128
V = ( ( 112 * R -  94 * G -  18 * B + 128) >> 8) + 128

Ces formules produisent des résultats sur 8 bits à l'aide de coefficients qui ne nécessitent pas plus de 8 bits de précision (non signée). Les résultats intermédiaires nécessitent jusqu’à 16 bits de précision.

Conversion de YUV 8 bits en RGB888

À partir des formules RVB à YUV d’origine, vous pouvez dériver les relations suivantes pour BT.601.

Y = round( 0.256788 * R + 0.504129 * G + 0.097906 * B) +  16 
U = round(-0.148223 * R - 0.290993 * G + 0.439216 * B) + 128
V = round( 0.439216 * R - 0.367788 * G - 0.071427 * B) + 128

Par conséquent, étant donné :

C = Y - 16
D = U - 128
E = V - 128

les formules permettant de convertir YUV en RVB peuvent être dérivées comme suit :

R = clip( round( 1.164383 * C                   + 1.596027 * E  ) )
G = clip( round( 1.164383 * C - (0.391762 * D) - (0.812968 * E) ) )
B = clip( round( 1.164383 * C +  2.017232 * D                   ) )

où clip() désigne le clippage dans une plage de [0..255]. Nous pensons que ces formules peuvent être raisonnablement approximatives par les éléments suivants :

R = clip(( 298 * C           + 409 * E + 128) >> 8)
G = clip(( 298 * C - 100 * D - 208 * E + 128) >> 8)
B = clip(( 298 * C + 516 * D           + 128) >> 8)

Ces formules utilisent des coefficients qui nécessitent plus de 8 bits de précision pour produire chacun un résultat de 8 bits, et les résultats intermédiaires nécessiteront plus de 16 bits de précision.

Pour convertir 4:2:0 ou 4:2:2 YUV en RVB, nous vous recommandons de convertir les données YUV en 4:4:4 YUV, puis de convertir de 4:4:4 YUV en RVB. Les sections qui suivent présentent certaines méthodes pour convertir les formats 4:2:0 et 4:2:2 en 4:4:4.

Conversion de 4:2:0 YUV à 4:2:2 YUV

La conversion de YUV 4:2:0 à YUV 4:2:2 nécessite une upconversion verticale par un facteur de deux. Cette section décrit un exemple de méthode pour effectuer la mise à jour. La méthode part du principe que les images vidéo sont en balayage progressif.

Remarque

Le processus de conversion entrelacée des analyses de 4:2:0 à 4:2:2 présente des problèmes atypiques et il est difficile à mettre en œuvre. Cet article ne traite pas de la conversion du balayage entrelacé de 4:2:0 à 4:2:2.

 

Laissez chaque ligne verticale d’échantillons de couleur d’entrée être un tableau Cin[] allant de 0 à N - 1. La ligne verticale correspondante sur l’image de sortie est un tableau Cout[] allant de 0 à 2N - 1. Pour convertir chaque ligne verticale, procédez comme suit :

Cout[0]     = Cin[0];
Cout[1]     = clip((9 * (Cin[0] + Cin[1]) - (Cin[0] + Cin[2]) + 8) >> 4);
Cout[2]     = Cin[1];
Cout[3]     = clip((9 * (Cin[1] + Cin[2]) - (Cin[0] + Cin[3]) + 8) >> 4);
Cout[4]     = Cin[2]
Cout[5]     = clip((9 * (Cin[2] + Cin[3]) - (Cin[1] + Cin[4]) + 8) >> 4);
...
Cout[2*i]   = Cin[i]
Cout[2*i+1] = clip((9 * (Cin[i] + Cin[i+1]) - (Cin[i-1] + Cin[i+2]) + 8) >> 4);
...
Cout[2*N-3] = clip((9 * (Cin[N-2] + Cin[N-1]) - (Cin[N-3] + Cin[N-1]) + 8) >> 4);
Cout[2*N-2] = Cin[N-1];
Cout[2*N-1] = clip((9 * (Cin[N-1] + Cin[N-1]) - (Cin[N-2] + Cin[N-1]) + 8) >> 4);

où clip() désigne le découpage en une plage de [0..255].

Remarque

Les équations permettant de gérer les arêtes peuvent être simplifiées mathématiquement. Ils sont présentés sous cette forme pour illustrer l’effet de pincement aux bords de l’image.

 

En effet, cette méthode calcule chaque valeur manquante en interpolant la courbe sur les quatre pixels adjacents, pondérée vers les valeurs des deux pixels les plus proches (figure 11). La méthode d'interpolation spécifique utilisée dans cet exemple génère des échantillons manquants à des positions intermédiaires à l'aide d'une méthode bien connue appelée interpolation Catmull-Rom, également appelée interpolation par convolution cubique.

Un diagramme illustrant le suréchantillonnage de 4:2:0 à 4:2:2

En termes de traitement des signaux, la mise à jour verticale doit idéalement inclure une compensation de décalage de phase pour tenir compte du décalage vertical demi-pixel (par rapport à la grille d’échantillonnage de sortie 4:2:2) entre les emplacements des lignes d’échantillon 4:2:0 et l’emplacement de chaque autre ligne d’échantillon de 4:2:2. Toutefois, l’introduction de ce décalage augmente la quantité de traitement requise pour générer les échantillons et rend impossible la reconstruction des échantillons d’origine 4:2:0 à partir de l’image upsampled 4:2:2. Il serait également impossible de décoder la vidéo directement dans des surfaces 4:2:2, puis d’utiliser ces surfaces comme images de référence pour décoder les images suivantes dans le flux. Par conséquent, la méthode fournie ici ne tient pas compte de l’alignement vertical précis des échantillons. Cela n’est probablement pas visuellement dangereux à des résolutions d’image raisonnablement élevées.

Si vous commencez par une vidéo 4:2:0 qui utilise la grille d’échantillonnage définie dans H.261, H.263 ou MPEG-1 vidéo, la phase des échantillons de chroma 4:2:2 de sortie sera également décalée par un décalage horizontal demi-pixel par rapport à l’espacement sur la grille d’échantillonnage luma (décalage de quart de pixel par rapport à l’espacement de la grille d’échantillonnage chroma 4:2:2). Toutefois, la forme MPEG-2 de 4:2:0 vidéo est probablement plus couramment utilisée sur les PC et ne souffre pas de ce problème. De plus, la distinction n’est probablement pas visuellement néfaste à des résolutions d’image raisonnablement élevées. Essayer de corriger ce problème créerait le même type de problèmes abordés pour le décalage de phase verticale.

Conversion de 4:2:2 YUV à 4:4:4 YUV

La conversion de YUV 4:2:2 à YUV 4:4:4 nécessite une upconversion horizontale par un facteur de deux. La méthode décrite précédemment pour la conversion ascendante verticale peut également être appliquée à la conversion ascendante horizontale. Pour MPEG-2 et la vidéo BT.601 de type ITU-R, cette méthode produira des échantillons avec l’alignement de phase correct.

Conversion de 4:2:0 YUV à 4:4:4 YUV

Pour convertir 4:2:0 YUV à 4:4:4 YUV, vous pouvez simplement suivre les deux méthodes décrites précédemment. Convertissez l’image 4:2:0 en 4:2:2, puis convertissez l’image 4:2:2 en 4:4:4. Vous pouvez également inverser l’ordre des deux processus de conversion ascendante, car l'ordre des opérations n'a pas d'importance significative pour la qualité visuelle du résultat.

Conversion de YUY2 en I422

Pour le format de couleur 4:2:2, certains décodeurs peuvent générer par défaut le format MFVideoFormat_YUY2, qui est un format compact. Toutefois, de nombreux encodeurs attendent une entrée au format planaire MFVideoFormat_I422. Dans de tels cas, le processeur de transcodage vidéo Media Foundation Transform (communément appelé « XVP ») peut être inséré dans le pipeline pour convertir MFVideoFormat_YUY2 en MFVideoFormat_I422. Pour plus d’informations, consultez Transcoding Video Processor Media Foundation Transform. Cet exemple montre comment utiliser XVP pour effectuer cette conversion pour les workflows d’encodage.

#include <mfapi.h> 
#include <wmcodecdsp.h>  // CLSID_VideoProcessorMFT 

using Microsoft::WRL; 

HRESULT ConvertYUY2toI422WithXVP( 
    _In_ IMFSample* inputSample, 
    _In_ MFT_OUTPUT_DATA_BUFFER* outputBuffer, 
    UINT32 width, 
    UINT32 height)
{ 
    RETURN_HR_IF_NULL(E_INVALIDARG, inputSample);     
    RETURN_HR_IF_NULL(E_INVALIDARG, outputBuffer);     

    ComPtr<IMFTransform> xvp; 
    RETURN_IF_FAILED(CoCreateInstance( 
        CLSID_VideoProcessorMFT, 
        nullptr, 
        CLSCTX_INPROC_SERVER, 
        IID_PPV_ARGS(&xvp))); 

    // Set input type: MFVideoFormat_YUY2 
    ComPtr<IMFMediaType> inputType; 
    RETURN_IF_FAILED(MFCreateMediaType(&inputType)); 
    RETURN_IF_FAILED(inputType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video)); 
    RETURN_IF_FAILED(inputType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_YUY2)); 
    RETURN_IF_FAILED(MFSetAttributeSize(inputType.Get(), MF_MT_FRAME_SIZE, width, height)); 
    RETURN_IF_FAILED(spXVP->SetInputType(0, inputType.Get(), 0)); 

    // Set output type: MFVideoFormat_I422 
    ComPtr<IMFMediaType> outputType; 
    RETURN_IF_FAILED(MFCreateMediaType(&outputType)); 
    RETURN_IF_FAILED(outputType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video)); 
    RETURN_IF_FAILED(outputType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_I422)); 
    RETURN_IF_FAILED(MFSetAttributeSize(outputType.Get(), MF_MT_FRAME_SIZE, width, height)); 
    RETURN_IF_FAILED(xvp->SetOutputType(0, outputType.Get(), 0)); 

    // Submit input sample 
    RETURN_IF_FAILED(xvp->ProcessInput(0, inputSample, 0)); 

    // Request the converted output sample 
    DWORD status = 0; 
    return xvp->ProcessOutput(0, 1, outputBuffer, &status);
}

Conversion d’AYUV en I444

Pour le format de couleur 4:4:4, certains décodeurs peuvent générer MFVideoFormat_AYUV par défaut, qui est un format compact. Toutefois, de nombreux encodeurs attendent une entrée au format planaire MFVideoFormat_I444. Dans de tels cas, le processeur de transcodage vidéo Media Foundation Transform (XVP) peut être inséré dans le pipeline afin de convertir MFVideoFormat_AYUV en MFVideoFormat_I444. Cet exemple montre comment utiliser XVP pour effectuer cette conversion pour les workflows d’encodage.

#include <mfapi.h> 
#include <wmcodecdsp.h>  // CLSID_VideoProcessorMFT 

using Microsoft::WRL; 

HRESULT ConvertAYUVtoI444WithXVP( 
    _In_ IMFSample* inputSample, 
    _In_ MFT_OUTPUT_DATA_BUFFER* outputBuffer, 
    UINT32 width, 
    UINT32 height) 
{ 
    RETURN_HR_IF_NULL(E_INVALIDARG, inputSample);     
    RETURN_HR_IF_NULL(E_INVALIDARG, outputBuffer);     

    ComPtr<IMFTransform> xvp; 
    RETURN_IF_FAILED(CoCreateInstance( 
        CLSID_VideoProcessorMFT, 
        nullptr, 
        CLSCTX_INPROC_SERVER, 
        IID_PPV_ARGS(&xvp))); 

    // Set input type: MFVideoFormat_AYUV 
    ComPtr<IMFMediaType> inputType; 
    RETURN_IF_FAILED(MFCreateMediaType(&inputType)); 
    RETURN_IF_FAILED(inputType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video)); 
    RETURN_IF_FAILED(inputType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_AYUV)); 
    RETURN_IF_FAILED(MFSetAttributeSize(inputType.Get(), MF_MT_FRAME_SIZE, width, height)); 
    RETURN_IF_FAILED(xvp->SetInputType(0, inputType.Get(), 0)); 

    // Set output type: MFVideoFormat_I444 
    ComPtr<IMFMediaType> outputType; 
    RETURN_IF_FAILED(MFCreateMediaType(&outputType)); 
    RETURN_IF_FAILED(outputType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video)); 
    RETURN_IF_FAILED(outputType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_I444)); 
    RETURN_IF_FAILED(MFSetAttributeSize(outputType.Get(), MF_MT_FRAME_SIZE, width, height)); 
    RETURN_IF_FAILED(xvp->SetOutputType(0, outputType.Get(), 0)); 

    // Submit input sample 
    RETURN_IF_FAILED(xvp->ProcessInput(0, inputSample, 0)); 

    // Request the converted output sample 
    DWORD status = 0; 
    return xvp->ProcessOutput(0, 1, outputBuffer, &status); 
}

Autres formats YUV

D’autres formats YUV moins courants sont les suivants :

  • AI44 est un format YUV palettisé avec 8 bits par échantillon. Chaque échantillon contient un index dans les 4 bits les plus significatifs (MSB) et une valeur alpha dans les 4 bits les moins significatifs (LSB). L’index fait référence à un tableau d’entrées de palette YUV, qui doivent être définies dans le type de média pour le format. Ce format est principalement utilisé pour les images de sous-image.
  • NV11 est un format planaire de 4:1:1 avec 12 bits par pixel. Les échantillons Y apparaissent d’abord en mémoire. Le plan Y est suivi d’un tableau d’échantillons compressés U (Cb) et V (Cr). Lorsque le tableau U-V combiné est traité sous la forme d’un tableau de valeurs WORD little endian, les échantillons U sont contenus dans les LSB de chaque WORD, et les échantillons V sont contenus dans les MSB. (Cette disposition de mémoire est similaire à NV12 bien que l’échantillonnage chromatique soit différent.)
  • Le format Y41P est un format compressé 4:1:1, avec un échantillonnage U et V tous les quatre pixels à l'horizontale. Chaque macropixel contient 8 pixels en trois octets, avec la disposition d’octet suivante : U0 Y0 V0 Y1 U4 Y2 V4 Y3 Y4 Y5 Y6 Y7
  • Y41T est identique à Y41P, sauf que le bit le moins significatif de chaque échantillon Y spécifie la clé chromatique (0 = transparent, 1 = opaque).
  • Y42T est identique à UYVY, sauf que le bit le moins significatif de chaque échantillon Y spécifie la clé chromatique (0 = transparent, 1 = opaque).
  • YVYU équivaut à YUYV, sauf que les échantillons U et V sont échangés.

Identification des formats YUV dans Media Foundation

Chacun des formats YUV décrits dans cet article a un code FOURCC affecté. Un code FOURCC est un entier non signé de 32 bits créé en concaténant quatre caractères ASCII.

Il existe plusieurs macros C/C++ qui facilitent la déclaration des valeurs FOURCC dans le code source. Par exemple, la macro MAKEFOURCC est déclarée dans Mmsystem.h, et la macro FCC est déclarée dans Aviriff.h. Utilisez-les comme suit :

DWORD fccYUY2 = MAKEFOURCC('Y','U','Y','2');
DWORD fccYUY2 = FCC('YUY2');

Vous pouvez également déclarer un code FOURCC directement en tant que littéral de chaîne en inversant simplement l'ordre des caractères. Par exemple:

DWORD fccYUY2 = '2YUY';  // Declares the FOURCC 'YUY2'

Inverser l’ordre est nécessaire, car le système d’exploitation Windows utilise une architecture little-endian. « Y » = 0x59, « U » = 0x55, et « 2 » = 0x32, donc « 2YUY » est 0x32595559.

Dans Media Foundation, les formats sont identifiés par un GUID de type principal et un GUID de sous-type. Le type principal pour les formats vidéo d’ordinateur est toujours MFMediaType_Video . Le sous-type peut être construit en mappant le code FOURCC à un GUID, comme suit :

XXXXXXXX-0000-0010-8000-00AA00389B71

où XXXXXXXX est le code FOURCC. Par conséquent, le GUID de sous-type pour YUY2 est :

32595559-0000-0010-8000-00AA00389B71

Les constantes des GUID de format YUV les plus courantes sont définies dans le fichier d’en-tête mfapi.h. Pour obtenir la liste de ces constantes, consultez les GUID de sous-type vidéo.

À propos de la vidéo YUV

Types de médias vidéo