Gamma Correction vs. Premultiplied Pixels
Pixels with 8 bits per channel are normally sRGB encoded because that
allocates more bits to darker colors where human vision is the most
sensitive. (Actually, it’s really more of a historical accident, but
sRGB nevertheless remains useful for this reason). The relationship
between sRGB and linear RGB is that you get an sRGB pixel by raising
each component of a linear pixel to the power of
A lot of graphics software does alpha blending directly on these sRGB pixels using alpha values that are linearly coded (ie., an alpha value of 0 means no coverage, 0.5 means half coverage, and 1 means full coverage). Because alpha blending is best done with premultiplied pixels, such systems store pixels in this format:
[ alpha, alpha * red_s, alpha * green_s, alpha * blue_s ]
where alpha is linearly coded, and (red_s
, green_s
, blue_s
) are
sRGB coded. As long as you are happy with blending in sRGB, this works
well. Also, if you simply discard the alpha channel of such pixels and
display them directly on a monitor, it will look as if the pixels were
alpha blended (in the sRGB space) on top of a black background, which
is the desired result.
But what if you want to blend in linear RGB? If you use the format
above, some expensive conversions will be required. To convert to
premultiplied linear, you have to first divide by alpha, then raise
each color to 2.2, then multiply by alpha. To convert back, you must
divide by alpha, raise to
The conversions can be avoided if you store the pixels linearly, ie., keeping the premultiplication, but coding red, green, and blue linearly instead of as sRGB. This makes blending fast, but the downside is that you need deeper pixels. With only 8 bits per pixel, the linear coding loses too much precision in darker tones. Another problems is that to display these pixels, you will either have to convert them to sRGB, or if the video card can scan them out directly, you have to make sure that the gamma ramp is set to compensate for the fact that the monitor expects sRGB pixels.
Can we get the best of both worlds? Yes. The format to use is this:
[ alpha, alpha_s * red_s, alpha_s * green_s, alpha_s * blue_s ]
That is, the alpha channel is stored linearly, and the color channels are stored in sRGB, premultiplied with the alpha value raised to 1/2.2. Ie., the red component is now
(red * alpha)^(1/2.2),
where before it was
alpha * red^(1/2.2).
It is sufficient to use 8 bits per channel with this format because of the sRGB encoding. Discarding the alpha channel and displaying the pixels on a monitor will produce pixels that are alpha blended (in linear space) against black, as desired.
You can convert to linear RGB simply by raising the R, G, and B
components to 2.2, and back by raising to
This is also the pixel format to use with texture samplers that implement the sRGB OpenGL extensions (textures and framebuffers). These extensions say precisely that the R, G, and B components are raised to 2.2 before texture filtering, and raised to 1/2.2 after the final raster operation.