1 /*
2 * Copyright 2016 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/SkBitmap.h"
9 #include "include/core/SkCanvas.h"
10 #include "include/effects/SkImageFilters.h"
11 #include "include/private/SkNx.h"
12 #include "src/core/SkImageFilter_Base.h"
13 #include "src/core/SkReadBuffer.h"
14 #include "src/core/SkSpecialImage.h"
15 #include "src/core/SkSpecialSurface.h"
16 #include "src/core/SkWriteBuffer.h"
17
18 #if SK_SUPPORT_GPU
19 #include "include/gpu/GrRecordingContext.h"
20 #include "src/core/SkRuntimeEffectPriv.h"
21 #include "src/gpu/GrColorSpaceXform.h"
22 #include "src/gpu/GrRecordingContextPriv.h"
23 #include "src/gpu/GrTextureProxy.h"
24 #include "src/gpu/SkGr.h"
25 #include "src/gpu/SurfaceFillContext.h"
26 #include "src/gpu/effects/GrSkSLFP.h"
27 #include "src/gpu/effects/GrTextureEffect.h"
28 #endif
29
30 namespace {
31
32 class SkArithmeticImageFilter final : public SkImageFilter_Base {
33 public:
SkArithmeticImageFilter(float k1,float k2,float k3,float k4,bool enforcePMColor,sk_sp<SkImageFilter> inputs[2],const SkRect * cropRect)34 SkArithmeticImageFilter(float k1, float k2, float k3, float k4, bool enforcePMColor,
35 sk_sp<SkImageFilter> inputs[2], const SkRect* cropRect)
36 : INHERITED(inputs, 2, cropRect)
37 , fK{k1, k2, k3, k4}
38 , fEnforcePMColor(enforcePMColor) {}
39
40 protected:
41 sk_sp<SkSpecialImage> onFilterImage(const Context&, SkIPoint* offset) const override;
42
43 SkIRect onFilterBounds(const SkIRect&, const SkMatrix& ctm,
44 MapDirection, const SkIRect* inputRect) const override;
45
46 #if SK_SUPPORT_GPU
47 sk_sp<SkSpecialImage> filterImageGPU(const Context& ctx,
48 sk_sp<SkSpecialImage> background,
49 const SkIPoint& backgroundOffset,
50 sk_sp<SkSpecialImage> foreground,
51 const SkIPoint& foregroundOffset,
52 const SkIRect& bounds) const;
53 #endif
54
55 void flatten(SkWriteBuffer& buffer) const override;
56
57 void drawForeground(SkCanvas* canvas, SkSpecialImage*, const SkIRect&) const;
58
59 private:
60 friend void ::SkRegisterArithmeticImageFilterFlattenable();
SK_FLATTENABLE_HOOKS(SkArithmeticImageFilter)61 SK_FLATTENABLE_HOOKS(SkArithmeticImageFilter)
62
63 bool onAffectsTransparentBlack() const override { return !SkScalarNearlyZero(fK[3]); }
64
65 SkV4 fK;
66 bool fEnforcePMColor;
67
68 using INHERITED = SkImageFilter_Base;
69 };
70
71 }; // end namespace
72
Arithmetic(SkScalar k1,SkScalar k2,SkScalar k3,SkScalar k4,bool enforcePMColor,sk_sp<SkImageFilter> background,sk_sp<SkImageFilter> foreground,const CropRect & cropRect)73 sk_sp<SkImageFilter> SkImageFilters::Arithmetic(
74 SkScalar k1, SkScalar k2, SkScalar k3, SkScalar k4, bool enforcePMColor,
75 sk_sp<SkImageFilter> background, sk_sp<SkImageFilter> foreground,
76 const CropRect& cropRect) {
77 if (!SkScalarIsFinite(k1) || !SkScalarIsFinite(k2) || !SkScalarIsFinite(k3) ||
78 !SkScalarIsFinite(k4)) {
79 return nullptr;
80 }
81
82 // are we nearly some other "std" mode?
83 int mode = -1; // illegal mode
84 if (SkScalarNearlyZero(k1) && SkScalarNearlyEqual(k2, SK_Scalar1) && SkScalarNearlyZero(k3) &&
85 SkScalarNearlyZero(k4)) {
86 mode = (int)SkBlendMode::kSrc;
87 } else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) &&
88 SkScalarNearlyEqual(k3, SK_Scalar1) && SkScalarNearlyZero(k4)) {
89 mode = (int)SkBlendMode::kDst;
90 } else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) && SkScalarNearlyZero(k3) &&
91 SkScalarNearlyZero(k4)) {
92 mode = (int)SkBlendMode::kClear;
93 }
94 if (mode >= 0) {
95 return SkImageFilters::Blend((SkBlendMode)mode, std::move(background),
96 std::move(foreground), cropRect);
97 }
98
99 sk_sp<SkImageFilter> inputs[2] = {std::move(background), std::move(foreground)};
100 return sk_sp<SkImageFilter>(
101 new SkArithmeticImageFilter(k1, k2, k3, k4, enforcePMColor, inputs, cropRect));
102 }
103
SkRegisterArithmeticImageFilterFlattenable()104 void SkRegisterArithmeticImageFilterFlattenable() {
105 SK_REGISTER_FLATTENABLE(SkArithmeticImageFilter);
106 SkFlattenable::Register("ArithmeticImageFilterImpl", SkArithmeticImageFilter::CreateProc);
107 }
108
CreateProc(SkReadBuffer & buffer)109 sk_sp<SkFlattenable> SkArithmeticImageFilter::CreateProc(SkReadBuffer& buffer) {
110 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
111 float k[4];
112 for (int i = 0; i < 4; ++i) {
113 k[i] = buffer.readScalar();
114 }
115 const bool enforcePMColor = buffer.readBool();
116 if (!buffer.isValid()) {
117 return nullptr;
118 }
119 return SkImageFilters::Arithmetic(k[0], k[1], k[2], k[3], enforcePMColor, common.getInput(0),
120 common.getInput(1), common.cropRect());
121 }
122
flatten(SkWriteBuffer & buffer) const123 void SkArithmeticImageFilter::flatten(SkWriteBuffer& buffer) const {
124 this->INHERITED::flatten(buffer);
125 for (int i = 0; i < 4; ++i) {
126 buffer.writeScalar(fK[i]);
127 }
128 buffer.writeBool(fEnforcePMColor);
129 }
130
131 ///////////////////////////////////////////////////////////////////////////////////////////////////
132
pin(float min,const Sk4f & val,float max)133 static Sk4f pin(float min, const Sk4f& val, float max) {
134 return Sk4f::Max(min, Sk4f::Min(val, max));
135 }
136
137 template <bool EnforcePMColor>
arith_span(const SkV4 & k,SkPMColor dst[],const SkPMColor src[],int count)138 void arith_span(const SkV4& k, SkPMColor dst[], const SkPMColor src[], int count) {
139 const Sk4f k1 = k[0] * (1/255.0f),
140 k2 = k[1],
141 k3 = k[2],
142 k4 = k[3] * 255.0f + 0.5f;
143
144 for (int i = 0; i < count; i++) {
145 Sk4f s = SkNx_cast<float>(Sk4b::Load(src+i)),
146 d = SkNx_cast<float>(Sk4b::Load(dst+i)),
147 r = pin(0, k1*s*d + k2*s + k3*d + k4, 255);
148 if (EnforcePMColor) {
149 Sk4f a = SkNx_shuffle<3,3,3,3>(r);
150 r = Sk4f::Min(a, r);
151 }
152 SkNx_cast<uint8_t>(r).store(dst+i);
153 }
154 }
155
156 // apply mode to src==transparent (0)
arith_transparent(const SkV4 & k,SkPMColor dst[],int count)157 template<bool EnforcePMColor> void arith_transparent(const SkV4& k, SkPMColor dst[], int count) {
158 const Sk4f k3 = k[2],
159 k4 = k[3] * 255.0f + 0.5f;
160
161 for (int i = 0; i < count; i++) {
162 Sk4f d = SkNx_cast<float>(Sk4b::Load(dst+i)),
163 r = pin(0, k3*d + k4, 255);
164 if (EnforcePMColor) {
165 Sk4f a = SkNx_shuffle<3,3,3,3>(r);
166 r = Sk4f::Min(a, r);
167 }
168 SkNx_cast<uint8_t>(r).store(dst+i);
169 }
170 }
171
intersect(SkPixmap * dst,SkPixmap * src,int srcDx,int srcDy)172 static bool intersect(SkPixmap* dst, SkPixmap* src, int srcDx, int srcDy) {
173 SkIRect dstR = SkIRect::MakeWH(dst->width(), dst->height());
174 SkIRect srcR = SkIRect::MakeXYWH(srcDx, srcDy, src->width(), src->height());
175 SkIRect sect;
176 if (!sect.intersect(dstR, srcR)) {
177 return false;
178 }
179 *dst = SkPixmap(dst->info().makeDimensions(sect.size()),
180 dst->addr(sect.fLeft, sect.fTop),
181 dst->rowBytes());
182 *src = SkPixmap(src->info().makeDimensions(sect.size()),
183 src->addr(std::max(0, -srcDx), std::max(0, -srcDy)),
184 src->rowBytes());
185 return true;
186 }
187
onFilterImage(const Context & ctx,SkIPoint * offset) const188 sk_sp<SkSpecialImage> SkArithmeticImageFilter::onFilterImage(const Context& ctx,
189 SkIPoint* offset) const {
190 SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
191 sk_sp<SkSpecialImage> background(this->filterInput(0, ctx, &backgroundOffset));
192
193 SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
194 sk_sp<SkSpecialImage> foreground(this->filterInput(1, ctx, &foregroundOffset));
195
196 SkIRect foregroundBounds = SkIRect::MakeEmpty();
197 if (foreground) {
198 foregroundBounds = SkIRect::MakeXYWH(foregroundOffset.x(), foregroundOffset.y(),
199 foreground->width(), foreground->height());
200 }
201
202 SkIRect srcBounds = SkIRect::MakeEmpty();
203 if (background) {
204 srcBounds = SkIRect::MakeXYWH(backgroundOffset.x(), backgroundOffset.y(),
205 background->width(), background->height());
206 }
207
208 srcBounds.join(foregroundBounds);
209 if (srcBounds.isEmpty()) {
210 return nullptr;
211 }
212
213 SkIRect bounds;
214 if (!this->applyCropRect(ctx, srcBounds, &bounds)) {
215 return nullptr;
216 }
217
218 offset->fX = bounds.left();
219 offset->fY = bounds.top();
220
221 #if SK_SUPPORT_GPU
222 if (ctx.gpuBacked()) {
223 return this->filterImageGPU(ctx, background, backgroundOffset, foreground,
224 foregroundOffset, bounds);
225 }
226 #endif
227
228 sk_sp<SkSpecialSurface> surf(ctx.makeSurface(bounds.size()));
229 if (!surf) {
230 return nullptr;
231 }
232
233 SkCanvas* canvas = surf->getCanvas();
234 SkASSERT(canvas);
235
236 canvas->clear(0x0); // can't count on background to fully clear the background
237 canvas->translate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
238
239 if (background) {
240 SkPaint paint;
241 paint.setBlendMode(SkBlendMode::kSrc);
242 background->draw(canvas, SkIntToScalar(backgroundOffset.fX),
243 SkIntToScalar(backgroundOffset.fY), SkSamplingOptions(), &paint);
244 }
245
246 this->drawForeground(canvas, foreground.get(), foregroundBounds);
247
248 return surf->makeImageSnapshot();
249 }
250
onFilterBounds(const SkIRect & src,const SkMatrix & ctm,MapDirection dir,const SkIRect * inputRect) const251 SkIRect SkArithmeticImageFilter::onFilterBounds(const SkIRect& src,
252 const SkMatrix& ctm,
253 MapDirection dir,
254 const SkIRect* inputRect) const {
255 if (kReverse_MapDirection == dir) {
256 return INHERITED::onFilterBounds(src, ctm, dir, inputRect);
257 }
258
259 SkASSERT(2 == this->countInputs());
260
261 // result(i1,i2) = k1*i1*i2 + k2*i1 + k3*i2 + k4
262 // Note that background (getInput(0)) is i2, and foreground (getInput(1)) is i1.
263 auto i2 = this->getInput(0) ? this->getInput(0)->filterBounds(src, ctm, dir, nullptr) : src;
264 auto i1 = this->getInput(1) ? this->getInput(1)->filterBounds(src, ctm, dir, nullptr) : src;
265
266 // Arithmetic with non-zero k4 may influence the complete filter primitive
267 // region. [k4 > 0 => result(0,0) = k4 => result(i1,i2) >= k4]
268 if (!SkScalarNearlyZero(fK[3])) {
269 i1.join(i2);
270 return i1;
271 }
272
273 // If both K2 or K3 are non-zero, both i1 and i2 appear.
274 if (!SkScalarNearlyZero(fK[1]) && !SkScalarNearlyZero(fK[2])) {
275 i1.join(i2);
276 return i1;
277 }
278
279 // If k2 is non-zero, output can be produced whenever i1 is non-transparent.
280 // [k3 = k4 = 0 => result(i1,i2) = k1*i1*i2 + k2*i1 = (k1*i2 + k2)*i1]
281 if (!SkScalarNearlyZero(fK[1])) {
282 return i1;
283 }
284
285 // If k3 is non-zero, output can be produced whenever i2 is non-transparent.
286 // [k2 = k4 = 0 => result(i1,i2) = k1*i1*i2 + k3*i2 = (k1*i1 + k3)*i2]
287 if (!SkScalarNearlyZero(fK[2])) {
288 return i2;
289 }
290
291 // If just k1 is non-zero, output will only be produce where both inputs
292 // are non-transparent. Use intersection.
293 // [k1 > 0 and k2 = k3 = k4 = 0 => result(i1,i2) = k1*i1*i2]
294 if (!SkScalarNearlyZero(fK[0])) {
295 if (!i1.intersect(i2)) {
296 return SkIRect::MakeEmpty();
297 }
298 return i1;
299 }
300
301 // [k1 = k2 = k3 = k4 = 0 => result(i1,i2) = 0]
302 return SkIRect::MakeEmpty();
303 }
304
305 #if SK_SUPPORT_GPU
306
make_arithmetic_fp(std::unique_ptr<GrFragmentProcessor> srcFP,std::unique_ptr<GrFragmentProcessor> dstFP,const SkV4 & k,bool enforcePMColor)307 std::unique_ptr<GrFragmentProcessor> make_arithmetic_fp(
308 std::unique_ptr<GrFragmentProcessor> srcFP,
309 std::unique_ptr<GrFragmentProcessor> dstFP,
310 const SkV4& k,
311 bool enforcePMColor) {
312 static auto effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader, R"(
313 uniform shader srcFP;
314 uniform shader dstFP;
315 uniform half4 k;
316 uniform half pmClamp;
317 half4 main(float2 xy) {
318 half4 src = srcFP.eval(xy);
319 half4 dst = dstFP.eval(xy);
320 half4 color = saturate(k.x * src * dst +
321 k.y * src +
322 k.z * dst +
323 k.w);
324 color.rgb = min(color.rgb, max(color.a, pmClamp));
325 return color;
326 }
327 )");
328 return GrSkSLFP::Make(effect, "arithmetic_fp", /*inputFP=*/nullptr, GrSkSLFP::OptFlags::kNone,
329 "srcFP", std::move(srcFP),
330 "dstFP", std::move(dstFP),
331 "k", k,
332 "pmClamp", enforcePMColor ? 0.0f : 1.0f);
333 }
334
filterImageGPU(const Context & ctx,sk_sp<SkSpecialImage> background,const SkIPoint & backgroundOffset,sk_sp<SkSpecialImage> foreground,const SkIPoint & foregroundOffset,const SkIRect & bounds) const335 sk_sp<SkSpecialImage> SkArithmeticImageFilter::filterImageGPU(
336 const Context& ctx,
337 sk_sp<SkSpecialImage> background,
338 const SkIPoint& backgroundOffset,
339 sk_sp<SkSpecialImage> foreground,
340 const SkIPoint& foregroundOffset,
341 const SkIRect& bounds) const {
342 SkASSERT(ctx.gpuBacked());
343
344 auto rContext = ctx.getContext();
345
346 GrSurfaceProxyView backgroundView, foregroundView;
347
348 GrProtected isProtected = GrProtected::kNo;
349 if (background) {
350 backgroundView = background->view(rContext);
351 SkASSERT(backgroundView.proxy());
352 isProtected = backgroundView.proxy()->isProtected();
353 }
354
355 if (foreground) {
356 foregroundView = foreground->view(rContext);
357 SkASSERT(foregroundView.proxy());
358 isProtected = foregroundView.proxy()->isProtected();
359 }
360
361 std::unique_ptr<GrFragmentProcessor> fp;
362 const auto& caps = *ctx.getContext()->priv().caps();
363 GrSamplerState sampler(GrSamplerState::WrapMode::kClampToBorder,
364 GrSamplerState::Filter::kNearest);
365
366 if (background) {
367 SkRect bgSubset = SkRect::Make(background->subset());
368 SkMatrix backgroundMatrix = SkMatrix::Translate(
369 SkIntToScalar(bgSubset.left() - backgroundOffset.fX),
370 SkIntToScalar(bgSubset.top() - backgroundOffset.fY));
371 fp = GrTextureEffect::MakeSubset(std::move(backgroundView),
372 background->alphaType(),
373 backgroundMatrix,
374 sampler,
375 bgSubset,
376 caps);
377 fp = GrColorSpaceXformEffect::Make(std::move(fp),
378 background->getColorSpace(),
379 background->alphaType(),
380 ctx.colorSpace(),
381 kPremul_SkAlphaType);
382 } else {
383 fp = GrFragmentProcessor::MakeColor(SK_PMColor4fTRANSPARENT);
384 }
385
386 if (foreground) {
387 SkRect fgSubset = SkRect::Make(foreground->subset());
388 SkMatrix foregroundMatrix = SkMatrix::Translate(
389 SkIntToScalar(fgSubset.left() - foregroundOffset.fX),
390 SkIntToScalar(fgSubset.top() - foregroundOffset.fY));
391 auto fgFP = GrTextureEffect::MakeSubset(std::move(foregroundView),
392 foreground->alphaType(),
393 foregroundMatrix,
394 sampler,
395 fgSubset,
396 caps);
397 fgFP = GrColorSpaceXformEffect::Make(std::move(fgFP),
398 foreground->getColorSpace(),
399 foreground->alphaType(),
400 ctx.colorSpace(),
401 kPremul_SkAlphaType);
402 fp = make_arithmetic_fp(std::move(fgFP), std::move(fp), fK, fEnforcePMColor);
403 }
404
405 GrImageInfo info(ctx.grColorType(), kPremul_SkAlphaType, ctx.refColorSpace(), bounds.size());
406 auto sfc = rContext->priv().makeSFC(info,
407 SkBackingFit::kApprox,
408 1,
409 GrMipmapped::kNo,
410 isProtected,
411 kBottomLeft_GrSurfaceOrigin);
412 if (!sfc) {
413 return nullptr;
414 }
415
416 sfc->fillRectToRectWithFP(bounds, SkIRect::MakeSize(bounds.size()), std::move(fp));
417
418 return SkSpecialImage::MakeDeferredFromGpu(rContext,
419 SkIRect::MakeWH(bounds.width(), bounds.height()),
420 kNeedNewImageUniqueID_SpecialImage,
421 sfc->readSurfaceView(),
422 sfc->colorInfo().colorType(),
423 sfc->colorInfo().refColorSpace(),
424 ctx.surfaceProps());
425 }
426 #endif
427
drawForeground(SkCanvas * canvas,SkSpecialImage * img,const SkIRect & fgBounds) const428 void SkArithmeticImageFilter::drawForeground(SkCanvas* canvas, SkSpecialImage* img,
429 const SkIRect& fgBounds) const {
430 SkPixmap dst;
431 if (!canvas->peekPixels(&dst)) {
432 return;
433 }
434
435 const SkMatrix& ctm = canvas->getTotalMatrix();
436 SkASSERT(ctm.getType() <= SkMatrix::kTranslate_Mask);
437 const int dx = SkScalarRoundToInt(ctm.getTranslateX());
438 const int dy = SkScalarRoundToInt(ctm.getTranslateY());
439 // be sure to perform this offset using SkIRect, since it saturates to avoid overflows
440 const SkIRect fgoffset = fgBounds.makeOffset(dx, dy);
441
442 if (img) {
443 SkBitmap srcBM;
444 SkPixmap src;
445 if (!img->getROPixels(&srcBM)) {
446 return;
447 }
448 if (!srcBM.peekPixels(&src)) {
449 return;
450 }
451
452 auto proc = fEnforcePMColor ? arith_span<true> : arith_span<false>;
453 SkPixmap tmpDst = dst;
454 if (intersect(&tmpDst, &src, fgoffset.fLeft, fgoffset.fTop)) {
455 for (int y = 0; y < tmpDst.height(); ++y) {
456 proc(fK, tmpDst.writable_addr32(0, y), src.addr32(0, y), tmpDst.width());
457 }
458 }
459 }
460
461 // Now apply the mode with transparent-color to the outside of the fg image
462 SkRegion outside(SkIRect::MakeWH(dst.width(), dst.height()));
463 outside.op(fgoffset, SkRegion::kDifference_Op);
464 auto proc = fEnforcePMColor ? arith_transparent<true> : arith_transparent<false>;
465 for (SkRegion::Iterator iter(outside); !iter.done(); iter.next()) {
466 const SkIRect r = iter.rect();
467 for (int y = r.fTop; y < r.fBottom; ++y) {
468 proc(fK, dst.writable_addr32(r.fLeft, y), r.width());
469 }
470 }
471 }
472