SkColorSpace Class Reference

#include <SkColorSpace.h>

Inheritance diagram for SkColorSpace:

Public Member Functions
void	toProfile (skcms_ICCProfile *) const
bool	gammaCloseToSRGB () const
bool	gammaIsLinear () const
bool	isNumericalTransferFn (skcms_TransferFunction *fn) const
bool	toXYZD50 (skcms_Matrix3x3 *toXYZD50) const
uint32_t	toXYZD50Hash () const
sk_sp< SkColorSpace >	makeLinearGamma () const
sk_sp< SkColorSpace >	makeSRGBGamma () const
sk_sp< SkColorSpace >	makeColorSpin () const
bool	isSRGB () const
sk_sp< SkData >	serialize () const
size_t	writeToMemory (void *memory) const
void	transferFn (float gabcdef[7]) const
void	transferFn (skcms_TransferFunction *fn) const
void	invTransferFn (skcms_TransferFunction *fn) const
void	gamutTransformTo (const SkColorSpace *dst, skcms_Matrix3x3 *src_to_dst) const
uint32_t	transferFnHash () const
uint64_t	hash () const
Public Member Functions inherited from SkNVRefCnt< SkColorSpace >
	SkNVRefCnt ()
	~SkNVRefCnt ()
bool	unique () const
void	ref () const
void	unref () const
void	deref () const
bool	refCntGreaterThan (int32_t threadIsolatedTestCnt) const

Static Public Member Functions
static sk_sp< SkColorSpace >	MakeSRGB ()
static sk_sp< SkColorSpace >	MakeSRGBLinear ()
static sk_sp< SkColorSpace >	MakeRGB (const skcms_TransferFunction &transferFn, const skcms_Matrix3x3 &toXYZ)
static sk_sp< SkColorSpace >	Make (const skcms_ICCProfile &)
static sk_sp< SkColorSpace >	Deserialize (const void *data, size_t length)
static bool	Equals (const SkColorSpace *, const SkColorSpace *)

Friends
class	SkColorSpaceSingletonFactory

Detailed Description

Definition at line 107 of file SkColorSpace.h.

Member Function Documentation

Deserialize()

sk_sp< SkColorSpace > SkColorSpace::Deserialize ( const void *  data, size_t  length  )

static

Definition at line 266 of file SkColorSpace.cpp.

                                                                             {
    if (length < sizeof(ColorSpaceHeader)) {
        return nullptr;
    }
 
    ColorSpaceHeader header = *((const ColorSpaceHeader*) data);
    data = SkTAddOffset<const void>(data, sizeof(ColorSpaceHeader));
    length -= sizeof(ColorSpaceHeader);
    if (header.fVersion != k1_Version) {
        return nullptr;
    }
 
    if (length < 16 * sizeof(float)) {
        return nullptr;
    }
 
    skcms_TransferFunction transferFn;
    memcpy(&transferFn, data, 7 * sizeof(float));
    data = SkTAddOffset<const void>(data, 7 * sizeof(float));
 
    skcms_Matrix3x3 toXYZ;
    memcpy(&toXYZ, data, 9 * sizeof(float));
    return SkColorSpace::MakeRGB(transferFn, toXYZ);
}

Equals()

bool SkColorSpace::Equals ( const SkColorSpace *  x, const SkColorSpace *  y  )

static

If both are null, we return true. If one is null and the other is not, we return false. If both are non-null, we do a deeper compare.

Definition at line 291 of file SkColorSpace.cpp.

                                                                      {
    if (x == y) {
        return true;
    }
 
    if (!x || !y) {
        return false;
    }
 
    if (x->hash() == y->hash()) {
    #if defined(SK_DEBUG)
        // Do these floats function equivalently?
        // This returns true more often than simple float comparison   (NaN vs. NaN) and,
        // also returns true more often than simple bitwise comparison (+0 vs. -0) and,
        // even returns true more often than those two OR'd together   (two different NaNs).
        auto equiv = [](float X, float Y) {
            return (X==Y)
                || (std::isnan(X) && std::isnan(Y));
        };
 
        for (int i = 0; i < 7; i++) {
            float X = (&x->fTransferFn.g)[i],
                  Y = (&y->fTransferFn.g)[i];
            SkASSERTF(equiv(X,Y), "Hash collision at tf[%d], !equiv(%g,%g)\n", i, X,Y);
        }
        for (int r = 0; r < 3; r++)
        for (int c = 0; c < 3; c++) {
            float X = x->fToXYZD50.vals[r][c],
                  Y = y->fToXYZD50.vals[r][c];
            SkASSERTF(equiv(X,Y), "Hash collision at toXYZD50[%d][%d], !equiv(%g,%g)\n", r,c, X,Y);
        }
    #endif
        return true;
    }
    return false;
}

gammaCloseToSRGB()

bool SkColorSpace::gammaCloseToSRGB

(

)

const

Returns true if the color space gamma is near enough to be approximated as sRGB.

Definition at line 151 of file SkColorSpace.cpp.

                                          {
    // Nearly-equal transfer functions were snapped at construction time, so just do an exact test
    return memcmp(&fTransferFn, &SkNamedTransferFn::kSRGB, 7*sizeof(float)) == 0;
}

gammaIsLinear()

bool SkColorSpace::gammaIsLinear

(

)

const

Returns true if the color space gamma is linear.

Definition at line 156 of file SkColorSpace.cpp.

                                       {
    // Nearly-equal transfer functions were snapped at construction time, so just do an exact test
    return memcmp(&fTransferFn, &SkNamedTransferFn::kLinear, 7*sizeof(float)) == 0;
}

gamutTransformTo()

void SkColorSpace::gamutTransformTo	(	const SkColorSpace *	dst,
		skcms_Matrix3x3 *	src_to_dst
	)		const

Definition at line 142 of file SkColorSpace.cpp.

                                                                                              {
    dst->computeLazyDstFields();
    *src_to_dst = skcms_Matrix3x3_concat(&dst->fFromXYZD50, &fToXYZD50);
}

hash()

uint64_t SkColorSpace::hash ( ) const

inline

Definition at line 222 of file SkColorSpace.h.

{ return (uint64_t)fTransferFnHash << 32 | fToXYZD50Hash; }

invTransferFn()

void SkColorSpace::invTransferFn

(

skcms_TransferFunction *

fn

)

const

Definition at line 132 of file SkColorSpace.cpp.

                                                                 {
    this->computeLazyDstFields();
    *fn = fInvTransferFn;
}

isNumericalTransferFn()

bool SkColorSpace::isNumericalTransferFn

(

skcms_TransferFunction *

fn

)

const

Sets |fn| to the transfer function from this color space. Returns true if the transfer function can be represented as coefficients to the standard ICC 7-parameter equation. Returns false otherwise (eg, PQ, HLG).

Definition at line 116 of file SkColorSpace.cpp.

                                                                             {
    // TODO: Change transferFn/invTransferFn to just operate on skcms_TransferFunction (all callers
    // already pass pointers to an skcms struct). Then remove this function, and update the two
    // remaining callers to do the right thing with transferFn and classify.
    this->transferFn(coeffs);
    return skcms_TransferFunction_getType(coeffs) == skcms_TFType_sRGBish;
}

isSRGB()

bool SkColorSpace::isSRGB

(

)

const

Returns true if the color space is sRGB. Returns false otherwise.

This allows a little bit of tolerance, given that we might see small numerical error in some cases: converting ICC fixed point to float, converting white point to D50, rounding decisions on transfer function and matrix.

This does not consider a 2.2f exponential transfer function to be sRGB. While these functions are similar (and it is sometimes useful to consider them together), this function checks for logical equality.

Definition at line 147 of file SkColorSpace.cpp.

                                {
    return sk_srgb_singleton() == this;
}

Make()

sk_sp< SkColorSpace > SkColorSpace::Make ( const skcms_ICCProfile &  profile )

static

Create an SkColorSpace from a parsed (skcms) ICC profile.

Definition at line 193 of file SkColorSpace.cpp.

                                                                      {
    // TODO: move below ≈sRGB test?
    if (!profile.has_toXYZD50 || !profile.has_trc) {
        return nullptr;
    }
 
    if (skcms_ApproximatelyEqualProfiles(&profile, skcms_sRGB_profile())) {
        return SkColorSpace::MakeSRGB();
    }
 
    // TODO: can we save this work and skip lazily inverting the matrix later?
    skcms_Matrix3x3 inv;
    if (!skcms_Matrix3x3_invert(&profile.toXYZD50, &inv)) {
        return nullptr;
    }
 
    // We can't work with tables or mismatched parametric curves,
    // but if they all look close enough to sRGB, that's fine.
    // TODO: should we maybe do this unconditionally to snap near-sRGB parametrics to sRGB?
    const skcms_Curve* trc = profile.trc;
    if (trc[0].table_entries != 0 ||
        trc[1].table_entries != 0 ||
        trc[2].table_entries != 0 ||
        0 != memcmp(&trc[0].parametric, &trc[1].parametric, sizeof(trc[0].parametric)) ||
        0 != memcmp(&trc[0].parametric, &trc[2].parametric, sizeof(trc[0].parametric)))
    {
        if (skcms_TRCs_AreApproximateInverse(&profile, skcms_sRGB_Inverse_TransferFunction())) {
            return SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, profile.toXYZD50);
        }
        return nullptr;
    }
 
    return SkColorSpace::MakeRGB(profile.trc[0].parametric, profile.toXYZD50);
}

makeColorSpin()

sk_sp< SkColorSpace > SkColorSpace::makeColorSpin

(

)

const

Returns a color space with the same transfer function as this one, but with the primary colors rotated. In other words, this produces a new color space that maps RGB to GBR (when applied to a source), and maps RGB to BRG (when applied to a destination).

This is used for testing, to construct color spaces that have severe and testable behavior.

Definition at line 175 of file SkColorSpace.cpp.

                                                      {
    skcms_Matrix3x3 spin = {{
        { 0, 0, 1 },
        { 1, 0, 0 },
        { 0, 1, 0 },
    }};
 
    skcms_Matrix3x3 spun = skcms_Matrix3x3_concat(&fToXYZD50, &spin);
 
    return sk_sp<SkColorSpace>(new SkColorSpace(fTransferFn, spun));
}

makeLinearGamma()

sk_sp< SkColorSpace > SkColorSpace::makeLinearGamma

(

)

const

Returns a color space with the same gamut as this one, but with a linear gamma.

Definition at line 161 of file SkColorSpace.cpp.

                                                        {
    if (this->gammaIsLinear()) {
        return sk_ref_sp(const_cast<SkColorSpace*>(this));
    }
    return SkColorSpace::MakeRGB(SkNamedTransferFn::kLinear, fToXYZD50);
}

MakeRGB()

sk_sp< SkColorSpace > SkColorSpace::MakeRGB ( const skcms_TransferFunction &  transferFn, const skcms_Matrix3x3 &  toXYZ  )

static

Create an SkColorSpace from a transfer function and a row-major 3x3 transformation to XYZ.

Definition at line 42 of file SkColorSpace.cpp.

                                                                        {
    if (skcms_TransferFunction_getType(&transferFn) == skcms_TFType_Invalid) {
        return nullptr;
    }
 
    const skcms_TransferFunction* tf = &transferFn;
 
    if (is_almost_srgb(transferFn)) {
        if (xyz_almost_equal(toXYZ, SkNamedGamut::kSRGB)) {
            return SkColorSpace::MakeSRGB();
        }
        tf = &SkNamedTransferFn::kSRGB;
    } else if (is_almost_2dot2(transferFn)) {
        tf = &SkNamedTransferFn::k2Dot2;
    } else if (is_almost_linear(transferFn)) {
        if (xyz_almost_equal(toXYZ, SkNamedGamut::kSRGB)) {
            return SkColorSpace::MakeSRGBLinear();
        }
        tf = &SkNamedTransferFn::kLinear;
    }
 
    return sk_sp<SkColorSpace>(new SkColorSpace(*tf, toXYZ));
}

MakeSRGB()

sk_sp< SkColorSpace > SkColorSpace::MakeSRGB ( )

static

Create the sRGB color space.

Definition at line 87 of file SkColorSpace.cpp.

                                           {
    return sk_ref_sp(sk_srgb_singleton());
}

makeSRGBGamma()

sk_sp< SkColorSpace > SkColorSpace::makeSRGBGamma

(

)

const

Returns a color space with the same gamut as this one, but with the sRGB transfer function.

Definition at line 168 of file SkColorSpace.cpp.

                                                      {
    if (this->gammaCloseToSRGB()) {
        return sk_ref_sp(const_cast<SkColorSpace*>(this));
    }
    return SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, fToXYZD50);
}

MakeSRGBLinear()

sk_sp< SkColorSpace > SkColorSpace::MakeSRGBLinear ( )

static

Colorspace with the sRGB primaries, but a linear (1.0) gamma.

Definition at line 91 of file SkColorSpace.cpp.

                                                 {
    return sk_ref_sp(sk_srgb_linear_singleton());
}

serialize()

sk_sp< SkData > SkColorSpace::serialize

(

)

const

Returns a serialized representation of this color space.

Definition at line 260 of file SkColorSpace.cpp.

                                            {
    sk_sp<SkData> data = SkData::MakeUninitialized(this->writeToMemory(nullptr));
    this->writeToMemory(data->writable_data());
    return data;
}

toProfile()

void SkColorSpace::toProfile

(

skcms_ICCProfile *

profile

)

const

Convert this color space to an skcms ICC profile struct.

Definition at line 187 of file SkColorSpace.cpp.

                                                            {
    skcms_Init               (profile);
    skcms_SetTransferFunction(profile, &fTransferFn);
    skcms_SetXYZD50          (profile, &fToXYZD50);
}

toXYZD50()

bool SkColorSpace::toXYZD50

(

skcms_Matrix3x3 *

toXYZD50

)

const

Returns true and sets |toXYZD50|.

Definition at line 137 of file SkColorSpace.cpp.

                                                           {
    *toXYZD50 = fToXYZD50;
    return true;
}

toXYZD50Hash()

uint32_t SkColorSpace::toXYZD50Hash ( ) const

inline

Returns a hash of the gamut transformation to XYZ D50. Allows for fast equality checking of gamuts, at the (very small) risk of collision.

Definition at line 161 of file SkColorSpace.h.

{ return fToXYZD50Hash; }

transferFn() [1/2]

void SkColorSpace::transferFn

(

float

gabcdef[7]

)

const

Definition at line 124 of file SkColorSpace.cpp.

                                                    {
    memcpy(gabcdef, &fTransferFn, 7*sizeof(float));
}

transferFn() [2/2]

void SkColorSpace::transferFn

(

skcms_TransferFunction *

fn

)

const

Definition at line 128 of file SkColorSpace.cpp.

                                                              {
    *fn = fTransferFn;
}

transferFnHash()

uint32_t SkColorSpace::transferFnHash ( ) const

inline

Definition at line 221 of file SkColorSpace.h.

{ return fTransferFnHash; }

writeToMemory()

size_t SkColorSpace::writeToMemory

(

void *

memory

)

const

If |memory| is nullptr, returns the size required to serialize. Otherwise, serializes into |memory| and returns the size.

Definition at line 246 of file SkColorSpace.cpp.

                                                     {
    if (memory) {
        *((ColorSpaceHeader*) memory) = ColorSpaceHeader();
        memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
 
        memcpy(memory, &fTransferFn, 7 * sizeof(float));
        memory = SkTAddOffset<void>(memory, 7 * sizeof(float));
 
        memcpy(memory, &fToXYZD50, 9 * sizeof(float));
    }
 
    return sizeof(ColorSpaceHeader) + 16 * sizeof(float);
}

Friends And Related Function Documentation

SkColorSpaceSingletonFactory

friend class SkColorSpaceSingletonFactory

friend

Definition at line 225 of file SkColorSpace.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/include/core/SkColorSpace.h
• third_party/skia/bench/ReadPixBench.cpp
• third_party/skia/bench/WritePixelsBench.cpp
• third_party/skia/src/core/SkColorSpace.cpp