Delete SkColorSpace::ColorSpaceFlags
BUG=skia:
Change-Id: Ia0688876915cd773614ca0c4ccd467cf6e7c603e
Reviewed-on: https://skia-review.googlesource.com/10105
Commit-Queue: Matt Sarett <msarett@google.com>
Reviewed-by: Brian Osman <brianosman@google.com>
diff --git a/dm/DM.cpp b/dm/DM.cpp
index 7c504ba..0b36e4b 100644
--- a/dm/DM.cpp
+++ b/dm/DM.cpp
@@ -867,16 +867,11 @@
if (FLAGS_cpu) {
auto srgbColorSpace = SkColorSpace::MakeSRGB();
- auto srgbColorSpaceNonLinearBlending = SkColorSpace::MakeRGB(
- SkColorSpace::kSRGB_RenderTargetGamma,
- SkColorSpace::kSRGB_Gamut,
- SkColorSpace::kNonLinearBlending_ColorSpaceFlag);
auto srgbLinearColorSpace = SkColorSpace::MakeSRGBLinear();
SINK("565", RasterSink, kRGB_565_SkColorType);
SINK("8888", RasterSink, kN32_SkColorType);
SINK("srgb", RasterSink, kN32_SkColorType, srgbColorSpace);
- SINK("srgbnl", RasterSink, kN32_SkColorType, srgbColorSpaceNonLinearBlending);
SINK("f16", RasterSink, kRGBA_F16_SkColorType, srgbLinearColorSpace);
SINK("pdf", PDFSink);
SINK("skp", SKPSink);
diff --git a/include/core/SkColorSpace.h b/include/core/SkColorSpace.h
index 27288f7..6a4919b 100644
--- a/include/core/SkColorSpace.h
+++ b/include/core/SkColorSpace.h
@@ -87,23 +87,17 @@
kRec2020_Gamut,
};
- enum ColorSpaceFlags {
- kNonLinearBlending_ColorSpaceFlag = 0x1,
- };
-
/**
* Create an SkColorSpace from a transfer function and a color gamut.
*
* Transfer function can be specified as an enum or as the coefficients to an equation.
* Gamut can be specified as an enum or as the matrix transformation to XYZ D50.
*/
- static sk_sp<SkColorSpace> MakeRGB(RenderTargetGamma gamma, Gamut gamut, uint32_t flags = 0);
- static sk_sp<SkColorSpace> MakeRGB(RenderTargetGamma gamma, const SkMatrix44& toXYZD50,
- uint32_t flags = 0);
- static sk_sp<SkColorSpace> MakeRGB(const SkColorSpaceTransferFn& coeffs, Gamut gamut,
- uint32_t flags = 0);
+ static sk_sp<SkColorSpace> MakeRGB(RenderTargetGamma gamma, Gamut gamut);
+ static sk_sp<SkColorSpace> MakeRGB(RenderTargetGamma gamma, const SkMatrix44& toXYZD50);
+ static sk_sp<SkColorSpace> MakeRGB(const SkColorSpaceTransferFn& coeffs, Gamut gamut);
static sk_sp<SkColorSpace> MakeRGB(const SkColorSpaceTransferFn& coeffs,
- const SkMatrix44& toXYZD50, uint32_t flags = 0);
+ const SkMatrix44& toXYZD50);
/**
* Create an SkColorSpace from an ICC profile.
diff --git a/src/codec/SkCodecPriv.h b/src/codec/SkCodecPriv.h
index 5bf0272..af049b3 100644
--- a/src/codec/SkCodecPriv.h
+++ b/src/codec/SkCodecPriv.h
@@ -311,8 +311,7 @@
bool isF16 = kRGBA_F16_SkColorType == dstInfo.colorType();
// Need a color xform when dst space does not match the src.
- bool srcDstNotEqual =
- !SkColorSpace_Base::EqualsIgnoreFlags(srcInfo.colorSpace(), dstInfo.colorSpace());
+ bool srcDstNotEqual = !SkColorSpace::Equals(srcInfo.colorSpace(), dstInfo.colorSpace());
return needsColorCorrectPremul || isF16 || srcDstNotEqual;
}
diff --git a/src/core/SkColorSpace.cpp b/src/core/SkColorSpace.cpp
index b953ffa..9942406 100644
--- a/src/core/SkColorSpace.cpp
+++ b/src/core/SkColorSpace.cpp
@@ -83,9 +83,8 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
-SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkData> profileData, uint32_t flags)
+SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkData> profileData)
: fProfileData(std::move(profileData))
- , fFlags(flags)
{}
/**
@@ -113,25 +112,21 @@
color_space_almost_equal(toXYZD50.getFloat(3, 3), 1.0f);
}
-sk_sp<SkColorSpace> SkColorSpace_Base::MakeRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50,
- uint32_t flags)
+sk_sp<SkColorSpace> SkColorSpace_Base::MakeRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50)
{
- bool nonLinearBlending = SkToBool(flags & kNonLinearBlending_ColorSpaceFlag);
switch (gammaNamed) {
case kSRGB_SkGammaNamed:
if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
- return nonLinearBlending
- ? SkColorSpace_Base::MakeNamed(kSRGB_NonLinearBlending_Named)
- : SkColorSpace_Base::MakeNamed(kSRGB_Named);
+ return SkColorSpace_Base::MakeNamed(kSRGB_Named);
}
break;
case k2Dot2Curve_SkGammaNamed:
- if (xyz_almost_equal(toXYZD50, gAdobeRGB_toXYZD50) && !nonLinearBlending) {
+ if (xyz_almost_equal(toXYZD50, gAdobeRGB_toXYZD50)) {
return SkColorSpace_Base::MakeNamed(kAdobeRGB_Named);
}
break;
case kLinear_SkGammaNamed:
- if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50) && !nonLinearBlending) {
+ if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
return SkColorSpace_Base::MakeNamed(kSRGBLinear_Named);
}
break;
@@ -142,37 +137,36 @@
break;
}
- return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(gammaNamed, toXYZD50, flags));
+ return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(gammaNamed, toXYZD50));
}
-sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, const SkMatrix44& toXYZD50,
- uint32_t flags) {
+sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, const SkMatrix44& toXYZD50) {
switch (gamma) {
case kLinear_RenderTargetGamma:
- return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, toXYZD50, flags);
+ return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, toXYZD50);
case kSRGB_RenderTargetGamma:
- return SkColorSpace_Base::MakeRGB(kSRGB_SkGammaNamed, toXYZD50, flags);
+ return SkColorSpace_Base::MakeRGB(kSRGB_SkGammaNamed, toXYZD50);
default:
return nullptr;
}
}
sk_sp<SkColorSpace> SkColorSpace::MakeRGB(const SkColorSpaceTransferFn& coeffs,
- const SkMatrix44& toXYZD50, uint32_t flags) {
+ const SkMatrix44& toXYZD50) {
if (!is_valid_transfer_fn(coeffs)) {
return nullptr;
}
if (is_almost_srgb(coeffs)) {
- return SkColorSpace::MakeRGB(kSRGB_RenderTargetGamma, toXYZD50, flags);
+ return SkColorSpace::MakeRGB(kSRGB_RenderTargetGamma, toXYZD50);
}
if (is_almost_2dot2(coeffs)) {
- return SkColorSpace_Base::MakeRGB(k2Dot2Curve_SkGammaNamed, toXYZD50, flags);
+ return SkColorSpace_Base::MakeRGB(k2Dot2Curve_SkGammaNamed, toXYZD50);
}
if (is_almost_linear(coeffs)) {
- return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, toXYZD50, flags);
+ return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, toXYZD50);
}
void* memory = sk_malloc_throw(sizeof(SkGammas) + sizeof(SkColorSpaceTransferFn));
@@ -186,32 +180,29 @@
gammas->fData[channel] = data;
}
return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(kNonStandard_SkGammaNamed,
- std::move(gammas), toXYZD50, nullptr, flags));
+ std::move(gammas), toXYZD50, nullptr));
}
-sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, Gamut gamut, uint32_t flags) {
+sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, Gamut gamut) {
SkMatrix44 toXYZD50(SkMatrix44::kUninitialized_Constructor);
to_xyz_d50(&toXYZD50, gamut);
- return SkColorSpace::MakeRGB(gamma, toXYZD50, flags);
+ return SkColorSpace::MakeRGB(gamma, toXYZD50);
}
-sk_sp<SkColorSpace> SkColorSpace::MakeRGB(const SkColorSpaceTransferFn& coeffs, Gamut gamut,
- uint32_t flags) {
+sk_sp<SkColorSpace> SkColorSpace::MakeRGB(const SkColorSpaceTransferFn& coeffs, Gamut gamut) {
SkMatrix44 toXYZD50(SkMatrix44::kUninitialized_Constructor);
to_xyz_d50(&toXYZD50, gamut);
- return SkColorSpace::MakeRGB(coeffs, toXYZD50, flags);
+ return SkColorSpace::MakeRGB(coeffs, toXYZD50);
}
static SkColorSpace* gAdobeRGB;
static SkColorSpace* gSRGB;
static SkColorSpace* gSRGBLinear;
-static SkColorSpace* gSRGBNonLinearBlending;
sk_sp<SkColorSpace> SkColorSpace_Base::MakeNamed(Named named) {
static SkOnce sRGBOnce;
static SkOnce adobeRGBOnce;
static SkOnce sRGBLinearOnce;
- static SkOnce sRGBNonLinearBlendingOnce;
switch (named) {
case kSRGB_Named: {
@@ -221,7 +212,7 @@
// Force the mutable type mask to be computed. This avoids races.
(void)srgbToxyzD50.getType();
- gSRGB = new SkColorSpace_XYZ(kSRGB_SkGammaNamed, srgbToxyzD50, 0 /* flags */);
+ gSRGB = new SkColorSpace_XYZ(kSRGB_SkGammaNamed, srgbToxyzD50);
});
return sk_ref_sp<SkColorSpace>(gSRGB);
}
@@ -232,8 +223,7 @@
// Force the mutable type mask to be computed. This avoids races.
(void)adobergbToxyzD50.getType();
- gAdobeRGB = new SkColorSpace_XYZ(k2Dot2Curve_SkGammaNamed, adobergbToxyzD50,
- 0 /* flags */);
+ gAdobeRGB = new SkColorSpace_XYZ(k2Dot2Curve_SkGammaNamed, adobergbToxyzD50);
});
return sk_ref_sp<SkColorSpace>(gAdobeRGB);
}
@@ -244,23 +234,10 @@
// Force the mutable type mask to be computed. This avoids races.
(void)srgbToxyzD50.getType();
- gSRGBLinear = new SkColorSpace_XYZ(kLinear_SkGammaNamed, srgbToxyzD50,
- 0 /* flags */);
+ gSRGBLinear = new SkColorSpace_XYZ(kLinear_SkGammaNamed, srgbToxyzD50);
});
return sk_ref_sp<SkColorSpace>(gSRGBLinear);
}
- case kSRGB_NonLinearBlending_Named: {
- sRGBNonLinearBlendingOnce([] {
- SkMatrix44 srgbToxyzD50(SkMatrix44::kUninitialized_Constructor);
- srgbToxyzD50.set3x3RowMajorf(gSRGB_toXYZD50);
-
- // Force the mutable type mask to be computed. This avoids races.
- (void)srgbToxyzD50.getType();
- gSRGBNonLinearBlending = new SkColorSpace_XYZ(kSRGB_SkGammaNamed, srgbToxyzD50,
- kNonLinearBlending_ColorSpaceFlag);
- });
- return sk_ref_sp<SkColorSpace>(gSRGBNonLinearBlending);
- }
default:
break;
}
@@ -300,35 +277,7 @@
}
bool SkColorSpace::isSRGB() const {
- return gSRGB == this || gSRGBNonLinearBlending == this;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-sk_sp<SkColorSpace> SkColorSpace_Base::makeWithoutFlags() {
- if (!fFlags) {
- return sk_ref_sp(this);
- }
-
- SkASSERT(Type::kXYZ == this->type());
- SkColorSpaceTransferFn fn;
- SkAssertResult(this->onIsNumericalTransferFn(&fn));
- return SkColorSpace::MakeRGB(fn, *this->toXYZD50(), 0);
-}
-
-sk_sp<SkColorSpace> SkColorSpace_Base::makeWithNonLinearBlending() {
- if (SkToBool(SkColorSpace::kNonLinearBlending_ColorSpaceFlag & fFlags)) {
- return sk_ref_sp(this);
- }
-
- // This should only be called on XYZ color spaces. A2B color spaces are never
- // allowed to be destinations - which means that this flag does not make any
- // sense for them.
- SkASSERT(Type::kXYZ == this->type());
- SkColorSpaceTransferFn fn;
- SkAssertResult(this->onIsNumericalTransferFn(&fn));
- return SkColorSpace::MakeRGB(fn, *this->toXYZD50(),
- SkColorSpace::kNonLinearBlending_ColorSpaceFlag);
+ return gSRGB == this;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -362,8 +311,7 @@
*/
static constexpr uint8_t kTransferFn_Flag = 1 << 3;
- static ColorSpaceHeader Pack(Version version, uint8_t named, uint8_t gammaNamed,
- bool nonLinearBlending, uint8_t flags)
+ static ColorSpaceHeader Pack(Version version, uint8_t named, uint8_t gammaNamed, uint8_t flags)
{
ColorSpaceHeader header;
@@ -376,8 +324,6 @@
SkASSERT(gammaNamed <= kNonStandard_SkGammaNamed);
header.fGammaNamed = (uint8_t) gammaNamed;
- header.fNonLinearBlend = nonLinearBlending ? 1 : 0;
-
SkASSERT(flags <= kTransferFn_Flag);
header.fFlags = flags;
return header;
@@ -386,8 +332,7 @@
uint8_t fVersion; // Always zero
uint8_t fNamed; // Must be a SkColorSpace::Named
uint8_t fGammaNamed; // Must be a SkGammaNamed
- uint8_t fNonLinearBlend : 1; // kNonLinearBlending_ColorSpaceFlag
- uint8_t fFlags : 7; // Some combination of the flags listed above
+ uint8_t fFlags;
};
size_t SkColorSpace::writeToMemory(void* memory) const {
@@ -402,26 +347,19 @@
if (this == gSRGB) {
if (memory) {
*((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
- k0_Version, SkColorSpace_Base::kSRGB_Named, gammaNamed, false, 0);
+ k0_Version, SkColorSpace_Base::kSRGB_Named, gammaNamed, 0);
}
return sizeof(ColorSpaceHeader);
} else if (this == gAdobeRGB) {
if (memory) {
*((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
- k0_Version, SkColorSpace_Base::kAdobeRGB_Named, gammaNamed, false, 0);
+ k0_Version, SkColorSpace_Base::kAdobeRGB_Named, gammaNamed, 0);
}
return sizeof(ColorSpaceHeader);
} else if (this == gSRGBLinear) {
if (memory) {
*((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
- k0_Version, SkColorSpace_Base::kSRGBLinear_Named, gammaNamed, false, 0);
- }
- return sizeof(ColorSpaceHeader);
- } else if (this == gSRGBNonLinearBlending) {
- if (memory) {
- *((ColorSpaceHeader*)memory) = ColorSpaceHeader::Pack(
- k0_Version, SkColorSpace_Base::kSRGB_NonLinearBlending_Named, gammaNamed,
- true, 0);
+ k0_Version, SkColorSpace_Base::kSRGBLinear_Named, gammaNamed, 0);
}
return sizeof(ColorSpaceHeader);
}
@@ -434,7 +372,6 @@
if (memory) {
*((ColorSpaceHeader*) memory) =
ColorSpaceHeader::Pack(k0_Version, 0, gammaNamed,
- thisXYZ->nonLinearBlending(),
ColorSpaceHeader::kMatrix_Flag);
memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
thisXYZ->toXYZD50()->as3x4RowMajorf((float*) memory);
@@ -453,7 +390,6 @@
if (memory) {
*((ColorSpaceHeader*) memory) =
ColorSpaceHeader::Pack(k0_Version, 0, thisXYZ->fGammaNamed,
- thisXYZ->nonLinearBlending(),
ColorSpaceHeader::kTransferFn_Flag);
memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
@@ -483,7 +419,6 @@
if (memory) {
*((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(k0_Version, 0,
kNonStandard_SkGammaNamed,
- as_CSB(this)->nonLinearBlending(),
ColorSpaceHeader::kICC_Flag);
memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
@@ -519,8 +454,6 @@
return SkColorSpace_Base::MakeNamed((SkColorSpace_Base::Named) header.fNamed);
}
- uint32_t colorSpaceFlags = header.fNonLinearBlend ? kNonLinearBlending_ColorSpaceFlag : 0;
-
switch ((SkGammaNamed) header.fGammaNamed) {
case kSRGB_SkGammaNamed:
case k2Dot2Curve_SkGammaNamed:
@@ -531,8 +464,7 @@
SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
toXYZ.set3x4RowMajorf((const float*) data);
- return SkColorSpace_Base::MakeRGB((SkGammaNamed) header.fGammaNamed, toXYZ,
- colorSpaceFlags);
+ return SkColorSpace_Base::MakeRGB((SkGammaNamed) header.fGammaNamed, toXYZ);
}
default:
break;
@@ -570,22 +502,13 @@
SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
toXYZ.set3x4RowMajorf((const float*) data);
- return SkColorSpace::MakeRGB(transferFn, toXYZ, colorSpaceFlags);
+ return SkColorSpace::MakeRGB(transferFn, toXYZ);
}
default:
return nullptr;
}
}
-bool SkColorSpace_Base::EqualsIgnoreFlags(SkColorSpace* src, SkColorSpace* dst) {
- if (!src || !dst) {
- return src == dst;
- }
-
- return SkColorSpace::Equals(as_CSB(src)->makeWithoutFlags().get(),
- as_CSB(dst)->makeWithoutFlags().get());
-}
-
bool SkColorSpace::Equals(const SkColorSpace* src, const SkColorSpace* dst) {
if (src == dst) {
return true;
@@ -614,9 +537,6 @@
if (srcXYZ->gammaNamed() != dstXYZ->gammaNamed()) {
return false;
}
- if (srcXYZ->nonLinearBlending() != dstXYZ->nonLinearBlending()) {
- return false;
- }
switch (srcXYZ->gammaNamed()) {
case kSRGB_SkGammaNamed:
diff --git a/src/core/SkColorSpaceXform.cpp b/src/core/SkColorSpaceXform.cpp
index 3179920..62cde5c 100644
--- a/src/core/SkColorSpaceXform.cpp
+++ b/src/core/SkColorSpaceXform.cpp
@@ -318,7 +318,7 @@
ColorSpaceMatch csm = kNone_ColorSpaceMatch;
SkMatrix44 srcToDst(SkMatrix44::kUninitialized_Constructor);
- if (SkColorSpace_Base::EqualsIgnoreFlags(srcSpace, dstSpace)) {
+ if (SkColorSpace::Equals(srcSpace, dstSpace)) {
srcToDst.setIdentity();
csm = kFull_ColorSpaceMatch;
} else {
diff --git a/src/core/SkColorSpace_A2B.cpp b/src/core/SkColorSpace_A2B.cpp
index 11df9cc..7e097ff 100644
--- a/src/core/SkColorSpace_A2B.cpp
+++ b/src/core/SkColorSpace_A2B.cpp
@@ -9,7 +9,7 @@
SkColorSpace_A2B::SkColorSpace_A2B(ICCTypeFlag iccType, std::vector<Element> elements,
PCS pcs, sk_sp<SkData> profileData)
- : INHERITED(std::move(profileData), 0)
+ : INHERITED(std::move(profileData))
, fICCType(iccType)
, fElements(std::move(elements))
, fPCS(pcs)
diff --git a/src/core/SkColorSpace_Base.h b/src/core/SkColorSpace_Base.h
index f9ef360..61f65a5 100644
--- a/src/core/SkColorSpace_Base.h
+++ b/src/core/SkColorSpace_Base.h
@@ -180,16 +180,12 @@
*/
virtual sk_sp<SkColorSpace> makeSRGBGamma() = 0;
- sk_sp<SkColorSpace> makeWithoutFlags();
- sk_sp<SkColorSpace> makeWithNonLinearBlending();
-
enum class Type : uint8_t {
kXYZ,
kA2B
};
virtual Type type() const = 0;
- bool nonLinearBlending() const { return SkToBool(fFlags & kNonLinearBlending_ColorSpaceFlag); }
typedef uint8_t ICCTypeFlag;
static constexpr ICCTypeFlag kRGB_ICCTypeFlag = 1 << 0;
@@ -198,8 +194,7 @@
static sk_sp<SkColorSpace> MakeICC(const void* input, size_t len, ICCTypeFlag type);
- static sk_sp<SkColorSpace> MakeRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50,
- uint32_t flags);
+ static sk_sp<SkColorSpace> MakeRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50);
enum Named : uint8_t {
kSRGB_Named,
@@ -210,14 +205,11 @@
static sk_sp<SkColorSpace> MakeNamed(Named);
- static bool EqualsIgnoreFlags(SkColorSpace* src, SkColorSpace* dst);
-
protected:
- SkColorSpace_Base(sk_sp<SkData> profileData, uint32_t flags);
+ SkColorSpace_Base(sk_sp<SkData> profileData);
private:
sk_sp<SkData> fProfileData;
- uint32_t fFlags;
friend class SkColorSpace;
friend class SkColorSpace_XYZ;
diff --git a/src/core/SkColorSpace_ICC.cpp b/src/core/SkColorSpace_ICC.cpp
index 3e080b2..9c2082a 100644
--- a/src/core/SkColorSpace_ICC.cpp
+++ b/src/core/SkColorSpace_ICC.cpp
@@ -1410,11 +1410,10 @@
if (kNonStandard_SkGammaNamed == gammaNamed) {
return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(gammaNamed,
std::move(gammas),
- mat, std::move(profileData),
- 0 /* flags */));
+ mat, std::move(profileData)));
}
- return SkColorSpace_Base::MakeRGB(gammaNamed, mat, 0 /* flags */);
+ return SkColorSpace_Base::MakeRGB(gammaNamed, mat);
}
static sk_sp<SkColorSpace> make_gray(const ICCProfileHeader& header, ICCTag* tags, int tagCount,
@@ -1439,7 +1438,7 @@
toXYZD50.setFloat(1, 1, kWhitePointD50[1]);
toXYZD50.setFloat(2, 2, kWhitePointD50[2]);
if (SkGammas::Type::kNamed_Type == type) {
- return SkColorSpace_Base::MakeRGB(data.fNamed, toXYZD50, 0 /* flags */);
+ return SkColorSpace_Base::MakeRGB(data.fNamed, toXYZD50);
}
size_t allocSize = sizeof(SkGammas);
@@ -1456,8 +1455,7 @@
return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(kNonStandard_SkGammaNamed,
std::move(gammas),
- toXYZD50, std::move(profileData),
- 0 /* flags */));
+ toXYZD50, std::move(profileData)));
}
static sk_sp<SkColorSpace> make_a2b(SkColorSpace_Base::ICCTypeFlag iccType,
diff --git a/src/core/SkColorSpace_XYZ.cpp b/src/core/SkColorSpace_XYZ.cpp
index a337768..baf9969 100644
--- a/src/core/SkColorSpace_XYZ.cpp
+++ b/src/core/SkColorSpace_XYZ.cpp
@@ -10,9 +10,8 @@
#include "SkColorSpaceXform_Base.h"
#include "SkOpts.h"
-SkColorSpace_XYZ::SkColorSpace_XYZ(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50,
- uint32_t flags)
- : INHERITED(nullptr, flags)
+SkColorSpace_XYZ::SkColorSpace_XYZ(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50)
+ : INHERITED(nullptr)
, fGammaNamed(gammaNamed)
, fGammas(nullptr)
, fToXYZD50(toXYZD50)
@@ -21,9 +20,8 @@
{}
SkColorSpace_XYZ::SkColorSpace_XYZ(SkGammaNamed gammaNamed, sk_sp<SkGammas> gammas,
- const SkMatrix44& toXYZD50, sk_sp<SkData> profileData,
- uint32_t flags)
- : INHERITED(std::move(profileData), flags)
+ const SkMatrix44& toXYZD50, sk_sp<SkData> profileData)
+ : INHERITED(std::move(profileData))
, fGammaNamed(gammaNamed)
, fGammas(std::move(gammas))
, fToXYZD50(toXYZD50)
@@ -88,14 +86,14 @@
if (this->gammaIsLinear()) {
return sk_ref_sp(this);
}
- return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, fToXYZD50, fFlags);
+ return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, fToXYZD50);
}
sk_sp<SkColorSpace> SkColorSpace_XYZ::makeSRGBGamma() {
if (this->gammaCloseToSRGB()) {
return sk_ref_sp(this);
}
- return SkColorSpace_Base::MakeRGB(kSRGB_SkGammaNamed, fToXYZD50, fFlags);
+ return SkColorSpace_Base::MakeRGB(kSRGB_SkGammaNamed, fToXYZD50);
}
void SkColorSpace_XYZ::toDstGammaTables(const uint8_t* tables[3], sk_sp<SkData>* storage,
diff --git a/src/core/SkColorSpace_XYZ.h b/src/core/SkColorSpace_XYZ.h
index c185452..d0ce0f8 100644
--- a/src/core/SkColorSpace_XYZ.h
+++ b/src/core/SkColorSpace_XYZ.h
@@ -36,10 +36,10 @@
void toDstGammaTables(const uint8_t* tables[3], sk_sp<SkData>* storage, int numTables) const;
- SkColorSpace_XYZ(SkGammaNamed gammaNamed, const SkMatrix44& toXYZ, uint32_t flags);
+ SkColorSpace_XYZ(SkGammaNamed gammaNamed, const SkMatrix44& toXYZ);
SkColorSpace_XYZ(SkGammaNamed gammaNamed, sk_sp<SkGammas> gammas,
- const SkMatrix44& toXYZ, sk_sp<SkData> profileData, uint32_t flags);
+ const SkMatrix44& toXYZ, sk_sp<SkData> profileData);
private:
const SkGammaNamed fGammaNamed;
diff --git a/src/core/SkRasterPipelineBlitter.cpp b/src/core/SkRasterPipelineBlitter.cpp
index fc69bf4..a926b43 100644
--- a/src/core/SkRasterPipelineBlitter.cpp
+++ b/src/core/SkRasterPipelineBlitter.cpp
@@ -23,12 +23,10 @@
static SkBlitter* Create(const SkPixmap&, const SkPaint&, const SkMatrix& ctm,
SkArenaAlloc*);
- SkRasterPipelineBlitter(SkPixmap dst, SkBlendMode blend, SkPM4f paintColor,
- bool nonLinearBlending)
+ SkRasterPipelineBlitter(SkPixmap dst, SkBlendMode blend, SkPM4f paintColor)
: fDst(dst)
, fBlend(blend)
, fPaintColor(paintColor)
- , fNonLinearBlending(nonLinearBlending)
{}
void blitH (int x, int y, int w) override;
@@ -49,7 +47,6 @@
SkBlendMode fBlend;
SkPM4f fPaintColor;
SkRasterPipeline fShader;
- bool fNonLinearBlending;
// We may be able to specialize blitH() into a memset.
bool fCanMemsetInBlitH = false;
@@ -92,12 +89,10 @@
const SkPaint& paint,
const SkMatrix& ctm,
SkArenaAlloc* alloc) {
- bool nonLinearBlending = dst.colorSpace() && as_CSB(dst.colorSpace())->nonLinearBlending();
auto blitter = alloc->make<SkRasterPipelineBlitter>(
dst,
paint.getBlendMode(),
- SkPM4f_from_SkColor(paint.getColor(), dst.colorSpace()),
- nonLinearBlending);
+ SkPM4f_from_SkColor(paint.getColor(), dst.colorSpace()));
SkBlendMode* blend = &blitter->fBlend;
@@ -130,11 +125,6 @@
pipeline->append(SkRasterPipeline::constant_color, paintColor);
}
- // Some people want the rest of the pipeline to operate on sRGB encoded color channels...
- if (nonLinearBlending && dst.info().gammaCloseToSRGB()) {
- pipeline->append(SkRasterPipeline::to_srgb);
- }
-
if (colorFilter) {
if (!colorFilter->appendStages(pipeline, dst.colorSpace(), alloc, is_opaque)) {
return nullptr;
@@ -191,7 +181,7 @@
}
void SkRasterPipelineBlitter::append_store(SkRasterPipeline* p) const {
- if (!fNonLinearBlending && fDst.info().gammaCloseToSRGB()) {
+ if (fDst.info().gammaCloseToSRGB()) {
p->append(SkRasterPipeline::to_srgb);
}
if (fDst.info().colorType() == kBGRA_8888_SkColorType) {
diff --git a/src/gpu/GrSurfaceContext.cpp b/src/gpu/GrSurfaceContext.cpp
index d3225e3..a28c27a 100644
--- a/src/gpu/GrSurfaceContext.cpp
+++ b/src/gpu/GrSurfaceContext.cpp
@@ -28,7 +28,3 @@
#endif
, fDrawingManager(drawingMgr) {
}
-
-bool GrSurfaceContext::isGammaCorrect() const {
- return fColorSpace && !as_CSB(fColorSpace)->nonLinearBlending();
-}
diff --git a/src/gpu/GrSurfaceContext.h b/src/gpu/GrSurfaceContext.h
index 109c4a0..88badc1 100644
--- a/src/gpu/GrSurfaceContext.h
+++ b/src/gpu/GrSurfaceContext.h
@@ -34,7 +34,7 @@
SkColorSpace* getColorSpace() const { return fColorSpace.get(); }
sk_sp<SkColorSpace> refColorSpace() const { return fColorSpace; }
- bool isGammaCorrect() const;
+ bool isGammaCorrect() const { return fColorSpace; }
// TODO: these two calls would be way cooler if this object had a GrSurfaceProxy pointer
int width() const { return this->asSurfaceProxy()->width(); }
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 27fe796..1551998 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -116,8 +116,7 @@
SkColorSpace* colorSpace = pixmap.colorSpace();
if (caps.srgbSupport() &&
- colorSpace && colorSpace->gammaCloseToSRGB() && !as_CSB(colorSpace)->nonLinearBlending() &&
- !GrPixelConfigIsSRGB(desc->fConfig)) {
+ colorSpace && colorSpace->gammaCloseToSRGB() && !GrPixelConfigIsSRGB(desc->fConfig)) {
// We were supplied an sRGB-like color space, but we don't have a suitable pixel config.
// Convert to 8888 sRGB so we can handle the data correctly. The raster backend doesn't
// handle sRGB Index8 -> sRGB 8888 correctly (yet), so lie about both the source and
@@ -365,12 +364,10 @@
case kARGB_4444_SkColorType:
return kRGBA_4444_GrPixelConfig;
case kRGBA_8888_SkColorType:
- return (caps.srgbSupport() && cs && cs->gammaCloseToSRGB() &&
- !as_CSB(cs)->nonLinearBlending())
+ return (caps.srgbSupport() && cs && cs->gammaCloseToSRGB())
? kSRGBA_8888_GrPixelConfig : kRGBA_8888_GrPixelConfig;
case kBGRA_8888_SkColorType:
- return (caps.srgbSupport() && cs && cs->gammaCloseToSRGB() &&
- !as_CSB(cs)->nonLinearBlending())
+ return (caps.srgbSupport() && cs && cs->gammaCloseToSRGB())
? kSBGRA_8888_GrPixelConfig : kBGRA_8888_GrPixelConfig;
case kIndex_8_SkColorType:
return kSkia8888_GrPixelConfig;
@@ -423,7 +420,7 @@
}
GrPixelConfig GrRenderableConfigForColorSpace(const SkColorSpace* colorSpace) {
- if (!colorSpace || as_CSB(colorSpace)->nonLinearBlending()) {
+ if (!colorSpace) {
return kRGBA_8888_GrPixelConfig;
} else if (colorSpace->gammaIsLinear()) {
return kRGBA_half_GrPixelConfig;
diff --git a/src/image/SkImage.cpp b/src/image/SkImage.cpp
index 566bdc0..e45bbd7 100644
--- a/src/image/SkImage.cpp
+++ b/src/image/SkImage.cpp
@@ -312,7 +312,7 @@
// (1) The color spaces are equal (nullptr is considered to be sRGB).
// (2) The color type is kAlpha8.
if ((!this->colorSpace() && target->isSRGB()) ||
- SkColorSpace_Base::EqualsIgnoreFlags(this->colorSpace(), target.get()) ||
+ SkColorSpace::Equals(this->colorSpace(), target.get()) ||
kAlpha_8_SkColorType == this->onImageInfo().colorType()) {
return sk_ref_sp(const_cast<SkImage_Base*>(this));
}
diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp
index fdbbf82..cef355e 100644
--- a/src/image/SkSurface_Gpu.cpp
+++ b/src/image/SkSurface_Gpu.cpp
@@ -186,15 +186,13 @@
return !colorSpace || colorSpace->gammaIsLinear();
case kSRGBA_8888_GrPixelConfig:
case kSBGRA_8888_GrPixelConfig:
- return context->caps()->srgbSupport() && colorSpace && colorSpace->gammaCloseToSRGB() &&
- !as_CSB(colorSpace)->nonLinearBlending();
+ return context->caps()->srgbSupport() && colorSpace && colorSpace->gammaCloseToSRGB();
case kRGBA_8888_GrPixelConfig:
case kBGRA_8888_GrPixelConfig:
// If we don't have sRGB support, we may get here with a color space. It still needs
// to be sRGB-like (so that the application will work correctly on sRGB devices.)
return !colorSpace ||
- (colorSpace->gammaCloseToSRGB() && (!context->caps()->srgbSupport() ||
- !as_CSB(colorSpace)->nonLinearBlending()));
+ (colorSpace->gammaCloseToSRGB() && !context->caps()->srgbSupport());
default:
return !colorSpace;
}
diff --git a/tests/ColorSpaceTest.cpp b/tests/ColorSpaceTest.cpp
index 059fa59..2eb7347 100644
--- a/tests/ColorSpaceTest.cpp
+++ b/tests/ColorSpaceTest.cpp
@@ -311,13 +311,6 @@
REPORTER_ASSERT(r, !SkColorSpace::Equals(upperRight.get(), adobe.get()));
REPORTER_ASSERT(r, !SkColorSpace::Equals(z30.get(), rgb4.get()));
REPORTER_ASSERT(r, !SkColorSpace::Equals(srgb.get(), rgb4.get()));
-
- sk_sp<SkColorSpace> srgbFlag =
- SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
- SkColorSpace::kSRGB_Gamut,
- SkColorSpace::kNonLinearBlending_ColorSpaceFlag);
- REPORTER_ASSERT(r, !SkColorSpace::Equals(srgb.get(), srgbFlag.get()));
- REPORTER_ASSERT(r, SkColorSpace_Base::EqualsIgnoreFlags(srgb.get(), srgbFlag.get()));
}
static inline bool matrix_almost_equal(const SkMatrix44& a, const SkMatrix44& b) {
@@ -481,8 +474,6 @@
DEF_TEST(ColorSpace_IsSRGB, r) {
sk_sp<SkColorSpace> srgb0 = SkColorSpace::MakeSRGB();
- sk_sp<SkColorSpace> srgb1 = SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
- SkColorSpace::kSRGB_Gamut, SkColorSpace::kNonLinearBlending_ColorSpaceFlag);
SkColorSpaceTransferFn fn;
fn.fA = 1.0f;
@@ -495,6 +486,5 @@
sk_sp<SkColorSpace> twoDotTwo = SkColorSpace::MakeRGB(fn, SkColorSpace::kSRGB_Gamut);
REPORTER_ASSERT(r, srgb0->isSRGB());
- REPORTER_ASSERT(r, srgb1->isSRGB());
REPORTER_ASSERT(r, !twoDotTwo->isSRGB());
}
diff --git a/tests/ColorSpaceXformTest.cpp b/tests/ColorSpaceXformTest.cpp
index 03c8f49..f8a5c8f 100644
--- a/tests/ColorSpaceXformTest.cpp
+++ b/tests/ColorSpaceXformTest.cpp
@@ -23,7 +23,7 @@
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_XYZ(
- kNonStandard_SkGammaNamed, gammas, SkMatrix::I(), nullptr, 0 /* flags */));
+ kNonStandard_SkGammaNamed, gammas, SkMatrix::I(), nullptr));
// Use special testing entry point, so we don't skip the xform, even though src == dst.
return SlowIdentityXform(static_cast<SkColorSpace_XYZ*>(space.get()));
@@ -53,7 +53,7 @@
SkColorSpace_Base::kRGB_ICCTypeFlag,
std::move(srcElements));
sk_sp<SkColorSpace> dstSpace(new SkColorSpace_XYZ(gammaNamed, gammas, arbitraryMatrix,
- nullptr, 0 /* flags */));
+ nullptr));
return SkColorSpaceXform::New(static_cast<SkColorSpace_A2B*>(srcSpace.get()),
static_cast<SkColorSpace_XYZ*>(dstSpace.get()));
diff --git a/tests/ICCTest.cpp b/tests/ICCTest.cpp
index e2f845c..5d541bd 100644
--- a/tests/ICCTest.cpp
+++ b/tests/ICCTest.cpp
@@ -161,7 +161,7 @@
static sk_sp<SkICC> MakeICC(sk_sp<SkGammas> gammas) {
return MakeICC(sk_sp<SkColorSpace>(new SkColorSpace_XYZ(
kNonStandard_SkGammaNamed, std::move(gammas),
- SkMatrix44(SkMatrix44::kIdentity_Constructor), nullptr, 0 /* flags */)));
+ SkMatrix44(SkMatrix44::kIdentity_Constructor), nullptr)));
}
};
diff --git a/tools/flags/SkCommonFlagsConfig.cpp b/tools/flags/SkCommonFlagsConfig.cpp
index b9d6a5d..1e980d2 100644
--- a/tools/flags/SkCommonFlagsConfig.cpp
+++ b/tools/flags/SkCommonFlagsConfig.cpp
@@ -306,14 +306,10 @@
}
const bool linearGamma = commands[0].equals("f16");
- const bool nonLinearBlending = commands[0].equals("srgbnl");
SkColorSpace::Gamut gamut = SkColorSpace::kSRGB_Gamut;
SkColorSpace::RenderTargetGamma gamma = linearGamma ? SkColorSpace::kLinear_RenderTargetGamma
: SkColorSpace::kSRGB_RenderTargetGamma;
- SkColorSpace::ColorSpaceFlags flags =
- nonLinearBlending ? SkColorSpace::kNonLinearBlending_ColorSpaceFlag
- : (SkColorSpace::ColorSpaceFlags) 0;
- *outColorSpace = SkColorSpace::MakeRGB(gamma, gamut, flags);
+ *outColorSpace = SkColorSpace::MakeRGB(gamma, gamut);
if (commands.count() == 2) {
if (commands[1].equals("srgb")) {
@@ -327,7 +323,7 @@
};
SkMatrix44 wideGamutRGBMatrix(SkMatrix44::kUninitialized_Constructor);
wideGamutRGBMatrix.set3x3RowMajorf(gWideGamutRGB_toXYZD50);
- *outColorSpace = SkColorSpace::MakeRGB(gamma, wideGamutRGBMatrix, flags);
+ *outColorSpace = SkColorSpace::MakeRGB(gamma, wideGamutRGBMatrix);
} else if (commands[1].equals("narrow")) {
// NarrowGamut RGB (an artifically smaller than sRGB gamut)
SkColorSpacePrimaries primaries ={
@@ -338,7 +334,7 @@
};
SkMatrix44 narrowGamutRGBMatrix(SkMatrix44::kUninitialized_Constructor);
primaries.toXYZD50(&narrowGamutRGBMatrix);
- *outColorSpace = SkColorSpace::MakeRGB(gamma, narrowGamutRGBMatrix, flags);
+ *outColorSpace = SkColorSpace::MakeRGB(gamma, narrowGamutRGBMatrix);
} else {
// Unknown color gamut
return false;