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 2006 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkColorFilter.h"
#include "SkFilterShader.h"
#include "SkFlattenableBuffers.h"
#include "SkShader.h"
#include "SkUnPreMultiply.h"
#include "SkString.h"
SK_DEFINE_INST_COUNT(SkColorFilter)
bool SkColorFilter::asColorMode(SkColor* color, SkXfermode::Mode* mode) const {
return false;
}
bool SkColorFilter::asColorMatrix(SkScalar matrix[20]) const {
return false;
}
bool SkColorFilter::asComponentTable(SkBitmap*) const {
return false;
}
void SkColorFilter::filterSpan16(const uint16_t s[], int count, uint16_t d[]) const {
SkASSERT(this->getFlags() & SkColorFilter::kHasFilter16_Flag);
SkDEBUGFAIL("missing implementation of SkColorFilter::filterSpan16");
if (d != s) {
memcpy(d, s, count * sizeof(uint16_t));
}
}
SkColor SkColorFilter::filterColor(SkColor c) const {
SkPMColor dst, src = SkPreMultiplyColor(c);
this->filterSpan(&src, 1, &dst);
return SkUnPreMultiply::PMColorToColor(dst);
}
GrEffectRef* SkColorFilter::asNewEffect(GrContext*) const {
return NULL;
}
///////////////////////////////////////////////////////////////////////////////
SkFilterShader::SkFilterShader(SkShader* shader, SkColorFilter* filter) {
fShader = shader; shader->ref();
fFilter = filter; filter->ref();
}
SkFilterShader::SkFilterShader(SkFlattenableReadBuffer& buffer) :
INHERITED(buffer) {
fShader = buffer.readFlattenableT<SkShader>();
fFilter = buffer.readFlattenableT<SkColorFilter>();
}
SkFilterShader::~SkFilterShader() {
fFilter->unref();
fShader->unref();
}
void SkFilterShader::flatten(SkFlattenableWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeFlattenable(fShader);
buffer.writeFlattenable(fFilter);
}
uint32_t SkFilterShader::getFlags() {
uint32_t shaderF = fShader->getFlags();
uint32_t filterF = fFilter->getFlags();
// if the filter doesn't support 16bit, clear the matching bit in the shader
if (!(filterF & SkColorFilter::kHasFilter16_Flag)) {
shaderF &= ~SkShader::kHasSpan16_Flag;
}
// if the filter might change alpha, clear the opaque flag in the shader
if (!(filterF & SkColorFilter::kAlphaUnchanged_Flag)) {
shaderF &= ~(SkShader::kOpaqueAlpha_Flag | SkShader::kHasSpan16_Flag);
}
return shaderF;
}
bool SkFilterShader::setContext(const SkBitmap& device,
const SkPaint& paint,
const SkMatrix& matrix) {
// we need to keep the setContext/endContext calls balanced. If we return
// false, our endContext() will not be called.
if (!this->INHERITED::setContext(device, paint, matrix)) {
return false;
}
if (!fShader->setContext(device, paint, matrix)) {
this->INHERITED::endContext();
return false;
}
return true;
}
void SkFilterShader::endContext() {
fShader->endContext();
this->INHERITED::endContext();
}
void SkFilterShader::shadeSpan(int x, int y, SkPMColor result[], int count) {
fShader->shadeSpan(x, y, result, count);
fFilter->filterSpan(result, count, result);
}
void SkFilterShader::shadeSpan16(int x, int y, uint16_t result[], int count) {
SkASSERT(fShader->getFlags() & SkShader::kHasSpan16_Flag);
SkASSERT(fFilter->getFlags() & SkColorFilter::kHasFilter16_Flag);
fShader->shadeSpan16(x, y, result, count);
fFilter->filterSpan16(result, count, result);
}
#ifdef SK_DEVELOPER
void SkFilterShader::toString(SkString* str) const {
str->append("SkFilterShader: (");
str->append("Shader: ");
fShader->toString(str);
str->append(" Filter: ");
// TODO: add "fFilter->toString(str);" once SkColorFilter::toString is added
this->INHERITED::toString(str);
str->append(")");
}
#endif
|
