Color Management [was: GSoC CM collaboration]

Graeme Gill graeme2 at
Wed Mar 5 18:02:42 PST 2008

Harald Braumann wrote:

> I'm not intimately familiar with the technical details, but from a user
> perspective I would expect that I create a colour profile for a monitor
> and then everything is colour corrected on that monitor.

It doesn't work like that. A profile doesn't correct color in itself,
it characterizes a device. To transform color from one device colorspace
to another, you need two profiles, one for each device color space.
Unless the colorspaces are identical, there are always choices to
be made in how the color is to be transformed, because they will
have different color gamuts. You have to choose what do do for
colors that fall inside one gamut (representable in one colorspace),
but not in the other. This choice depends on technology/algorithms/options
and intention.

> I guess I
> wouldn't get that result if I had to depend on every single GUI toolkit
> to implement colour matching.

You don't get quite the same result if you use different CMM's for color matching.
Generally a toolkit will use a CMM rather than implementing CMM functionality
itself, and it's the convention (established by ColorSync) to have CMM's
be pluggable. There's usually an allowance for an application choosing it's
desired CMM, or trying to use a CMM that best matches the creator of
a particular profile. Most passive CMM's do have fairly similar behaviour
for some profile classes, but sometimes there are bigger differences
when there are different interpretations of the standard. Active CMM's
would be expected to have more options and therefore more differences.

 >  If a window is displayed on multiple
> outputs, either in full or partially, I would also expect it to be
> colour corrected on each output. Now I'm not sure if that is at all
> possible with the current architecture, as the window would have to be
> rendered independently for each output, but it sure would be nice.
> Anyway, you couldn't achieve this at the application level. 

Yes, that's the desired result. Yes you can achieve it at the application
level, if the application is responsible for rendering the different bits
on different windows (response to exposure events). The trend is away from
such an arrangement though, with such details now being taken care of by a
compositing engine. This is probably a good thing, because many application
writers can't be bothered implementing such things properly.

Graeme Gill.

More information about the xorg mailing list