msarett | bb9f774 | 2016-05-17 09:31:20 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2016 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
msarett | 8cc2091 | 2016-05-23 09:29:29 -0700 | [diff] [blame] | 8 | #ifndef SkColorSpace_Base_DEFINED |
| 9 | #define SkColorSpace_Base_DEFINED |
| 10 | |
| 11 | #include "SkColorSpace.h" |
msarett | ab926f0 | 2016-05-25 08:53:40 -0700 | [diff] [blame] | 12 | #include "SkData.h" |
msarett | e077e06 | 2016-05-24 10:16:53 -0700 | [diff] [blame] | 13 | #include "SkTemplates.h" |
msarett | bb9f774 | 2016-05-17 09:31:20 -0700 | [diff] [blame] | 14 | |
msarett | 2aec3ff | 2016-07-20 12:58:52 -0700 | [diff] [blame^] | 15 | struct SkGammaCurve { |
| 16 | bool isNamed() const { |
| 17 | bool result = (SkColorSpace::kNonStandard_GammaNamed != fNamed); |
| 18 | SkASSERT(!result || (0.0f == fValue)); |
| 19 | SkASSERT(!result || (0 == fTableSize)); |
| 20 | SkASSERT(!result || (0.0f == fG && 0.0f == fE)); |
| 21 | return result; |
msarett | dc27a64 | 2016-06-06 12:02:31 -0700 | [diff] [blame] | 22 | } |
| 23 | |
msarett | 2aec3ff | 2016-07-20 12:58:52 -0700 | [diff] [blame^] | 24 | bool isValue() const { |
| 25 | bool result = (0.0f != fValue); |
| 26 | SkASSERT(!result || SkColorSpace::kNonStandard_GammaNamed == fNamed); |
| 27 | SkASSERT(!result || (0 == fTableSize)); |
| 28 | SkASSERT(!result || (0.0f == fG && 0.0f == fE)); |
| 29 | return result; |
msarett | 2ea944c | 2016-07-20 11:44:42 -0700 | [diff] [blame] | 30 | } |
msarett | bb9f774 | 2016-05-17 09:31:20 -0700 | [diff] [blame] | 31 | |
msarett | 2aec3ff | 2016-07-20 12:58:52 -0700 | [diff] [blame^] | 32 | bool isTable() const { |
| 33 | bool result = (0 != fTableSize); |
| 34 | SkASSERT(!result || SkColorSpace::kNonStandard_GammaNamed == fNamed); |
| 35 | SkASSERT(!result || (0.0f == fValue)); |
| 36 | SkASSERT(!result || (0.0f == fG && 0.0f == fE)); |
| 37 | SkASSERT(!result || fTable); |
| 38 | return result; |
msarett | 2ea944c | 2016-07-20 11:44:42 -0700 | [diff] [blame] | 39 | } |
| 40 | |
msarett | 2aec3ff | 2016-07-20 12:58:52 -0700 | [diff] [blame^] | 41 | bool isParametric() const { |
| 42 | bool result = (0.0f != fG || 0.0f != fE); |
| 43 | SkASSERT(!result || SkColorSpace::kNonStandard_GammaNamed == fNamed); |
| 44 | SkASSERT(!result || (0.0f == fValue)); |
| 45 | SkASSERT(!result || (0 == fTableSize)); |
| 46 | return result; |
msarett | 2ea944c | 2016-07-20 11:44:42 -0700 | [diff] [blame] | 47 | } |
| 48 | |
msarett | 2aec3ff | 2016-07-20 12:58:52 -0700 | [diff] [blame^] | 49 | // We have four different ways to represent gamma. |
| 50 | // (1) A known, named type: |
| 51 | SkColorSpace::GammaNamed fNamed; |
msarett | 2ea944c | 2016-07-20 11:44:42 -0700 | [diff] [blame] | 52 | |
msarett | 2aec3ff | 2016-07-20 12:58:52 -0700 | [diff] [blame^] | 53 | // (2) A single value: |
| 54 | float fValue; |
msarett | 2ea944c | 2016-07-20 11:44:42 -0700 | [diff] [blame] | 55 | |
msarett | 2aec3ff | 2016-07-20 12:58:52 -0700 | [diff] [blame^] | 56 | // (3) A lookup table: |
| 57 | uint32_t fTableSize; |
| 58 | std::unique_ptr<float[]> fTable; |
msarett | 2ea944c | 2016-07-20 11:44:42 -0700 | [diff] [blame] | 59 | |
msarett | 2aec3ff | 2016-07-20 12:58:52 -0700 | [diff] [blame^] | 60 | // (4) Parameters for a curve: |
| 61 | // Y = (aX + b)^g + c for X >= d |
| 62 | // Y = eX + f otherwise |
| 63 | float fG; |
| 64 | float fA; |
| 65 | float fB; |
| 66 | float fC; |
| 67 | float fD; |
| 68 | float fE; |
| 69 | float fF; |
| 70 | |
| 71 | SkGammaCurve() |
| 72 | : fNamed(SkColorSpace::kNonStandard_GammaNamed) |
| 73 | , fValue(0.0f) |
| 74 | , fTableSize(0) |
| 75 | , fTable(nullptr) |
| 76 | , fG(0.0f) |
| 77 | , fA(0.0f) |
| 78 | , fB(0.0f) |
| 79 | , fC(0.0f) |
| 80 | , fD(0.0f) |
| 81 | , fE(0.0f) |
| 82 | , fF(0.0f) |
msarett | 264f88a | 2016-05-17 13:57:15 -0700 | [diff] [blame] | 83 | {} |
| 84 | |
msarett | 2aec3ff | 2016-07-20 12:58:52 -0700 | [diff] [blame^] | 85 | bool quickEquals(const SkGammaCurve& that) const { |
| 86 | return (this->fNamed == that.fNamed) && (this->fValue == that.fValue) && |
| 87 | (this->fTableSize == that.fTableSize) && (this->fTable == that.fTable) && |
| 88 | (this->fG == that.fG) && (this->fA == that.fA) && (this->fB == that.fB) && |
| 89 | (this->fC == that.fC) && (this->fD == that.fD) && (this->fE == that.fE) && |
| 90 | (this->fF == that.fF); |
| 91 | } |
| 92 | }; |
| 93 | |
| 94 | struct SkGammas : public SkRefCnt { |
| 95 | public: |
| 96 | static SkColorSpace::GammaNamed Named(SkGammaCurve curves[3]) { |
| 97 | if (SkColorSpace::kLinear_GammaNamed == curves[0].fNamed && |
| 98 | SkColorSpace::kLinear_GammaNamed == curves[1].fNamed && |
| 99 | SkColorSpace::kLinear_GammaNamed == curves[2].fNamed) |
| 100 | { |
| 101 | return SkColorSpace::kLinear_GammaNamed; |
| 102 | } |
| 103 | |
| 104 | if (SkColorSpace::kSRGB_GammaNamed == curves[0].fNamed && |
| 105 | SkColorSpace::kSRGB_GammaNamed == curves[1].fNamed && |
| 106 | SkColorSpace::kSRGB_GammaNamed == curves[2].fNamed) |
| 107 | { |
| 108 | return SkColorSpace::kSRGB_GammaNamed; |
| 109 | } |
| 110 | |
| 111 | if (SkColorSpace::k2Dot2Curve_GammaNamed == curves[0].fNamed && |
| 112 | SkColorSpace::k2Dot2Curve_GammaNamed == curves[1].fNamed && |
| 113 | SkColorSpace::k2Dot2Curve_GammaNamed == curves[2].fNamed) |
| 114 | { |
| 115 | return SkColorSpace::k2Dot2Curve_GammaNamed; |
| 116 | } |
| 117 | |
| 118 | return SkColorSpace::kNonStandard_GammaNamed; |
| 119 | } |
| 120 | |
| 121 | const SkGammaCurve& operator[](int i) const { |
| 122 | SkASSERT(0 <= i && i < 3); |
| 123 | return (&fRed)[i]; |
| 124 | } |
| 125 | |
| 126 | const SkGammaCurve fRed; |
| 127 | const SkGammaCurve fGreen; |
| 128 | const SkGammaCurve fBlue; |
| 129 | |
| 130 | SkGammas(SkGammaCurve red, SkGammaCurve green, SkGammaCurve blue) |
| 131 | : fRed(std::move(red)) |
| 132 | , fGreen(std::move(green)) |
| 133 | , fBlue(std::move(blue)) |
| 134 | {} |
| 135 | |
| 136 | SkGammas() {} |
| 137 | |
| 138 | friend class SkColorSpace; |
msarett | bb9f774 | 2016-05-17 09:31:20 -0700 | [diff] [blame] | 139 | }; |
| 140 | |
msarett | 0f83e01 | 2016-06-23 15:12:52 -0700 | [diff] [blame] | 141 | struct SkColorLookUpTable : public SkRefCnt { |
msarett | bb9f774 | 2016-05-17 09:31:20 -0700 | [diff] [blame] | 142 | uint8_t fInputChannels; |
| 143 | uint8_t fOutputChannels; |
msarett | 0f83e01 | 2016-06-23 15:12:52 -0700 | [diff] [blame] | 144 | uint8_t fGridPoints[3]; |
msarett | bb9f774 | 2016-05-17 09:31:20 -0700 | [diff] [blame] | 145 | std::unique_ptr<float[]> fTable; |
| 146 | |
msarett | 0f83e01 | 2016-06-23 15:12:52 -0700 | [diff] [blame] | 147 | SkColorLookUpTable() |
| 148 | : fInputChannels(0) |
| 149 | , fOutputChannels(0) |
| 150 | , fTable(nullptr) |
| 151 | { |
| 152 | fGridPoints[0] = fGridPoints[1] = fGridPoints[2] = 0; |
msarett | bb9f774 | 2016-05-17 09:31:20 -0700 | [diff] [blame] | 153 | } |
| 154 | }; |
| 155 | |
msarett | 8cc2091 | 2016-05-23 09:29:29 -0700 | [diff] [blame] | 156 | class SkColorSpace_Base : public SkColorSpace { |
| 157 | public: |
| 158 | |
msarett | c4ce6b5 | 2016-06-16 07:37:41 -0700 | [diff] [blame] | 159 | static sk_sp<SkColorSpace> NewRGB(float gammas[3], const SkMatrix44& toXYZD50); |
| 160 | |
msarett | b390676 | 2016-06-22 14:07:48 -0700 | [diff] [blame] | 161 | const SkGammas* gammas() const { return fGammas.get(); } |
msarett | 8cc2091 | 2016-05-23 09:29:29 -0700 | [diff] [blame] | 162 | |
msarett | b390676 | 2016-06-22 14:07:48 -0700 | [diff] [blame] | 163 | const SkColorLookUpTable* colorLUT() const { return fColorLUT.get(); } |
msarett | dc27a64 | 2016-06-06 12:02:31 -0700 | [diff] [blame] | 164 | |
msarett | ab926f0 | 2016-05-25 08:53:40 -0700 | [diff] [blame] | 165 | /** |
| 166 | * Writes this object as an ICC profile. |
| 167 | */ |
| 168 | sk_sp<SkData> writeToICC() const; |
| 169 | |
msarett | 8cc2091 | 2016-05-23 09:29:29 -0700 | [diff] [blame] | 170 | private: |
| 171 | |
msarett | 111a42d | 2016-06-22 08:18:54 -0700 | [diff] [blame] | 172 | static sk_sp<SkColorSpace> NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50); |
msarett | ab926f0 | 2016-05-25 08:53:40 -0700 | [diff] [blame] | 173 | |
msarett | 111a42d | 2016-06-22 08:18:54 -0700 | [diff] [blame] | 174 | SkColorSpace_Base(GammaNamed gammaNamed, const SkMatrix44& toXYZ, Named named); |
msarett | 8cc2091 | 2016-05-23 09:29:29 -0700 | [diff] [blame] | 175 | |
msarett | 2aec3ff | 2016-07-20 12:58:52 -0700 | [diff] [blame^] | 176 | SkColorSpace_Base(sk_sp<SkColorLookUpTable> colorLUT, sk_sp<SkGammas> gammas, |
| 177 | const SkMatrix44& toXYZ, sk_sp<SkData> profileData); |
msarett | 8cc2091 | 2016-05-23 09:29:29 -0700 | [diff] [blame] | 178 | |
msarett | 0f83e01 | 2016-06-23 15:12:52 -0700 | [diff] [blame] | 179 | sk_sp<SkColorLookUpTable> fColorLUT; |
| 180 | sk_sp<SkGammas> fGammas; |
| 181 | sk_sp<SkData> fProfileData; |
msarett | 8cc2091 | 2016-05-23 09:29:29 -0700 | [diff] [blame] | 182 | |
| 183 | friend class SkColorSpace; |
msarett | b390676 | 2016-06-22 14:07:48 -0700 | [diff] [blame] | 184 | friend class ColorSpaceXformTest; |
msarett | 8cc2091 | 2016-05-23 09:29:29 -0700 | [diff] [blame] | 185 | typedef SkColorSpace INHERITED; |
| 186 | }; |
| 187 | |
| 188 | static inline SkColorSpace_Base* as_CSB(SkColorSpace* colorSpace) { |
| 189 | return static_cast<SkColorSpace_Base*>(colorSpace); |
| 190 | } |
| 191 | |
msarett | ab926f0 | 2016-05-25 08:53:40 -0700 | [diff] [blame] | 192 | static inline const SkColorSpace_Base* as_CSB(const SkColorSpace* colorSpace) { |
| 193 | return static_cast<const SkColorSpace_Base*>(colorSpace); |
| 194 | } |
| 195 | |
msarett | 888dc16 | 2016-05-23 10:21:17 -0700 | [diff] [blame] | 196 | static inline SkColorSpace_Base* as_CSB(const sk_sp<SkColorSpace>& colorSpace) { |
| 197 | return static_cast<SkColorSpace_Base*>(colorSpace.get()); |
| 198 | } |
| 199 | |
msarett | bb9f774 | 2016-05-17 09:31:20 -0700 | [diff] [blame] | 200 | #endif |