1 /*
2 * Copyright 2013 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "include/core/SkCanvas.h"
9 #include "include/core/SkImage.h"
10 #include "include/core/SkMatrix.h"
11 #include "include/core/SkPaint.h"
12 #include "include/core/SkShader.h"
13 #include "include/core/SkSurface.h"
14 #include "include/effects/SkImageFilters.h"
15 #include "src/core/SkImageFilter_Base.h"
16 #include "src/core/SkReadBuffer.h"
17 #include "src/core/SkSpecialImage.h"
18 #include "src/core/SkSpecialSurface.h"
19 #include "src/core/SkValidationUtils.h"
20 #include "src/core/SkWriteBuffer.h"
21
22 namespace {
23
24 class SkTileImageFilter final : public SkImageFilter_Base {
25 public:
SkTileImageFilter(const SkRect & srcRect,const SkRect & dstRect,sk_sp<SkImageFilter> input)26 SkTileImageFilter(const SkRect& srcRect, const SkRect& dstRect, sk_sp<SkImageFilter> input)
27 : INHERITED(&input, 1, nullptr)
28 , fSrcRect(srcRect)
29 , fDstRect(dstRect) {}
30
31 SkIRect onFilterBounds(const SkIRect& src, const SkMatrix& ctm,
32 MapDirection, const SkIRect* inputRect) const override;
33 SkIRect onFilterNodeBounds(const SkIRect&, const SkMatrix& ctm,
34 MapDirection, const SkIRect* inputRect) const override;
35 SkRect computeFastBounds(const SkRect& src) const override;
36
37 protected:
38 void flatten(SkWriteBuffer& buffer) const override;
39
40 sk_sp<SkSpecialImage> onFilterImage(const Context&, SkIPoint* offset) const override;
41
42 private:
43 friend void ::SkRegisterTileImageFilterFlattenable();
44 SK_FLATTENABLE_HOOKS(SkTileImageFilter)
45
46 SkRect fSrcRect;
47 SkRect fDstRect;
48
49 using INHERITED = SkImageFilter_Base;
50 };
51
52 } // end namespace
53
54
Tile(const SkRect & src,const SkRect & dst,sk_sp<SkImageFilter> input)55 sk_sp<SkImageFilter> SkImageFilters::Tile(const SkRect& src,
56 const SkRect& dst,
57 sk_sp<SkImageFilter> input) {
58 if (!SkIsValidRect(src) || !SkIsValidRect(dst)) {
59 return nullptr;
60 }
61 if (src.width() == dst.width() && src.height() == dst.height()) {
62 SkRect ir = dst;
63 if (!ir.intersect(src)) {
64 return input;
65 }
66 return SkImageFilters::Offset(dst.x() - src.x(), dst.y() - src.y(),
67 std::move(input), &ir);
68 }
69 return sk_sp<SkImageFilter>(new SkTileImageFilter(src, dst, std::move(input)));
70 }
71
SkRegisterTileImageFilterFlattenable()72 void SkRegisterTileImageFilterFlattenable() {
73 SK_REGISTER_FLATTENABLE(SkTileImageFilter);
74 // TODO (michaelludwig) - Remove after grace period for SKPs to stop using old name
75 SkFlattenable::Register("SkTileImageFilterImpl", SkTileImageFilter::CreateProc);
76 }
77
CreateProc(SkReadBuffer & buffer)78 sk_sp<SkFlattenable> SkTileImageFilter::CreateProc(SkReadBuffer& buffer) {
79 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
80 SkRect src, dst;
81 buffer.readRect(&src);
82 buffer.readRect(&dst);
83 return SkImageFilters::Tile(src, dst, common.getInput(0));
84 }
85
flatten(SkWriteBuffer & buffer) const86 void SkTileImageFilter::flatten(SkWriteBuffer& buffer) const {
87 this->INHERITED::flatten(buffer);
88 buffer.writeRect(fSrcRect);
89 buffer.writeRect(fDstRect);
90 }
91
92 ///////////////////////////////////////////////////////////////////////////////////////////////////
93
onFilterImage(const Context & ctx,SkIPoint * offset) const94 sk_sp<SkSpecialImage> SkTileImageFilter::onFilterImage(const Context& ctx,
95 SkIPoint* offset) const {
96 SkIPoint inputOffset = SkIPoint::Make(0, 0);
97 sk_sp<SkSpecialImage> input(this->filterInput(0, ctx, &inputOffset));
98 if (!input) {
99 return nullptr;
100 }
101
102 SkRect dstRect;
103 ctx.ctm().mapRect(&dstRect, fDstRect);
104 if (!dstRect.intersect(SkRect::Make(ctx.clipBounds()))) {
105 return nullptr;
106 }
107
108 static const float kRoundOutInset = 1e-3f;
109 const SkIRect dstIRect = dstRect.makeInset(kRoundOutInset, kRoundOutInset).roundOut();
110 if (!fSrcRect.width() || !fSrcRect.height() || !dstIRect.width() || !dstIRect.height()) {
111 return nullptr;
112 }
113
114 SkRect srcRect;
115 ctx.ctm().mapRect(&srcRect, fSrcRect);
116 SkIRect srcIRect = srcRect.makeInset(kRoundOutInset, kRoundOutInset).roundOut();
117 srcIRect.offset(-inputOffset);
118 const SkIRect inputBounds = SkIRect::MakeWH(input->width(), input->height());
119
120 if (!SkIRect::Intersects(srcIRect, inputBounds)) {
121 return nullptr;
122 }
123
124 // We create an SkImage here b.c. it needs to be a tight fit for the tiling
125 sk_sp<SkImage> subset;
126 if (inputBounds.contains(srcIRect)) {
127 subset = input->asImage(&srcIRect);
128 } else {
129 sk_sp<SkSurface> surf(input->makeTightSurface(ctx.colorType(), ctx.colorSpace(),
130 srcIRect.size()));
131 if (!surf) {
132 return nullptr;
133 }
134
135 SkCanvas* canvas = surf->getCanvas();
136 SkASSERT(canvas);
137
138 SkPaint paint;
139 paint.setBlendMode(SkBlendMode::kSrc);
140
141 input->draw(canvas,
142 SkIntToScalar(inputOffset.x()), SkIntToScalar(inputOffset.y()),
143 SkSamplingOptions(), &paint);
144
145 subset = surf->makeImageSnapshot();
146 }
147 if (!subset) {
148 return nullptr;
149 }
150 SkASSERT(subset->width() == srcIRect.width());
151 SkASSERT(subset->height() == srcIRect.height());
152
153 sk_sp<SkSpecialSurface> surf(ctx.makeSurface(dstIRect.size()));
154 if (!surf) {
155 return nullptr;
156 }
157
158 SkCanvas* canvas = surf->getCanvas();
159 SkASSERT(canvas);
160
161 SkPaint paint;
162 paint.setBlendMode(SkBlendMode::kSrc);
163 paint.setShader(subset->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat,
164 SkSamplingOptions()));
165 canvas->translate(-dstRect.fLeft, -dstRect.fTop);
166 canvas->drawRect(dstRect, paint);
167 offset->fX = dstIRect.fLeft;
168 offset->fY = dstIRect.fTop;
169 return surf->makeImageSnapshot();
170 }
171
onFilterNodeBounds(const SkIRect & src,const SkMatrix & ctm,MapDirection dir,const SkIRect * inputRect) const172 SkIRect SkTileImageFilter::onFilterNodeBounds(
173 const SkIRect& src, const SkMatrix& ctm, MapDirection dir, const SkIRect* inputRect) const {
174 SkRect rect = kReverse_MapDirection == dir ? fSrcRect : fDstRect;
175 ctm.mapRect(&rect);
176 return rect.roundOut();
177 }
178
onFilterBounds(const SkIRect & src,const SkMatrix &,MapDirection,const SkIRect * inputRect) const179 SkIRect SkTileImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix&,
180 MapDirection, const SkIRect* inputRect) const {
181 // Don't recurse into inputs.
182 return src;
183 }
184
computeFastBounds(const SkRect & src) const185 SkRect SkTileImageFilter::computeFastBounds(const SkRect& src) const {
186 return fDstRect;
187 }
188