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
|
/*
* Copyright 2012 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 "SkMergeImageFilter.h"
#include "SkCanvas.h"
#include "SkColorSpaceXformer.h"
#include "SkReadBuffer.h"
#include "SkSpecialImage.h"
#include "SkSpecialSurface.h"
#include "SkWriteBuffer.h"
#include "SkValidationUtils.h"
sk_sp<SkImageFilter> SkMergeImageFilter::Make(sk_sp<SkImageFilter>* const filters, int count,
const CropRect* cropRect) {
return sk_sp<SkImageFilter>(new SkMergeImageFilter(filters, count, cropRect));
}
///////////////////////////////////////////////////////////////////////////////
SkMergeImageFilter::SkMergeImageFilter(sk_sp<SkImageFilter>* const filters, int count,
const CropRect* cropRect)
: INHERITED(filters, count, cropRect) {
SkASSERT(count >= 0);
}
sk_sp<SkSpecialImage> SkMergeImageFilter::onFilterImage(SkSpecialImage* source, const Context& ctx,
SkIPoint* offset) const {
int inputCount = this->countInputs();
if (inputCount < 1) {
return nullptr;
}
SkIRect bounds;
bounds.setEmpty();
std::unique_ptr<sk_sp<SkSpecialImage>[]> inputs(new sk_sp<SkSpecialImage>[inputCount]);
std::unique_ptr<SkIPoint[]> offsets(new SkIPoint[inputCount]);
// Filter all of the inputs.
for (int i = 0; i < inputCount; ++i) {
offsets[i] = { 0, 0 };
inputs[i] = this->filterInput(i, source, ctx, &offsets[i]);
if (!inputs[i]) {
continue;
}
const SkIRect inputBounds = SkIRect::MakeXYWH(offsets[i].fX, offsets[i].fY,
inputs[i]->width(), inputs[i]->height());
bounds.join(inputBounds);
}
if (bounds.isEmpty()) {
return nullptr;
}
// Apply the crop rect to the union of the inputs' bounds.
// Note that the crop rect can only reduce the bounds, since this
// filter does not affect transparent black.
bool embiggen = false;
this->getCropRect().applyTo(bounds, ctx.ctm(), embiggen, &bounds);
if (!bounds.intersect(ctx.clipBounds())) {
return nullptr;
}
const int x0 = bounds.left();
const int y0 = bounds.top();
sk_sp<SkSpecialSurface> surf(source->makeSurface(ctx.outputProperties(), bounds.size()));
if (!surf) {
return nullptr;
}
SkCanvas* canvas = surf->getCanvas();
SkASSERT(canvas);
canvas->clear(0x0);
// Composite all of the filter inputs.
for (int i = 0; i < inputCount; ++i) {
if (!inputs[i]) {
continue;
}
inputs[i]->draw(canvas,
SkIntToScalar(offsets[i].x() - x0), SkIntToScalar(offsets[i].y() - y0),
nullptr);
}
offset->fX = bounds.left();
offset->fY = bounds.top();
return surf->makeImageSnapshot();
}
sk_sp<SkImageFilter> SkMergeImageFilter::onMakeColorSpace(SkColorSpaceXformer* xformer) const {
SkSTArray<5, sk_sp<SkImageFilter>> inputs(this->countInputs());
bool changed = false;
for (int i = 0; i < this->countInputs(); i++) {
inputs.push_back(xformer->apply(this->getInput(i)));
changed |= (inputs[i].get() != this->getInput(i));
}
if (changed) {
return SkMergeImageFilter::Make(inputs.begin(), this->countInputs(),
this->getCropRectIfSet());
}
return this->refMe();
}
sk_sp<SkFlattenable> SkMergeImageFilter::CreateProc(SkReadBuffer& buffer) {
Common common;
if (!common.unflatten(buffer, -1) || !buffer.isValid()) {
return nullptr;
}
return Make(common.inputs(), common.inputCount(), &common.cropRect());
}
void SkMergeImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
}
void SkMergeImageFilter::toString(SkString* str) const {
str->appendf("SkMergeImageFilter: (");
for (int i = 0; i < this->countInputs(); ++i) {
SkImageFilter* filter = this->getInput(i);
str->appendf("%d: (", i);
filter->toString(str);
str->appendf(")");
}
str->append(")");
}
|
