kLinear_GammaNamed,
/**
- * Gamma curve is a close match to the canonical sRGB curve, which has
- * a short linear segment followed by a 2.4f exponential.
+ * Transfer function is the canonical sRGB curve, which has a short linear segment
+ * followed by a 2.4f exponential.
*/
kSRGB_GammaNamed,
-
- /**
- * Gamma curve is a close match to the 2.2f exponential curve. This is
- * used by Adobe RGB profiles and is common on monitors as well.
- */
- k2Dot2Curve_GammaNamed,
-
- /**
- * Gamma is represented by a look-up table, a parametric curve, or an uncommon
- * exponential curve. Or the R, G, and B gammas do not match.
- */
- kNonStandard_GammaNamed,
};
/**
sk_sp<SkColorSpace> makeLinearGamma();
/**
- * DO NOT USE: Will be deleted.
- */
- GammaNamed gammaNamed() const { return fGammaNamed; }
-
- /**
* Returns the matrix used to transform src gamut to XYZ D50.
*/
const SkMatrix44& xyz() const { return fToXYZD50; }
/**
* Returns true if the color space gamma is near enough to be approximated as sRGB.
*/
- bool gammaCloseToSRGB() const {
- return kSRGB_GammaNamed == fGammaNamed || k2Dot2Curve_GammaNamed == fGammaNamed;
- }
+ bool gammaCloseToSRGB() const;
/**
* Returns true if the color space gamma is linear.
*/
- bool gammaIsLinear() const {
- return kLinear_GammaNamed == fGammaNamed;
- }
+ bool gammaIsLinear() const;
/**
* Returns nullptr on failure. Fails when we fallback to serializing ICC data and
static bool Equals(const SkColorSpace* src, const SkColorSpace* dst);
protected:
- SkColorSpace(GammaNamed gammaNamed, const SkMatrix44& toXYZD50);
+ SkColorSpace(const SkMatrix44& toXYZD50);
- const GammaNamed fGammaNamed;
const SkMatrix44 fToXYZD50;
};
#include "SkColorSpacePriv.h"
#include "SkOnce.h"
-SkColorSpace::SkColorSpace(GammaNamed gammaNamed, const SkMatrix44& toXYZD50)
- : fGammaNamed(gammaNamed)
- , fToXYZD50(toXYZD50)
+SkColorSpace::SkColorSpace(const SkMatrix44& toXYZD50)
+ : fToXYZD50(toXYZD50)
{}
-SkColorSpace_Base::SkColorSpace_Base(GammaNamed gammaNamed, const SkMatrix44& toXYZD50)
- : INHERITED(gammaNamed, toXYZD50)
+SkColorSpace_Base::SkColorSpace_Base(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50)
+ : INHERITED(toXYZD50)
+ , fGammaNamed(gammaNamed)
, fGammas(nullptr)
, fProfileData(nullptr)
{}
-SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkColorLookUpTable> colorLUT, GammaNamed gammaNamed,
+SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkColorLookUpTable> colorLUT, SkGammaNamed gammaNamed,
sk_sp<SkGammas> gammas, const SkMatrix44& toXYZD50,
sk_sp<SkData> profileData)
- : INHERITED(gammaNamed, toXYZD50)
+ : INHERITED(toXYZD50)
, fColorLUT(std::move(colorLUT))
+ , fGammaNamed(gammaNamed)
, fGammas(std::move(gammas))
, fProfileData(std::move(profileData))
{}
return nullptr;
}
- GammaNamed gammaNamed = kNonStandard_GammaNamed;
+ SkGammaNamed gammaNamed = kNonStandard_SkGammaNamed;
if (color_space_almost_equal(2.2f, values[0]) &&
color_space_almost_equal(2.2f, values[1]) &&
color_space_almost_equal(2.2f, values[2])) {
- gammaNamed = k2Dot2Curve_GammaNamed;
+ gammaNamed = k2Dot2Curve_SkGammaNamed;
} else if (color_space_almost_equal(1.0f, values[0]) &&
color_space_almost_equal(1.0f, values[1]) &&
color_space_almost_equal(1.0f, values[2])) {
- gammaNamed = kLinear_GammaNamed;
+ gammaNamed = kLinear_SkGammaNamed;
}
- if (kNonStandard_GammaNamed == gammaNamed) {
+ if (kNonStandard_SkGammaNamed == gammaNamed) {
sk_sp<SkGammas> gammas = sk_sp<SkGammas>(new SkGammas());
gammas->fRedType = SkGammas::Type::kValue_Type;
gammas->fGreenType = SkGammas::Type::kValue_Type;
gammas->fRedData.fValue = values[0];
gammas->fGreenData.fValue = values[1];
gammas->fBlueData.fValue = values[2];
- return sk_sp<SkColorSpace>(new SkColorSpace_Base(nullptr, kNonStandard_GammaNamed, gammas,
+ return sk_sp<SkColorSpace>(new SkColorSpace_Base(nullptr, kNonStandard_SkGammaNamed, gammas,
toXYZD50, nullptr));
}
return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50);
}
-sk_sp<SkColorSpace> SkColorSpace_Base::NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50) {
+sk_sp<SkColorSpace> SkColorSpace_Base::NewRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50) {
switch (gammaNamed) {
- case kSRGB_GammaNamed:
+ case kSRGB_SkGammaNamed:
if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
return SkColorSpace::NewNamed(kSRGB_Named);
}
break;
- case k2Dot2Curve_GammaNamed:
+ case k2Dot2Curve_SkGammaNamed:
if (xyz_almost_equal(toXYZD50, gAdobeRGB_toXYZD50)) {
return SkColorSpace::NewNamed(kAdobeRGB_Named);
}
break;
- case kNonStandard_GammaNamed:
+ case kNonStandard_SkGammaNamed:
// This is not allowed.
return nullptr;
default:
}
sk_sp<SkColorSpace> SkColorSpace::NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50) {
- return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50);
+ switch (gammaNamed) {
+ case kLinear_GammaNamed:
+ return SkColorSpace_Base::NewRGB(kLinear_SkGammaNamed, toXYZD50);
+ case kSRGB_GammaNamed:
+ return SkColorSpace_Base::NewRGB(kSRGB_SkGammaNamed, toXYZD50);
+ default:
+ return nullptr;
+ }
}
static SkColorSpace* gAdobeRGB;
// Force the mutable type mask to be computed. This avoids races.
(void)srgbToxyzD50.getType();
- gSRGB = new SkColorSpace_Base(kSRGB_GammaNamed, srgbToxyzD50);
+ gSRGB = new SkColorSpace_Base(kSRGB_SkGammaNamed, srgbToxyzD50);
});
return sk_ref_sp<SkColorSpace>(gSRGB);
}
// Force the mutable type mask to be computed. This avoids races.
(void)adobergbToxyzD50.getType();
- gAdobeRGB = new SkColorSpace_Base(k2Dot2Curve_GammaNamed, adobergbToxyzD50);
+ gAdobeRGB = new SkColorSpace_Base(k2Dot2Curve_SkGammaNamed, adobergbToxyzD50);
});
return sk_ref_sp<SkColorSpace>(gAdobeRGB);
}
}
sk_sp<SkColorSpace> SkColorSpace::makeLinearGamma() {
- return SkColorSpace_Base::NewRGB(kLinear_GammaNamed, fToXYZD50);
+ return SkColorSpace_Base::NewRGB(kLinear_SkGammaNamed, fToXYZD50);
+}
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool SkColorSpace::gammaCloseToSRGB() const {
+ return kSRGB_SkGammaNamed == as_CSB(this)->fGammaNamed ||
+ k2Dot2Curve_SkGammaNamed == as_CSB(this)->fGammaNamed;
+}
+
+bool SkColorSpace::gammaIsLinear() const {
+ return kLinear_SkGammaNamed == as_CSB(this)->fGammaNamed;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
SkASSERT(named <= SkColorSpace::kAdobeRGB_Named);
header.fNamed = (uint8_t) named;
- SkASSERT(gammaNamed <= SkColorSpace::kNonStandard_GammaNamed);
+ SkASSERT(gammaNamed <= kNonStandard_SkGammaNamed);
header.fGammaNamed = (uint8_t) gammaNamed;
SkASSERT(flags <= kFloatGamma_Flag);
uint8_t fVersion; // Always zero
uint8_t fNamed; // Must be a SkColorSpace::Named
- uint8_t fGammaNamed; // Must be a SkColorSpace::GammaNamed
+ uint8_t fGammaNamed; // Must be a SkGammaNamed
uint8_t fFlags; // Some combination of the flags listed above
};
if (this == gSRGB) {
if (memory) {
*((ColorSpaceHeader*) memory) =
- ColorSpaceHeader::Pack(k0_Version, kSRGB_Named, fGammaNamed, 0);
+ ColorSpaceHeader::Pack(k0_Version, kSRGB_Named,
+ as_CSB(this)->fGammaNamed, 0);
}
return sizeof(ColorSpaceHeader);
} else if (this == gAdobeRGB) {
if (memory) {
*((ColorSpaceHeader*) memory) =
- ColorSpaceHeader::Pack(k0_Version, kAdobeRGB_Named, fGammaNamed, 0);
+ ColorSpaceHeader::Pack(k0_Version, kAdobeRGB_Named,
+ as_CSB(this)->fGammaNamed, 0);
}
}
// If we have a named gamma, write the enum and the matrix.
- switch (fGammaNamed) {
- case kSRGB_GammaNamed:
- case k2Dot2Curve_GammaNamed:
- case kLinear_GammaNamed: {
+ switch (as_CSB(this)->fGammaNamed) {
+ case kSRGB_SkGammaNamed:
+ case k2Dot2Curve_SkGammaNamed:
+ case kLinear_SkGammaNamed: {
if (memory) {
*((ColorSpaceHeader*) memory) =
- ColorSpaceHeader::Pack(k0_Version, 0, fGammaNamed,
+ ColorSpaceHeader::Pack(k0_Version, 0, as_CSB(this)->fGammaNamed,
ColorSpaceHeader::kMatrix_Flag);
memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
fToXYZD50.as4x3ColMajorf((float*) memory);
// Otherwise, write the gamma values and the matrix.
if (memory) {
*((ColorSpaceHeader*) memory) =
- ColorSpaceHeader::Pack(k0_Version, 0, fGammaNamed,
+ ColorSpaceHeader::Pack(k0_Version, 0, as_CSB(this)->fGammaNamed,
ColorSpaceHeader::kFloatGamma_Flag);
memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
if (memory) {
*((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(k0_Version, 0,
- kNonStandard_GammaNamed,
+ kNonStandard_SkGammaNamed,
ColorSpaceHeader::kICC_Flag);
memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
return NewNamed((Named) header.fNamed);
}
- switch ((GammaNamed) header.fGammaNamed) {
- case kSRGB_GammaNamed:
- case k2Dot2Curve_GammaNamed:
- case kLinear_GammaNamed: {
+ switch ((SkGammaNamed) header.fGammaNamed) {
+ case kSRGB_SkGammaNamed:
+ case k2Dot2Curve_SkGammaNamed:
+ case kLinear_SkGammaNamed: {
if (ColorSpaceHeader::kMatrix_Flag != header.fFlags || length < 12 * sizeof(float)) {
return nullptr;
}
SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
toXYZ.set4x3ColMajorf((const float*) data);
- return NewRGB((GammaNamed) header.fGammaNamed, toXYZ);
+ return SkColorSpace_Base::NewRGB((SkGammaNamed) header.fGammaNamed, toXYZ);
}
default:
break;
// It's important to check fProfileData before named gammas. Some profiles may have named
// gammas, but also include other wacky features that cause us to save the data.
- switch (src->fGammaNamed) {
- case kSRGB_GammaNamed:
- case k2Dot2Curve_GammaNamed:
- case kLinear_GammaNamed:
- return (src->fGammaNamed == dst->fGammaNamed) && (src->fToXYZD50 == dst->fToXYZD50);
+ switch (as_CSB(src)->fGammaNamed) {
+ case kSRGB_SkGammaNamed:
+ case k2Dot2Curve_SkGammaNamed:
+ case kLinear_SkGammaNamed:
+ return (as_CSB(src)->fGammaNamed == as_CSB(dst)->fGammaNamed) &&
+ (src->fToXYZD50 == dst->fToXYZD50);
default:
- if (src->fGammaNamed != dst->fGammaNamed) {
+ if (as_CSB(src)->fGammaNamed != as_CSB(dst)->fGammaNamed) {
return false;
}
}
static const int kDstGammaTableSize =
- SkColorSpaceXform_Base<SkColorSpace::kNonStandard_GammaNamed, kNone_ColorSpaceMatch>
+ SkColorSpaceXform_Base<kNonStandard_SkGammaNamed, kNone_ColorSpaceMatch>
::kDstGammaTableSize;
static void build_table_linear_to_gamma(uint8_t* outTable, float exponent) {
template <typename T>
static void build_gamma_tables(const T* outGammaTables[3], T* gammaTableStorage, int gammaTableSize,
const sk_sp<SkColorSpace>& space, const GammaFns<T>& fns) {
- switch (space->gammaNamed()) {
- case SkColorSpace::kSRGB_GammaNamed:
+ switch (as_CSB(space)->gammaNamed()) {
+ case kSRGB_SkGammaNamed:
outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = fns.fSRGBTable;
break;
- case SkColorSpace::k2Dot2Curve_GammaNamed:
+ case k2Dot2Curve_SkGammaNamed:
outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = fns.f2Dot2Table;
break;
- case SkColorSpace::kLinear_GammaNamed:
+ case kLinear_SkGammaNamed:
(*fns.fBuildFromValue)(gammaTableStorage, 1.0f);
outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = gammaTableStorage;
break;
if (gammas->isNamed(i)) {
switch (gammas->data(i).fNamed) {
- case SkColorSpace::kSRGB_GammaNamed:
+ case kSRGB_SkGammaNamed:
outGammaTables[i] = fns.fSRGBTable;
break;
- case SkColorSpace::k2Dot2Curve_GammaNamed:
+ case k2Dot2Curve_SkGammaNamed:
outGammaTables[i] = fns.f2Dot2Table;
break;
- case SkColorSpace::kLinear_GammaNamed:
+ case kLinear_SkGammaNamed:
(*fns.fBuildFromValue)(&gammaTableStorage[i * gammaTableSize], 1.0f);
outGammaTables[i] = &gammaTableStorage[i * gammaTableSize];
break;
switch (csm) {
case kNone_ColorSpaceMatch:
- switch (dstSpace->gammaNamed()) {
- case SkColorSpace::kSRGB_GammaNamed:
+ switch (as_CSB(dstSpace)->gammaNamed()) {
+ case kSRGB_SkGammaNamed:
return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
- <SkColorSpace::kSRGB_GammaNamed, kNone_ColorSpaceMatch>
+ <kSRGB_SkGammaNamed, kNone_ColorSpaceMatch>
(srcSpace, srcToDst, dstSpace));
- case SkColorSpace::k2Dot2Curve_GammaNamed:
+ case k2Dot2Curve_SkGammaNamed:
return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
- <SkColorSpace::k2Dot2Curve_GammaNamed, kNone_ColorSpaceMatch>
+ <k2Dot2Curve_SkGammaNamed, kNone_ColorSpaceMatch>
(srcSpace, srcToDst, dstSpace));
default:
return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
- <SkColorSpace::kNonStandard_GammaNamed, kNone_ColorSpaceMatch>
+ <kNonStandard_SkGammaNamed, kNone_ColorSpaceMatch>
(srcSpace, srcToDst, dstSpace));
}
case kGamut_ColorSpaceMatch:
- switch (dstSpace->gammaNamed()) {
- case SkColorSpace::kSRGB_GammaNamed:
+ switch (as_CSB(dstSpace)->gammaNamed()) {
+ case kSRGB_SkGammaNamed:
return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
- <SkColorSpace::kSRGB_GammaNamed, kGamut_ColorSpaceMatch>
+ <kSRGB_SkGammaNamed, kGamut_ColorSpaceMatch>
(srcSpace, srcToDst, dstSpace));
- case SkColorSpace::k2Dot2Curve_GammaNamed:
+ case k2Dot2Curve_SkGammaNamed:
return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
- <SkColorSpace::k2Dot2Curve_GammaNamed, kGamut_ColorSpaceMatch>
+ <k2Dot2Curve_SkGammaNamed, kGamut_ColorSpaceMatch>
(srcSpace, srcToDst, dstSpace));
default:
return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
- <SkColorSpace::kNonStandard_GammaNamed, kGamut_ColorSpaceMatch>
+ <kNonStandard_SkGammaNamed, kGamut_ColorSpaceMatch>
(srcSpace, srcToDst, dstSpace));
}
case kFull_ColorSpaceMatch:
- switch (dstSpace->gammaNamed()) {
- case SkColorSpace::kSRGB_GammaNamed:
+ switch (as_CSB(dstSpace)->gammaNamed()) {
+ case kSRGB_SkGammaNamed:
return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
- <SkColorSpace::kSRGB_GammaNamed, kFull_ColorSpaceMatch>
+ <kSRGB_SkGammaNamed, kFull_ColorSpaceMatch>
(srcSpace, srcToDst, dstSpace));
- case SkColorSpace::k2Dot2Curve_GammaNamed:
+ case k2Dot2Curve_SkGammaNamed:
return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
- <SkColorSpace::k2Dot2Curve_GammaNamed, kFull_ColorSpaceMatch>
+ <k2Dot2Curve_SkGammaNamed, kFull_ColorSpaceMatch>
(srcSpace, srcToDst, dstSpace));
default:
return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
- <SkColorSpace::kNonStandard_GammaNamed, kFull_ColorSpaceMatch>
+ <kNonStandard_SkGammaNamed, kFull_ColorSpaceMatch>
(srcSpace, srcToDst, dstSpace));
}
default:
| (*src & 0xFF000000);
}
-template <SkColorSpace::GammaNamed kDstGamma,
+template <SkGammaNamed kDstGamma,
ColorSpaceMatch kCSM,
SkAlphaType kAlphaType,
SwapRB kSwapRB>
decltype(load_rgb_from_tables_1)* load_1;
size_t sizeOfDstPixel;
switch (kDstGamma) {
- case SkColorSpace::kSRGB_GammaNamed:
+ case kSRGB_SkGammaNamed:
load = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables :
load_rgb_from_tables;
load_1 = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables_1 :
store_1 = store_srgb_1;
sizeOfDstPixel = 4;
break;
- case SkColorSpace::k2Dot2Curve_GammaNamed:
+ case k2Dot2Curve_SkGammaNamed:
load = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables :
load_rgb_from_tables;
load_1 = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables_1 :
store_1 = store_2dot2_1;
sizeOfDstPixel = 4;
break;
- case SkColorSpace::kLinear_GammaNamed:
+ case kLinear_SkGammaNamed:
load = load_rgba_from_tables;
load_1 = load_rgba_from_tables_1;
store = (kOpaque_SkAlphaType == kAlphaType) ? store_f16_opaque :
store_f16_1;
sizeOfDstPixel = 8;
break;
- case SkColorSpace::kNonStandard_GammaNamed:
+ case kNonStandard_SkGammaNamed:
load = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables :
load_rgb_from_tables;
load_1 = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables_1 :
///////////////////////////////////////////////////////////////////////////////////////////////////
-template <SkColorSpace::GammaNamed kDst, ColorSpaceMatch kCSM>
+template <SkGammaNamed kDst, ColorSpaceMatch kCSM>
SkColorSpaceXform_Base<kDst, kCSM>::SkColorSpaceXform_Base(const sk_sp<SkColorSpace>& srcSpace,
const SkMatrix44& srcToDst,
const sk_sp<SkColorSpace>& dstSpace)
kFromLinear);
}
-template <SkColorSpace::GammaNamed kDst, ColorSpaceMatch kCSM>
+template <SkGammaNamed kDst, ColorSpaceMatch kCSM>
void SkColorSpaceXform_Base<kDst, kCSM>
::apply(void* dst, const uint32_t* src, int len, SkColorType dstColorType, SkAlphaType dstAlphaType)
const
return color_xform_RGBA<kDst, kCSM, kPremul_SkAlphaType, kYes_SwapRB>
(dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
case kRGBA_F16_SkColorType:
- return color_xform_RGBA<SkColorSpace::kLinear_GammaNamed, kCSM,
+ return color_xform_RGBA<kLinear_SkGammaNamed, kCSM,
kPremul_SkAlphaType, kNo_SwapRB>
(dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
default:
return color_xform_RGBA<kDst, kCSM, kUnpremul_SkAlphaType, kYes_SwapRB>
(dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
case kRGBA_F16_SkColorType:
- return color_xform_RGBA<SkColorSpace::kLinear_GammaNamed, kCSM,
+ return color_xform_RGBA<kLinear_SkGammaNamed, kCSM,
kUnpremul_SkAlphaType, kNo_SwapRB>
(dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
default:
return color_xform_RGBA<kDst, kCSM, kOpaque_SkAlphaType, kYes_SwapRB>
(dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
case kRGBA_F16_SkColorType:
- return color_xform_RGBA<SkColorSpace::kLinear_GammaNamed, kCSM,
+ return color_xform_RGBA<kLinear_SkGammaNamed, kCSM,
kOpaque_SkAlphaType, kNo_SwapRB>
(dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
default:
std::unique_ptr<SkColorSpaceXform> SlowIdentityXform(const sk_sp<SkColorSpace>& space) {
return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
- <SkColorSpace::kNonStandard_GammaNamed, kNone_ColorSpaceMatch>
+ <kNonStandard_SkGammaNamed, kNone_ColorSpaceMatch>
(space, SkMatrix::I(), space));
}
kFull_ColorSpaceMatch,
};
-template <SkColorSpace::GammaNamed kDst, ColorSpaceMatch kCSM>
+template <SkGammaNamed kDst, ColorSpaceMatch kCSM>
class SkColorSpaceXform_Base : public SkColorSpaceXform {
public:
#include "SkData.h"
#include "SkTemplates.h"
+enum SkGammaNamed : uint8_t {
+ kLinear_SkGammaNamed,
+ kSRGB_SkGammaNamed,
+ k2Dot2Curve_SkGammaNamed,
+ kNonStandard_SkGammaNamed,
+};
+
struct SkGammas : SkRefCnt {
// There are four possible representations for gamma curves. kNone_Type is used
this->fTable.fSize == that.fTable.fSize;
}
- SkColorSpace::GammaNamed fNamed;
+ SkGammaNamed fNamed;
float fValue;
Table fTable;
size_t fParamOffset;
static sk_sp<SkColorSpace> NewRGB(const float gammas[3], const SkMatrix44& toXYZD50);
+ SkGammaNamed gammaNamed() const { return fGammaNamed; }
const SkGammas* gammas() const { return fGammas.get(); }
const SkColorLookUpTable* colorLUT() const { return fColorLUT.get(); }
*/
sk_sp<SkData> writeToICC() const;
- static sk_sp<SkColorSpace> NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50);
+ static sk_sp<SkColorSpace> NewRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50);
- SkColorSpace_Base(GammaNamed gammaNamed, const SkMatrix44& toXYZ);
+ SkColorSpace_Base(SkGammaNamed gammaNamed, const SkMatrix44& toXYZ);
- SkColorSpace_Base(sk_sp<SkColorLookUpTable> colorLUT, GammaNamed gammaNamed,
+ SkColorSpace_Base(sk_sp<SkColorLookUpTable> colorLUT, SkGammaNamed gammaNamed,
sk_sp<SkGammas> gammas, const SkMatrix44& toXYZ, sk_sp<SkData> profileData);
sk_sp<SkColorLookUpTable> fColorLUT;
+ const SkGammaNamed fGammaNamed;
sk_sp<SkGammas> fGammas;
sk_sp<SkData> fProfileData;
static SkGammas::Type set_gamma_value(SkGammas::Data* data, float value) {
if (color_space_almost_equal(2.2f, value)) {
- data->fNamed = SkColorSpace::k2Dot2Curve_GammaNamed;
+ data->fNamed = k2Dot2Curve_SkGammaNamed;
return SkGammas::Type::kNamed_Type;
}
if (color_space_almost_equal(1.0f, value)) {
- data->fNamed = SkColorSpace::kLinear_GammaNamed;
+ data->fNamed = kLinear_SkGammaNamed;
return SkGammas::Type::kNamed_Type;
}
// Some tags require a gamma curve, but the author doesn't actually want
// to transform the data. In this case, it is common to see a curve with
// a count of 0.
- outData->fNamed = SkColorSpace::kLinear_GammaNamed;
+ outData->fNamed = kLinear_SkGammaNamed;
return SkGammas::Type::kNamed_Type;
}
14116 == read_big_endian_u16((const uint8_t*) &table[513]) &&
34318 == read_big_endian_u16((const uint8_t*) &table[768]) &&
65535 == read_big_endian_u16((const uint8_t*) &table[1023])) {
- outData->fNamed = SkColorSpace::kSRGB_GammaNamed;
+ outData->fNamed = kSRGB_SkGammaNamed;
return SkGammas::Type::kNamed_Type;
}
}
12824 == read_big_endian_u16((const uint8_t*) &table[12]) &&
31237 == read_big_endian_u16((const uint8_t*) &table[18]) &&
65535 == read_big_endian_u16((const uint8_t*) &table[25])) {
- outData->fNamed = SkColorSpace::kSRGB_GammaNamed;
+ outData->fNamed = kSRGB_SkGammaNamed;
return SkGammas::Type::kNamed_Type;
}
}
3342 == read_big_endian_u16((const uint8_t*) &table[1025]) &&
14079 == read_big_endian_u16((const uint8_t*) &table[2051]) &&
65535 == read_big_endian_u16((const uint8_t*) &table[4095])) {
- outData->fNamed = SkColorSpace::kSRGB_GammaNamed;
+ outData->fNamed = kSRGB_SkGammaNamed;
return SkGammas::Type::kNamed_Type;
}
}
color_space_almost_equal(0.0774f, e) &&
color_space_almost_equal(0.0000f, f) &&
color_space_almost_equal(2.4000f, g)) {
- outData->fNamed = SkColorSpace::kSRGB_GammaNamed;
+ outData->fNamed = kSRGB_SkGammaNamed;
return SkGammas::Type::kNamed_Type;
}
*type = SkGammas::Type::kNamed_Type;
// Guess sRGB in the case of a malformed transfer function.
- data->fNamed = SkColorSpace::kSRGB_GammaNamed;
+ data->fNamed = kSRGB_SkGammaNamed;
}
}
return true;
}
-static inline SkColorSpace::GammaNamed is_named(const sk_sp<SkGammas>& gammas) {
+static inline SkGammaNamed is_named(const sk_sp<SkGammas>& gammas) {
if (gammas->isNamed(0) && gammas->isNamed(1) && gammas->isNamed(2) &&
gammas->fRedData.fNamed == gammas->fGreenData.fNamed &&
gammas->fRedData.fNamed == gammas->fBlueData.fNamed)
return gammas->fRedData.fNamed;
}
- return SkColorSpace::kNonStandard_GammaNamed;
+ return kNonStandard_SkGammaNamed;
}
-static bool load_a2b0(sk_sp<SkColorLookUpTable>* colorLUT, SkColorSpace::GammaNamed* gammaNamed,
+static bool load_a2b0(sk_sp<SkColorLookUpTable>* colorLUT, SkGammaNamed* gammaNamed,
sk_sp<SkGammas>* gammas, SkMatrix44* toXYZ, const uint8_t* src, size_t len) {
if (len < 32) {
SkColorSpacePrintf("A to B tag is too small (%d bytes).", len);
}
} else {
// Guess sRGB if the chunk is missing a transfer function.
- *gammaNamed = SkColorSpace::kSRGB_GammaNamed;
+ *gammaNamed = kSRGB_SkGammaNamed;
}
- if (SkColorSpace::kNonStandard_GammaNamed == *gammaNamed) {
+ if (kNonStandard_SkGammaNamed == *gammaNamed) {
*gammaNamed = is_named(*gammas);
- if (SkColorSpace::kNonStandard_GammaNamed != *gammaNamed) {
+ if (kNonStandard_SkGammaNamed != *gammaNamed) {
// No need to keep the gammas struct, the enum is enough.
*gammas = nullptr;
}
}
}
- GammaNamed gammaNamed = kNonStandard_GammaNamed;
+ SkGammaNamed gammaNamed = kNonStandard_SkGammaNamed;
sk_sp<SkGammas> gammas = nullptr;
size_t tagBytes;
if (r && g && b) {
}
} else {
// Guess sRGB if the profile is missing transfer functions.
- gammaNamed = kSRGB_GammaNamed;
+ gammaNamed = kSRGB_SkGammaNamed;
}
- if (kNonStandard_GammaNamed == gammaNamed) {
+ if (kNonStandard_SkGammaNamed == gammaNamed) {
// It's possible that we'll initially detect non-matching gammas, only for
// them to evaluate to the same named gamma curve.
gammaNamed = is_named(gammas);
- if (kNonStandard_GammaNamed == gammaNamed) {
+ if (kNonStandard_SkGammaNamed == gammaNamed) {
return sk_sp<SkColorSpace>(new SkColorSpace_Base(nullptr, gammaNamed,
std::move(gammas), mat,
std::move(data)));
// Recognize color profile specified by A2B0 tag.
const ICCTag* a2b0 = ICCTag::Find(tags.get(), tagCount, kTAG_A2B0);
if (a2b0) {
- GammaNamed gammaNamed = kNonStandard_GammaNamed;
+ SkGammaNamed gammaNamed = kNonStandard_SkGammaNamed;
sk_sp<SkGammas> gammas = nullptr;
sk_sp<SkColorLookUpTable> colorLUT = nullptr;
SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
return_null("Failed to parse A2B0 tag");
}
- if (colorLUT || kNonStandard_GammaNamed == gammaNamed) {
+ if (colorLUT || kNonStandard_SkGammaNamed == gammaNamed) {
return sk_sp<SkColorSpace>(new SkColorSpace_Base(std::move(colorLUT),
gammaNamed, std::move(gammas),
toXYZ, std::move(data)));
ptr += kTAG_XYZ_Bytes;
// Write TRC tags
- GammaNamed gammaNamed = this->gammaNamed();
- if (kNonStandard_GammaNamed == gammaNamed) {
+ SkGammaNamed gammaNamed = this->gammaNamed();
+ if (kNonStandard_SkGammaNamed == gammaNamed) {
// FIXME (msarett):
// Write the correct gamma representation rather than 2.2f.
write_trc_tag((uint32_t*) ptr, 2.2f);
ptr += SkAlign4(kTAG_TRC_Bytes);
} else {
switch (gammaNamed) {
- case SkColorSpace::kSRGB_GammaNamed:
+ case kSRGB_SkGammaNamed:
// FIXME (msarett):
// kSRGB cannot be represented by a value. Here we fall through to 2.2f,
// which is a close guess. To be more accurate, we need to represent sRGB
// gamma with a parametric curve.
- case SkColorSpace::k2Dot2Curve_GammaNamed:
+ case k2Dot2Curve_SkGammaNamed:
write_trc_tag((uint32_t*) ptr, 2.2f);
ptr += SkAlign4(kTAG_TRC_Bytes);
write_trc_tag((uint32_t*) ptr, 2.2f);
write_trc_tag((uint32_t*) ptr, 2.2f);
ptr += SkAlign4(kTAG_TRC_Bytes);
break;
- case SkColorSpace::kLinear_GammaNamed:
+ case kLinear_SkGammaNamed:
write_trc_tag((uint32_t*) ptr, 1.0f);
ptr += SkAlign4(kTAG_TRC_Bytes);
write_trc_tag((uint32_t*) ptr, 1.0f);
bool SkSurface_Gpu::Valid(const SkImageInfo& info) {
switch (info.colorType()) {
case kRGBA_F16_SkColorType:
- return info.colorSpace() &&
- SkColorSpace::kLinear_GammaNamed == info.colorSpace()->gammaNamed();
+ return info.colorSpace() && info.colorSpace()->gammaIsLinear();
case kRGBA_8888_SkColorType:
case kBGRA_8888_SkColorType:
return !info.colorSpace() || info.colorSpace()->gammaCloseToSRGB();
bool SkSurface_Gpu::Valid(GrContext* context, GrPixelConfig config, SkColorSpace* colorSpace) {
switch (config) {
case kRGBA_half_GrPixelConfig:
- return colorSpace && SkColorSpace::kLinear_GammaNamed == colorSpace->gammaNamed();
+ return colorSpace && colorSpace->gammaIsLinear();
case kSRGBA_8888_GrPixelConfig:
case kSBGRA_8888_GrPixelConfig:
return context->caps()->srgbSupport() && colorSpace && colorSpace->gammaCloseToSRGB();
shift = 2;
break;
case kRGBA_F16_SkColorType:
- if (!info.colorSpace() ||
- SkColorSpace::kLinear_GammaNamed != info.colorSpace()->gammaNamed()) {
+ if (!info.colorSpace() || !info.colorSpace()->gammaIsLinear()) {
return false;
}
shift = 3;
static void test_space(skiatest::Reporter* r, SkColorSpace* space,
const float red[], const float green[], const float blue[],
- const SkColorSpace::GammaNamed expectedGamma) {
+ const SkGammaNamed expectedGamma) {
REPORTER_ASSERT(r, nullptr != space);
- REPORTER_ASSERT(r, expectedGamma == space->gammaNamed());
+ REPORTER_ASSERT(r, expectedGamma == as_CSB(space)->gammaNamed());
const SkMatrix44& mat = space->xyz();
const float src[] = {
static void test_path(skiatest::Reporter* r, const char* path,
const float red[], const float green[], const float blue[],
- const SkColorSpace::GammaNamed expectedGamma) {
+ const SkGammaNamed expectedGamma) {
SkAutoTDelete<SkStream> stream(resource(path));
REPORTER_ASSERT(r, nullptr != stream);
if (!stream) {
DEF_TEST(ColorSpace_sRGB, r) {
test_space(r, SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named).get(),
- g_sRGB_XYZ, &g_sRGB_XYZ[3], &g_sRGB_XYZ[6], SkColorSpace::kSRGB_GammaNamed);
+ g_sRGB_XYZ, &g_sRGB_XYZ[3], &g_sRGB_XYZ[6], kSRGB_SkGammaNamed);
}
#if (PNG_LIBPNG_VER_MAJOR > 1) || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 6)
test_path(r, "color_wheel_with_profile.png", &g_sRGB_XYZ[0], &g_sRGB_XYZ[3], &g_sRGB_XYZ[6],
- SkColorSpace::kSRGB_GammaNamed);
+ kSRGB_SkGammaNamed);
#endif
const float red[] = { 0.385117f, 0.716904f, 0.0970612f };
const float green[] = { 0.143051f, 0.0606079f, 0.713913f };
const float blue[] = { 0.436035f, 0.222488f, 0.013916f };
- test_path(r, "icc-v2-gbr.jpg", red, green, blue, SkColorSpace::k2Dot2Curve_GammaNamed);
+ test_path(r, "icc-v2-gbr.jpg", red, green, blue, k2Dot2Curve_SkGammaNamed);
test_path(r, "webp-color-profile-crash.webp",
- red, green, blue, SkColorSpace::kNonStandard_GammaNamed);
+ red, green, blue, kNonStandard_SkGammaNamed);
test_path(r, "webp-color-profile-lossless.webp",
- red, green, blue, SkColorSpace::kNonStandard_GammaNamed);
+ red, green, blue, kNonStandard_SkGammaNamed);
test_path(r, "webp-color-profile-lossy.webp",
- red, green, blue, SkColorSpace::kNonStandard_GammaNamed);
+ red, green, blue, kNonStandard_SkGammaNamed);
test_path(r, "webp-color-profile-lossy-alpha.webp",
- red, green, blue, SkColorSpace::kNonStandard_GammaNamed);
+ red, green, blue, kNonStandard_SkGammaNamed);
}
DEF_TEST(ColorSpaceSRGBCompare, r) {
sk_sp<SkData> namedData = ColorSpaceTest::WriteToICC(namedColorSpace.get());
sk_sp<SkColorSpace> iccColorSpace = SkColorSpace::NewICC(namedData->data(), namedData->size());
test_space(r, iccColorSpace.get(), g_sRGB_XYZ, &g_sRGB_XYZ[3], &g_sRGB_XYZ[6],
- SkColorSpace::k2Dot2Curve_GammaNamed);
+ k2Dot2Curve_SkGammaNamed);
// FIXME (msarett): Test disabled. sRGB profiles are written approximately as 2.2f curves.
// REPORTER_ASSERT(r, iccColorSpace == namedColorSpace);
sk_sp<SkColorSpace> newMonitorSpace = SkColorSpace::NewICC(newMonitorData->data(),
newMonitorData->size());
REPORTER_ASSERT(r, monitorSpace->xyz() == newMonitorSpace->xyz());
- REPORTER_ASSERT(r, monitorSpace->gammaNamed() == newMonitorSpace->gammaNamed());
+ REPORTER_ASSERT(r, as_CSB(monitorSpace)->gammaNamed() == as_CSB(newMonitorSpace)->gammaNamed());
}
DEF_TEST(ColorSpace_Named, r) {
REPORTER_ASSERT(r, cs);
if (cs) {
if (rec.fIsSRGB) {
- REPORTER_ASSERT(r, SkColorSpace::kSRGB_GammaNamed == cs->gammaNamed());
+ REPORTER_ASSERT(r, kSRGB_SkGammaNamed == as_CSB(cs)->gammaNamed());
} else {
- REPORTER_ASSERT(r, SkColorSpace::k2Dot2Curve_GammaNamed == cs->gammaNamed());
+ REPORTER_ASSERT(r, k2Dot2Curve_SkGammaNamed == as_CSB(cs)->gammaNamed());
}
}
}
static std::unique_ptr<SkColorSpaceXform> CreateIdentityXform(const sk_sp<SkGammas>& gammas) {
// Logically we can pass any matrix here. For simplicty, pass I(), i.e. D50 XYZ gamut.
sk_sp<SkColorSpace> space(new SkColorSpace_Base(
- nullptr, SkColorSpace::kNonStandard_GammaNamed, gammas, SkMatrix::I(), nullptr));
+ nullptr, kNonStandard_SkGammaNamed, gammas, SkMatrix::I(), nullptr));
// Use special testing entry point, so we don't skip the xform, even though src == dst.
return SlowIdentityXform(space);
REPORTER_ASSERT(reporter, !configs[24]->asConfigGpu());
REPORTER_ASSERT(reporter, configs[25]->asConfigGpu()->getColorType() == kRGBA_F16_SkColorType);
REPORTER_ASSERT(reporter, configs[25]->asConfigGpu()->getColorSpace());
- REPORTER_ASSERT(reporter, configs[25]->asConfigGpu()->getColorSpace()->gammaNamed() ==
- SkColorSpace::kLinear_GammaNamed);
+ REPORTER_ASSERT(reporter, configs[25]->asConfigGpu()->getColorSpace()->gammaIsLinear());
REPORTER_ASSERT(reporter, configs[25]->asConfigGpu()->getColorSpace()->xyz() ==
srgbColorSpace->xyz());
REPORTER_ASSERT(reporter, configs[26]->asConfigGpu()->getColorType() == kN32_SkColorType);
projects / platform / upstream / libSkiaSharp.git / commitdiff