Skia Color Management

What we mean by color management

All the color spaces Skia works with describe themselves by how to transform colors from that color space to a common “connection” color space called XYZ D50. And we can infer from that same description how to transform from that XYZ D50 space back to the original color space. XYZ D50 is a color space represented in three dimensions like RGB, but the XYZ parts are not RGB-like at all, rather a linear remix of those channels. Y is closest to what you‘d think of as brightness, but X and Z are a little more abstract. It’s kind of like YUV if you're familiar with that. The “D50” part refers to the whitepoint of this space, around 5000 Kelvin.

All color managed drawing is divided into six parts, three steps connecting the source colors to that XYZ D50 space, then three symmetric steps connecting back from XYZ D50 to the destination color space. Some of these steps can annihilate with each other into no-ops, sometimes all the way to the entire process amounting to a no-op when the source space and destination space are the same. Here are the steps:

Color management steps

  1. unpremultiply if the source color is premultiplied -- alpha is not involved in color management, and we need to divide it out if it's multiplied in
  2. linearize the source color using the source color space's transfer function
  3. convert those unpremultiplied, linear source colors to XYZ D50 gamut by multiplying by a 3x3 matrix
  4. convert those XYZ D50 colors to the destination gamut by multiplying by a 3x3 matrix
  5. encode that color using the inverse of the destination color space's transfer function
  6. premultiply by alpha if the destination is premultiplied

If you poke around in our code the clearest place to see this logic is in a type called SkColorSpaceXformSteps. You'll see it as 5 steps there: we always merge the innermost two operations into a single 3x3 matrix multiply.


Whenever we‘re about to do some drawing we look at which of those steps we really need to do. Any step that’s a fundamental no-op we skip:

  • skip 1 if the source is already unpremultiplied
  • skip 2 if the source is already linearly encoded
  • skip 3 and 4 if that single concatenated matrix is identity (i.e. the source and destination color spaces have the same gamut)
  • skip 5 if the destination wants linear encoding
  • skip 6 if the destination wants to be unpremultiplied

We can reason from those basic skips into some more advanced optimizations:

  • if we've skipped 3 and 4 already, we can skip 2 and 5 any time the transfer functions are the same -- sending colors through a given transfer function and its own inverse is a no-op
  • if we've skipped all of 2-5, we can skip 1 and 6 if we were going to do both --- no sense in unpremultiplying just to re-premultiply.
  • opaque colors can be treated as either unpremultiplied or premultiplied, whichever lets us skip more steps.

All this comes together to an impressive “nothing to do” most of the time. If you‘re drawing opaque colors in a given color space to a destination tagged with that same color space, we’ll notice we can skip all six steps. Sometimes fewer steps are needed, sometimes more. In general if you need to do a gamut conversion, you should generally expect all the middle steps to be active. Steps 2 and 5 are by far the most expensive to compute.

nullptr SkColorSpace defaults

Now how do nullptr SkColorSpace defaults work into all of this? We preface all that logic I've just mentioned above with this little snippet:

 if (srcCS == nullptr) { srcCS = sRGB; }
 if (dstCS == nullptr) { dstCS = srcCS; }

(Order matters there.) The gist is, we assume any untagged sources are sRGB. And if you leave your surface untagged, we act as if your destination fluidly matches whatever source you‘re trying to draw into it, which skips at least steps 2-5 as listed above, maintaining an unmanaged color mode of drawing compatible with how retro Skia used to work before we introduce color management. It’s not very principled, but it's handy in practice to keep around.