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
|
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkColorPriv.h"
#include "SkColorSpace_Base.h"
#include "SkColorSpaceXform.h"
bool compute_gamut_xform(SkMatrix44* srcToDst, const SkMatrix44& srcToXYZ,
const SkMatrix44& dstToXYZ) {
if (!dstToXYZ.invert(srcToDst)) {
return false;
}
srcToDst->postConcat(srcToXYZ);
return true;
}
std::unique_ptr<SkColorSpaceXform> SkColorSpaceXform::New(const sk_sp<SkColorSpace>& srcSpace,
const sk_sp<SkColorSpace>& dstSpace) {
if (!srcSpace || !dstSpace) {
return nullptr;
}
if (as_CSB(srcSpace)->gammas()->isValues() && as_CSB(dstSpace)->gammas()->isValues()) {
SkMatrix44 srcToDst(SkMatrix44::kUninitialized_Constructor);
if (!compute_gamut_xform(&srcToDst, srcSpace->xyz(), dstSpace->xyz())) {
return nullptr;
}
float srcGammas[3];
float dstGammas[3];
srcGammas[0] = as_CSB(srcSpace)->gammas()->fRed.fValue;
srcGammas[1] = as_CSB(srcSpace)->gammas()->fGreen.fValue;
srcGammas[2] = as_CSB(srcSpace)->gammas()->fBlue.fValue;
dstGammas[0] = 1.0f / as_CSB(dstSpace)->gammas()->fRed.fValue;
dstGammas[1] = 1.0f / as_CSB(dstSpace)->gammas()->fGreen.fValue;
dstGammas[2] = 1.0f / as_CSB(dstSpace)->gammas()->fBlue.fValue;
return std::unique_ptr<SkColorSpaceXform>(
new SkGammaByValueXform(srcGammas, srcToDst, dstGammas));
}
// Unimplemeted
return nullptr;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
SkGammaByValueXform::SkGammaByValueXform(float srcGammas[3], const SkMatrix44& srcToDst,
float dstGammas[3])
: fSrcToDst(srcToDst)
{
memcpy(fSrcGammas, srcGammas, 3 * sizeof(float));
memcpy(fDstGammas, dstGammas, 3 * sizeof(float));
}
static uint8_t clamp_float_to_byte(float v) {
v = v * 255.0f;
if (v > 255.0f) {
return 255;
} else if (v <= 0.0f) {
return 0;
} else {
return (uint8_t) (v + 0.5f);
}
}
void SkGammaByValueXform::xform_RGBA_8888(uint32_t* dst, const uint32_t* src, uint32_t len) const {
while (len-- > 0) {
float srcFloats[3];
srcFloats[0] = ((*src >> 0) & 0xFF) * (1.0f / 255.0f);
srcFloats[1] = ((*src >> 8) & 0xFF) * (1.0f / 255.0f);
srcFloats[2] = ((*src >> 16) & 0xFF) * (1.0f / 255.0f);
// Convert to linear.
srcFloats[0] = pow(srcFloats[0], fSrcGammas[0]);
srcFloats[1] = pow(srcFloats[1], fSrcGammas[1]);
srcFloats[2] = pow(srcFloats[2], fSrcGammas[2]);
// Convert to dst gamut.
float dstFloats[3];
dstFloats[0] = srcFloats[0] * fSrcToDst.getFloat(0, 0) +
srcFloats[1] * fSrcToDst.getFloat(1, 0) +
srcFloats[2] * fSrcToDst.getFloat(2, 0) + fSrcToDst.getFloat(3, 0);
dstFloats[1] = srcFloats[0] * fSrcToDst.getFloat(0, 1) +
srcFloats[1] * fSrcToDst.getFloat(1, 1) +
srcFloats[2] * fSrcToDst.getFloat(2, 1) + fSrcToDst.getFloat(3, 1);
dstFloats[2] = srcFloats[0] * fSrcToDst.getFloat(0, 2) +
srcFloats[1] * fSrcToDst.getFloat(1, 2) +
srcFloats[2] * fSrcToDst.getFloat(2, 2) + fSrcToDst.getFloat(3, 2);
// Convert to dst gamma.
dstFloats[0] = pow(dstFloats[0], fDstGammas[0]);
dstFloats[1] = pow(dstFloats[1], fDstGammas[1]);
dstFloats[2] = pow(dstFloats[2], fDstGammas[2]);
*dst = SkPackARGB32NoCheck(((*src >> 24) & 0xFF),
clamp_float_to_byte(dstFloats[0]),
clamp_float_to_byte(dstFloats[1]),
clamp_float_to_byte(dstFloats[2]));
dst++;
src++;
}
}
|
