1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkColorSpace_Base_DEFINED
#define SkColorSpace_Base_DEFINED
#include "SkColorSpace.h"
#include "SkData.h"
#include "SkTemplates.h"
struct SkGammas : SkRefCnt {
// There are four possible representations for gamma curves. kNone_Type is used
// as a placeholder until the struct is initialized. It is not a valid value.
enum class Type : uint8_t {
kNone_Type,
kNamed_Type,
kValue_Type,
kTable_Type,
kParam_Type,
};
// Contains information for a gamma table.
struct Table {
size_t fOffset;
int fSize;
const float* table(const SkGammas* base) const {
return SkTAddOffset<const float>(base, sizeof(SkGammas) + fOffset);
}
};
// Contains the parameters for a parametric curve.
struct Params {
// Y = (aX + b)^g + c for X >= d
// Y = eX + f otherwise
float fG;
float fA;
float fB;
float fC;
float fD;
float fE;
float fF;
};
// Contains the actual gamma curve information. Should be interpreted
// based on the type of the gamma curve.
union Data {
Data()
: fTable{ 0, 0 }
{}
inline bool operator==(const Data& that) const {
return this->fTable.fOffset == that.fTable.fOffset &&
this->fTable.fSize == that.fTable.fSize;
}
SkColorSpace::GammaNamed fNamed;
float fValue;
Table fTable;
size_t fParamOffset;
const Params& params(const SkGammas* base) const {
return *SkTAddOffset<const Params>(base, sizeof(SkGammas) + fParamOffset);
}
};
bool isNamed(int i) const {
SkASSERT(0 <= i && i < 3);
return (&fRedType)[i] == Type::kNamed_Type;
}
bool isValue(int i) const {
SkASSERT(0 <= i && i < 3);
return (&fRedType)[i] == Type::kValue_Type;
}
bool isTable(int i) const {
SkASSERT(0 <= i && i < 3);
return (&fRedType)[i] == Type::kTable_Type;
}
bool isParametric(int i) const {
SkASSERT(0 <= i && i < 3);
return (&fRedType)[i] == Type::kParam_Type;
}
const Data& data(int i) const {
SkASSERT(0 <= i && i < 3);
return (&fRedData)[i];
}
const float* table(int i) const {
SkASSERT(isTable(i));
return (&fRedData)[i].fTable.table(this);
}
const Params& params(int i) const {
SkASSERT(isParametric(i));
return (&fRedData)[i].params(this);
}
SkGammas()
: fRedType(Type::kNone_Type)
, fGreenType(Type::kNone_Type)
, fBlueType(Type::kNone_Type)
{}
// These fields should only be modified when initializing the struct.
Data fRedData;
Data fGreenData;
Data fBlueData;
Type fRedType;
Type fGreenType;
Type fBlueType;
// Objects of this type are sometimes created in a custom fashion using
// sk_malloc_throw and therefore must be sk_freed. We overload new to
// also call sk_malloc_throw so that memory can be unconditionally released
// using sk_free in an overloaded delete. Overloading regular new means we
// must also overload placement new.
void* operator new(size_t size) { return sk_malloc_throw(size); }
void* operator new(size_t, void* p) { return p; }
void operator delete(void* p) { sk_free(p); }
};
struct SkColorLookUpTable : public SkRefCnt {
static constexpr uint8_t kOutputChannels = 3;
uint8_t fInputChannels;
uint8_t fGridPoints[3];
const float* table() const {
return SkTAddOffset<const float>(this, sizeof(SkColorLookUpTable));
}
SkColorLookUpTable(uint8_t inputChannels, uint8_t gridPoints[3])
: fInputChannels(inputChannels)
{
SkASSERT(3 == inputChannels);
memcpy(fGridPoints, gridPoints, 3 * sizeof(uint8_t));
}
// Objects of this type are created in a custom fashion using sk_malloc_throw
// and therefore must be sk_freed.
void* operator new(size_t size) = delete;
void* operator new(size_t, void* p) { return p; }
void operator delete(void* p) { sk_free(p); }
};
class SkColorSpace_Base : public SkColorSpace {
public:
static sk_sp<SkColorSpace> NewRGB(float gammas[3], const SkMatrix44& toXYZD50);
const SkGammas* gammas() const { return fGammas.get(); }
const SkColorLookUpTable* colorLUT() const { return fColorLUT.get(); }
/**
* Writes this object as an ICC profile.
*/
sk_sp<SkData> writeToICC() const;
private:
static sk_sp<SkColorSpace> NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50);
SkColorSpace_Base(GammaNamed gammaNamed, const SkMatrix44& toXYZ, Named named);
SkColorSpace_Base(sk_sp<SkColorLookUpTable> colorLUT, GammaNamed gammaNamed,
sk_sp<SkGammas> gammas, const SkMatrix44& toXYZ, sk_sp<SkData> profileData);
sk_sp<SkColorLookUpTable> fColorLUT;
sk_sp<SkGammas> fGammas;
sk_sp<SkData> fProfileData;
friend class SkColorSpace;
friend class ColorSpaceXformTest;
typedef SkColorSpace INHERITED;
};
static inline SkColorSpace_Base* as_CSB(SkColorSpace* colorSpace) {
return static_cast<SkColorSpace_Base*>(colorSpace);
}
static inline const SkColorSpace_Base* as_CSB(const SkColorSpace* colorSpace) {
return static_cast<const SkColorSpace_Base*>(colorSpace);
}
static inline SkColorSpace_Base* as_CSB(const sk_sp<SkColorSpace>& colorSpace) {
return static_cast<SkColorSpace_Base*>(colorSpace.get());
}
#endif
|
