YUV

Y′UV signals are typically created from RGB (red, green and blue) source. Weighted values of R, G, and B are summed to produce Y′, a measure of overall brightness or luminance. U and V are computed as scaled differences between Y′ and the B and R values.

BT.601 defines the following constants:

${\displaystyle {\begin{aligned}W_{R}&=0.299,\\W_{G}&=1-W_{R}-W_{B}=0.587,\\W_{B}&=0.114,\\U_{\text{max}}&=0.436,\\V_{\text{max}}&=0.615.\end{aligned}}}$

Y′UV is computed from RGB (linear RGB, not gamma corrected RGB or sRGB for example) as follows:

${\displaystyle {\begin{aligned}Y'&=W_{R}R+W_{G}G+W_{B}B=0.299R+0.587G+0.114B,\\U&=U_{\text{max}}{\frac {B-Y'}{1-W_{B}}}\approx 0.492(B-Y'),\\V&=V_{\text{max}}{\frac {R-Y'}{1-W_{R}}}\approx 0.877(R-Y').\end{aligned}}}$

The resulting ranges of Y′, U, and V respectively are [0, 1], [−U_max, U_max], and [−V_max, V_max].

Inverting the above transformation converts Y′UV to RGB:

${\displaystyle {\begin{aligned}R&=Y'+V{\frac {1-W_{R}}{V_{\text{max}}}}=Y'+{\frac {V}{0.877}}=Y'+1.14V,\\G&=Y'-U{\frac {W_{B}(1-W_{B})}{U_{\text{max}}W_{G}}}-V{\frac {W_{R}(1-W_{R})}{V_{\text{max}}W_{G}}}\\&=Y'-{\frac {0.232U}{0.587}}-{\frac {0.341V}{0.587}}=Y'-0.395U-0.581V,\\B&=Y'+U{\frac {1-W_{B}}{U_{\text{max}}}}=Y'+{\frac {U}{0.492}}=Y'+2.033U.\end{aligned}}}$

Equivalently, substituting values for the constants and expressing them as matrices gives these formulas for BT.601:

${\displaystyle {\begin{aligned}{\begin{bmatrix}Y'\\U\\V\end{bmatrix}}&={\begin{bmatrix}0.299&0.587&0.114\\-0.14713&-0.28886&0.436\\0.615&-0.51499&-0.10001\end{bmatrix}}{\begin{bmatrix}R\\G\\B\end{bmatrix}},\\{\begin{bmatrix}R\\G\\B\end{bmatrix}}&={\begin{bmatrix}1&0&1.13983\\1&-0.39465&-0.58060\\1&2.03211&0\end{bmatrix}}{\begin{bmatrix}Y'\\U\\V\end{bmatrix}}.\end{aligned}}}$

Note that for small values of Y' it is possible to get R, G, or B values that are negative so in practice we clamp the RGB results to the interval [0,1].

HDTV Rec. 709 (quite close to SDTV Rec. 601) compared with UHDTV Rec. 2020

For HDTV the ATSC decided to change the basic values for W_R and W_B compared to the previously selected values in the SDTV system. For HDTV these values are provided by Rec. 709. This decision further impacted on the matrix for the Y′UV↔RGB conversion so that its member values are also slightly different. As a result, with SDTV and HDTV there are generally two distinct Y′UV representations possible for any RGB triple: a SDTV-Y′UV and a HDTV-Y′UV one. This means in detail that when directly converting between SDTV and HDTV, the luma (Y′) information is roughly the same but the representation of the chroma (U & V) channel information needs conversion. Still in coverage of the CIE 1931 color space the Rec. 709 color space is almost identical to Rec. 601 and covers 35.9%.[8] In contrast to this UHDTV with Rec. 2020 covers a much larger area and would further see its very own matrix set for YUV/Y′UV.

BT.709 defines these weight values:

${\displaystyle {\begin{aligned}W_{R}&=0.2126\\W_{B}&=0.0722\\\end{aligned}}}$

The conversion matrices & formulas for BT.709 are these:

${\displaystyle {\begin{aligned}{\begin{bmatrix}Y'\\U\\V\end{bmatrix}}&={\begin{bmatrix}0.2126&0.7152&0.0722\\-0.09991&-0.33609&0.436\\0.615&-0.55861&-0.05639\end{bmatrix}}{\begin{bmatrix}R\\G\\B\end{bmatrix}}\\{\begin{bmatrix}R\\G\\B\end{bmatrix}}&={\begin{bmatrix}1&0&1.28033\\1&-0.21482&-0.38059\\1&2.12798&0\end{bmatrix}}{\begin{bmatrix}Y'\\U\\V\end{bmatrix}}\end{aligned}}}$

• The weights used to compute Y′ (top row of matrix) are identical to those used in the Y′IQ color space.
• Equal values of red, green and blue (i.e. levels of gray) yield 0 for U and V. Black, RGB=(0, 0, 0), yields YUV=(0, 0, 0). White, RGB=(1, 1, 1), yields YUV=(1, 0, 0).
• These formulas are traditionally used in analog televisions and equipment; digital equipment such as HDTV and digital video cameras use Y′CbCr.
• The RGB input values are assumed to be in linear RGB space. Gamma corrected RGB, or sRGB need to be first converted properly into linear space.

• UV planes in a range of Y=[0,1] using the BT.709 matrix
• 
  Y′ value of 0
• 
  Y′ value of 0.5
• 
  Y′ value of 0.5, with untruncated gamut shown by the center rectangle
• 
  Y′ value of 1

For getting the traditional "studio-swing" 8-bit representation of Y′UV for SDTV/BT.601 the following operations can be used:

1. Basic transform from 8-bit RGB to 16-bit values (Y′: unsigned, U/V: signed, matrix values got rounded so that the later-on desired Y′ range of [16..235] and U/V range of [16..240] is reached):

${\displaystyle {\begin{bmatrix}Y'\\U\\V\end{bmatrix}}={\begin{bmatrix}66&129&25\\-38&-74&112\\112&-94&-18\end{bmatrix}}{\begin{bmatrix}R\\G\\B\end{bmatrix}}.}$

2. Scale down (">>8") to 8 bits with rounding ("+128") (Y′: unsigned, U/V: signed):

${\displaystyle {\begin{aligned}Yt'&=(Y'+128)\gg 8,\\Ut&=(U+128)\gg 8,\\Vt&=(V+128)\gg 8.\end{aligned}}}$

3. Add an offset to the values to eliminate any negative values (all results are 8-bit unsigned):

${\displaystyle {\begin{aligned}Yu'&=Yt'+16,\\Uu&=Ut+128,\\Vu&=Vt+128.\end{aligned}}}$

For getting a "full-swing" 8-bit representation of Y′UV for SDTV/BT.601 the following operations can be used:

1. Basic transform from 8-bit RGB to 16-bit values (Y′: unsigned, U/V: signed, matrix values got rounded so that the later-on desired Y′UV range of each [0..255] is reached whilst no overflow can happen):

${\displaystyle {\begin{bmatrix}Y'\\U\\V\end{bmatrix}}={\begin{bmatrix}77&150&29\\-43&-84&127\\127&-106&-21\end{bmatrix}}{\begin{bmatrix}R\\G\\B\end{bmatrix}}.}$

2. Scale down (">>8") to 8-bit values with rounding ("+128") (Y′: unsigned, U/V: signed):

${\displaystyle {\begin{aligned}Yt'&=(Y'+128)\gg 8,\\Ut&=(U+128)\gg 8,\\Vt&=(V+128)\gg 8.\end{aligned}}}$

3. Add an offset to the values to eliminate any negative values (all results are 8-bit unsigned):

${\displaystyle {\begin{aligned}Yu'&=Yt',\\Uu&=Ut+128,\\Vu&=Vt+128.\end{aligned}}}$

The function [R, G, B] = Y′UV444toRGB888(Y′, U, V) converts Y′UV format to simple RGB format.

The RGB conversion formulae used for Y′UV444 format are also applicable to the standard NTSC TV transmission format of YUV420 (or YUV422 for that matter). For YUV420, since each U or V sample is used to represent 4 Y samples that form a square, a proper sampling method can allow the utilization of the exact conversion formulae shown below. For more details, please see the 4:2:0 format demonstration in the bottom section of this article.

These formulae are based on the NTSC standard:

${\displaystyle {\begin{aligned}Y'&=0.299R+0.587G+0.114B\\U&=-0.147R-0.289G+0.436B\\V&=0.615R-0.515G-0.100B\end{aligned}}}$

On older, non-SIMD architectures, floating point arithmetic is much slower than using fixed-point arithmetic, so an alternative formulation is:[14]

${\displaystyle {\begin{aligned}Y'&=((66R+129G+25B+128)\gg 8)+16\\U&=((-38R-74G+112B+128)\gg 8)+128\\V&=((112R-94G-18B+128)\gg 8)+128\end{aligned}}}$

For the conversion from Y'UV to RGB, using the coefficients c, d and e, and noting that ${\displaystyle []_{0}^{255}}$ denotes clamping a value to the 8-bit range of 0 to 255, the following formulae provide the conversion from Y′UV to RGB (NTSC version):

${\displaystyle {\begin{aligned}c&=Y'-16\\d&=U-128\\e&=V-128\end{aligned}}}$

${\displaystyle {\begin{aligned}R&=[(298c+409e+128)\gg 8]_{0}^{255}\\G&=[(298c-100d-208e+128)\gg 8]_{0}^{255}\\B&=[(298c+516d+128)\gg 8]_{0}^{255}\end{aligned}}}$

Note: The above formulae are actually implied for YCbCr. Though the term YUV is used here, YUV and YCbCr are not exactly the same in a strict manner.

The ITU-R version of the formula is different, with ${\displaystyle \max(C_{B})=\max(C_{R})=0.499\mapsto \mathrm {7F} _{16}}$, whereas ${\displaystyle \max(U)=0.436\mapsto 70_{16}}$ and ${\displaystyle \max(V)=0.615\mapsto 70_{16}}$ above:

${\displaystyle {\begin{aligned}Y&=0.299R+0.587G+0.114B+0\\C_{B}&=-0.169R-0.331G+0.499B+128\\C_{R}&=0.499R-0.418G-0.0813B+128\\\\R&=[Y+1.402\times (C_{R}-128)]_{0}^{255}\\G&=[Y-0.344\times (C_{B}-128)-0.714\times (C_{R}-128)]_{0}^{255}\\B&=[Y+1.772\times (C_{B}-128)]_{0}^{255}\end{aligned}}}$

Integer operation of ITU-R standard for YCbCr(8 bits per channel) to RGB888:

${\displaystyle {\begin{aligned}C_{R}&=C_{R}-128;\\C_{B}&=C_{B}-128;\\R&=Y+C_{R}+(C_{R}\gg 2)+(C_{R}\gg 3)+(C_{R}\gg 5)\\G&=Y-((C_{B}\gg 2)+(C_{B}\gg 4)+(C_{B}\gg 5))-((C_{R}\gg 1)+(C_{R}\gg 3)+(C_{R}\gg 4)+(C_{R}\gg 5))\\B&=Y+C_{B}+(C_{B}\gg 1)+(C_{B}\gg 2)+(C_{B}\gg 6)\end{aligned}}}$

Input: Read 4 bytes of Y′UV (u, y1, v, y2)

Output: Writes 6 bytes of RGB (R, G, B, R, G, B)

u  = yuv[0];
y1 = yuv[1];
v  = yuv[2];
y2 = yuv[3];

${\displaystyle {YUV}_{422}={\begin{bmatrix}u&y_{1}\\v&y_{2}\end{bmatrix}}}$

${\displaystyle {YUV}_{444}={\begin{bmatrix}y_{1}&u&v\\y_{2}&u&v\end{bmatrix}}}$

${\displaystyle {RGB}=M^{-1}{YUV}_{444}}$

Using this information it could be parsed as regular Y′UV444 format to get 2 RGB pixels info:

rgb1 = Y′UV444toRGB888(y1, u, v);
rgb2 = Y′UV444toRGB888(y2, u, v);

Y′UV422 can also be expressed with the values in an alternative order, e.g. for the FourCC format code YUY2.

Input: Read 4 bytes of Y′UV (y1, u, y2, v), (y1, y2, u, v) or (u, v, y1, y2)

${\displaystyle {YUY}_{422}={\begin{bmatrix}y_{1}&u\\y_{2}&v\end{bmatrix}}}$

${\displaystyle {YYU}_{422}={\begin{bmatrix}y_{1}&y_{2}\\u&v\end{bmatrix}}}$

${\displaystyle {UVY}_{422}={\begin{bmatrix}u&v\\y_{1}&y_{2}\end{bmatrix}}}$

Input: Read 6 bytes of Y′UV

Output: Writes 12 bytes of RGB

// Extract YUV components
u  = yuv[0];
y1 = yuv[1];
y2 = yuv[2];
v  = yuv[3];
y3 = yuv[4];
y4 = yuv[5];

rgb1 = Y′UV444toRGB888(y1, u, v);
rgb2 = Y′UV444toRGB888(y2, u, v);
rgb3 = Y′UV444toRGB888(y3, u, v);
rgb4 = Y′UV444toRGB888(y4, u, v);

${\displaystyle {YUV}_{411}={\begin{bmatrix}u&y_{1}&y_{2}\\v&y_{3}&y_{4}\end{bmatrix}}}$

${\displaystyle {YUV}_{444}={\begin{bmatrix}y_{1}&u&v\\y_{2}&u&v\\y_{3}&u&v\\y_{4}&u&v\end{bmatrix}}}$

So the result is we are getting 4 RGB pixels values (4*3 bytes) from 6 bytes. This means reducing the size of transferred data to half, with a loss of quality.

Y′UV420p is a planar format, meaning that the Y′, U, and V values are grouped together instead of interspersed. The reason for this is that by grouping the U and V values together, the image becomes much more compressible. When given an array of an image in the Y′UV420p format, all the Y′ values come first, followed by all the U values, followed finally by all the V values.

The Y′V12 format is essentially the same as Y′UV420p, but it has the U and V data switched: the Y′ values are followed by the V values, with the U values last. As long as care is taken to extract U and V values from the proper locations, both Y′UV420p and Y′V12 can be processed using the same algorithm.

As with most Y′UV formats, there are as many Y′ values as there are pixels. Where X equals the height multiplied by the width, the first X indices in the array are Y′ values that correspond to each individual pixel. However, there are only one fourth as many U and V values. The U and V values correspond to each 2 by 2 block of the image, meaning each U and V entry applies to four pixels. After the Y′ values, the next X/4 indices are the U values for each 2 by 2 block, and the next X/4 indices after that are the V values that also apply to each 2 by 2 block.

As shown in the above image, the Y′, U and V components in Y′UV420 are encoded separately in sequential blocks. A Y′ value is stored for every pixel, followed by a U value for each 2×2 square block of pixels, and finally a V value for each 2×2 block. Corresponding Y′, U and V values are shown using the same color in the diagram above. Read line-by-line as a byte stream from a device, the Y′ block would be found at position 0, the U block at position x×y (6×4 = 24 in this example) and the V block at position x×y + (x×y)/4 (here, 6×4 + (6×4)/4 = 30).

This format (NV21) is the standard picture format on Android camera preview. YUV 4:2:0 planar image, with 8 bit Y samples, followed by interleaved V/U plane with 8bit 2x2 subsampled chroma samples.[15]

C++ code used on Android to convert pixels of YUVImage:[16]

void YUVImage::yuv2rgb(uint8_t yValue, uint8_t uValue, uint8_t vValue,
        uint8_t *r, uint8_t *g, uint8_t *b) const {
    int rTmp = yValue + (1.370705 * (vValue-128)); 
    // or fast integer computing with a small approximation
    // rTmp = yValue + (351*(vValue-128))>>8;
    int gTmp = yValue - (0.698001 * (vValue-128)) - (0.337633 * (uValue-128)); 
    // gTmp = yValue - (179*(vValue-128) + 86*(uValue-128))>>8;
    int bTmp = yValue + (1.732446 * (uValue-128));
    // bTmp = yValue + (443*(uValue-128))>>8;
    *r = clamp(rTmp, 0, 255);
    *g = clamp(gTmp, 0, 255);
    *b = clamp(bTmp, 0, 255);
}