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
|
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkLumaColorFilter.h"
#include "SkColorPriv.h"
#include "SkString.h"
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrInvariantOutput.h"
#include "gl/GrGLProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
#endif
void SkLumaColorFilter::filterSpan(const SkPMColor src[], int count,
SkPMColor dst[]) const {
for (int i = 0; i < count; ++i) {
SkPMColor c = src[i];
/*
* While LuminanceToAlpha is defined to operate on un-premultiplied
* inputs, due to the final alpha scaling it can be computed based on
* premultipled components:
*
* LumA = (k1 * r / a + k2 * g / a + k3 * b / a) * a
* LumA = (k1 * r + k2 * g + k3 * b)
*/
unsigned luma = SkComputeLuminance(SkGetPackedR32(c),
SkGetPackedG32(c),
SkGetPackedB32(c));
dst[i] = SkPackARGB32(luma, 0, 0, 0);
}
}
SkColorFilter* SkLumaColorFilter::Create() {
return SkNEW(SkLumaColorFilter);
}
SkLumaColorFilter::SkLumaColorFilter() : INHERITED() {}
SkFlattenable* SkLumaColorFilter::CreateProc(SkReadBuffer&) {
return SkNEW(SkLumaColorFilter);
}
void SkLumaColorFilter::flatten(SkWriteBuffer&) const {}
#ifndef SK_IGNORE_TO_STRING
void SkLumaColorFilter::toString(SkString* str) const {
str->append("SkLumaColorFilter ");
}
#endif
#if SK_SUPPORT_GPU
class LumaColorFilterEffect : public GrFragmentProcessor {
public:
static GrFragmentProcessor* Create() {
GR_CREATE_STATIC_PROCESSOR(gLumaEffect, LumaColorFilterEffect, ());
return SkRef(gLumaEffect);
}
const char* name() const SK_OVERRIDE { return "Luminance-to-Alpha"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
GrProcessorKeyBuilder* b) const SK_OVERRIDE {
GLProcessor::GenKey(*this, caps, b);
}
GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
return SkNEW_ARGS(GLProcessor, (*this));
}
class GLProcessor : public GrGLFragmentProcessor {
public:
GLProcessor(const GrProcessor&) {}
static void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder* b) {}
virtual void emitCode(GrGLFPBuilder* builder,
const GrFragmentProcessor&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE {
if (NULL == inputColor) {
inputColor = "vec4(1)";
}
GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
fsBuilder->codeAppendf("\tfloat luma = dot(vec3(%f, %f, %f), %s.rgb);\n",
SK_ITU_BT709_LUM_COEFF_R,
SK_ITU_BT709_LUM_COEFF_G,
SK_ITU_BT709_LUM_COEFF_B,
inputColor);
fsBuilder->codeAppendf("\t%s = vec4(0, 0, 0, luma);\n",
outputColor);
}
private:
typedef GrGLFragmentProcessor INHERITED;
};
private:
LumaColorFilterEffect() {
this->initClassID<LumaColorFilterEffect>();
}
bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE { return true; }
void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
// The output is always black. The alpha value for the color passed in is arbitrary.
inout->setToOther(kRGB_GrColorComponentFlags, GrColorPackRGBA(0, 0, 0, 0),
GrInvariantOutput::kWill_ReadInput);
}
};
bool SkLumaColorFilter::asFragmentProcessors(GrContext*,
SkTDArray<GrFragmentProcessor*>* array) const {
GrFragmentProcessor* frag = LumaColorFilterEffect::Create();
if (frag) {
if (array) {
*array->append() = frag;
}
return true;
}
return false;
}
#endif
|
