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 "SkArithmeticImageFilter.h"
9 #include "SkCanvas.h"
10 #include "SkColorSpaceXformer.h"
11 #include "SkNx.h"
12 #include "SkReadBuffer.h"
13 #include "SkSpecialImage.h"
14 #include "SkSpecialSurface.h"
15 #include "SkWriteBuffer.h"
16 #include "SkXfermodeImageFilter.h"
17 #if SK_SUPPORT_GPU
18 #include "GrClip.h"
19 #include "GrContext.h"
20 #include "GrRenderTargetContext.h"
21 #include "GrTextureProxy.h"
22 #include "SkGr.h"
23 #include "effects/GrConstColorProcessor.h"
24 #include "effects/GrTextureDomain.h"
25 #include "glsl/GrGLSLFragmentProcessor.h"
26 #include "glsl/GrGLSLFragmentShaderBuilder.h"
27 #include "glsl/GrGLSLProgramDataManager.h"
28 #include "glsl/GrGLSLUniformHandler.h"
29 #endif
30
31 class ArithmeticImageFilterImpl : public SkImageFilter {
32 public:
ArithmeticImageFilterImpl(float k1,float k2,float k3,float k4,bool enforcePMColor,sk_sp<SkImageFilter> inputs[2],const CropRect * cropRect)33 ArithmeticImageFilterImpl(float k1, float k2, float k3, float k4, bool enforcePMColor,
34 sk_sp<SkImageFilter> inputs[2], const CropRect* cropRect)
35 : INHERITED(inputs, 2, cropRect), fK{k1, k2, k3, k4}, fEnforcePMColor(enforcePMColor) {}
36
37 SK_TO_STRING_OVERRIDE()
38 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(ArithmeticImageFilterImpl)
39
40 protected:
41 sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
42 SkIPoint* offset) const override;
43
44 #if SK_SUPPORT_GPU
45 sk_sp<SkSpecialImage> filterImageGPU(SkSpecialImage* source,
46 sk_sp<SkSpecialImage> background,
47 const SkIPoint& backgroundOffset,
48 sk_sp<SkSpecialImage> foreground,
49 const SkIPoint& foregroundOffset,
50 const SkIRect& bounds,
51 const OutputProperties& outputProperties) const;
52 #endif
53
flatten(SkWriteBuffer & buffer) const54 void flatten(SkWriteBuffer& buffer) const override {
55 this->INHERITED::flatten(buffer);
56 for (int i = 0; i < 4; ++i) {
57 buffer.writeScalar(fK[i]);
58 }
59 buffer.writeBool(fEnforcePMColor);
60 }
61
62 void drawForeground(SkCanvas* canvas, SkSpecialImage*, const SkIRect&) const;
63
64 sk_sp<SkImageFilter> onMakeColorSpace(SkColorSpaceXformer*) const override;
65
66 private:
67 const float fK[4];
68 const bool fEnforcePMColor;
69
70 friend class ::SkArithmeticImageFilter;
71
72 typedef SkImageFilter INHERITED;
73 };
74
CreateProc(SkReadBuffer & buffer)75 sk_sp<SkFlattenable> ArithmeticImageFilterImpl::CreateProc(SkReadBuffer& buffer) {
76 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
77 float k[4];
78 for (int i = 0; i < 4; ++i) {
79 k[i] = buffer.readScalar();
80 }
81 const bool enforcePMColor = buffer.readBool();
82 return SkArithmeticImageFilter::Make(k[0], k[1], k[2], k[3], enforcePMColor, common.getInput(0),
83 common.getInput(1), &common.cropRect());
84 }
85
pin(float min,const Sk4f & val,float max)86 static Sk4f pin(float min, const Sk4f& val, float max) {
87 return Sk4f::Max(min, Sk4f::Min(val, max));
88 }
89
90 template <bool EnforcePMColor>
arith_span(const float k[],SkPMColor dst[],const SkPMColor src[],int count)91 void arith_span(const float k[], SkPMColor dst[], const SkPMColor src[], int count) {
92 const Sk4f k1 = k[0] * (1/255.0f),
93 k2 = k[1],
94 k3 = k[2],
95 k4 = k[3] * 255.0f + 0.5f;
96
97 for (int i = 0; i < count; i++) {
98 Sk4f s = SkNx_cast<float>(Sk4b::Load(src+i)),
99 d = SkNx_cast<float>(Sk4b::Load(dst+i)),
100 r = pin(0, k1*s*d + k2*s + k3*d + k4, 255);
101 if (EnforcePMColor) {
102 Sk4f a = SkNx_shuffle<3,3,3,3>(r);
103 r = Sk4f::Min(a, r);
104 }
105 SkNx_cast<uint8_t>(r).store(dst+i);
106 }
107 }
108
109 // apply mode to src==transparent (0)
arith_transparent(const float k[],SkPMColor dst[],int count)110 template<bool EnforcePMColor> void arith_transparent(const float k[], SkPMColor dst[], int count) {
111 const Sk4f k3 = k[2],
112 k4 = k[3] * 255.0f + 0.5f;
113
114 for (int i = 0; i < count; i++) {
115 Sk4f d = SkNx_cast<float>(Sk4b::Load(dst+i)),
116 r = pin(0, k3*d + k4, 255);
117 if (EnforcePMColor) {
118 Sk4f a = SkNx_shuffle<3,3,3,3>(r);
119 r = Sk4f::Min(a, r);
120 }
121 SkNx_cast<uint8_t>(r).store(dst+i);
122 }
123 }
124
intersect(SkPixmap * dst,SkPixmap * src,int srcDx,int srcDy)125 static bool intersect(SkPixmap* dst, SkPixmap* src, int srcDx, int srcDy) {
126 SkIRect dstR = SkIRect::MakeWH(dst->width(), dst->height());
127 SkIRect srcR = SkIRect::MakeXYWH(srcDx, srcDy, src->width(), src->height());
128 SkIRect sect;
129 if (!sect.intersect(dstR, srcR)) {
130 return false;
131 }
132 *dst = SkPixmap(dst->info().makeWH(sect.width(), sect.height()),
133 dst->addr(sect.fLeft, sect.fTop),
134 dst->rowBytes());
135 *src = SkPixmap(src->info().makeWH(sect.width(), sect.height()),
136 src->addr(SkTMax(0, -srcDx), SkTMax(0, -srcDy)),
137 src->rowBytes());
138 return true;
139 }
140
onFilterImage(SkSpecialImage * source,const Context & ctx,SkIPoint * offset) const141 sk_sp<SkSpecialImage> ArithmeticImageFilterImpl::onFilterImage(SkSpecialImage* source,
142 const Context& ctx,
143 SkIPoint* offset) const {
144 SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
145 sk_sp<SkSpecialImage> background(this->filterInput(0, source, ctx, &backgroundOffset));
146
147 SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
148 sk_sp<SkSpecialImage> foreground(this->filterInput(1, source, ctx, &foregroundOffset));
149
150 SkIRect foregroundBounds = SkIRect::EmptyIRect();
151 if (foreground) {
152 foregroundBounds = SkIRect::MakeXYWH(foregroundOffset.x(), foregroundOffset.y(),
153 foreground->width(), foreground->height());
154 }
155
156 SkIRect srcBounds = SkIRect::EmptyIRect();
157 if (background) {
158 srcBounds = SkIRect::MakeXYWH(backgroundOffset.x(), backgroundOffset.y(),
159 background->width(), background->height());
160 }
161
162 srcBounds.join(foregroundBounds);
163 if (srcBounds.isEmpty()) {
164 return nullptr;
165 }
166
167 SkIRect bounds;
168 if (!this->applyCropRect(ctx, srcBounds, &bounds)) {
169 return nullptr;
170 }
171
172 offset->fX = bounds.left();
173 offset->fY = bounds.top();
174
175 #if SK_SUPPORT_GPU
176 if (source->isTextureBacked()) {
177 return this->filterImageGPU(source, background, backgroundOffset, foreground,
178 foregroundOffset, bounds, ctx.outputProperties());
179 }
180 #endif
181
182 sk_sp<SkSpecialSurface> surf(source->makeSurface(ctx.outputProperties(), bounds.size()));
183 if (!surf) {
184 return nullptr;
185 }
186
187 SkCanvas* canvas = surf->getCanvas();
188 SkASSERT(canvas);
189
190 canvas->clear(0x0); // can't count on background to fully clear the background
191 canvas->translate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
192
193 if (background) {
194 SkPaint paint;
195 paint.setBlendMode(SkBlendMode::kSrc);
196 background->draw(canvas, SkIntToScalar(backgroundOffset.fX),
197 SkIntToScalar(backgroundOffset.fY), &paint);
198 }
199
200 this->drawForeground(canvas, foreground.get(), foregroundBounds);
201
202 return surf->makeImageSnapshot();
203 }
204
205 #if SK_SUPPORT_GPU
206
207 namespace {
208 class ArithmeticFP : public GrFragmentProcessor {
209 public:
Make(float k1,float k2,float k3,float k4,bool enforcePMColor,sk_sp<GrFragmentProcessor> dst)210 static sk_sp<GrFragmentProcessor> Make(float k1, float k2, float k3, float k4,
211 bool enforcePMColor, sk_sp<GrFragmentProcessor> dst) {
212 return sk_sp<GrFragmentProcessor>(
213 new ArithmeticFP(k1, k2, k3, k4, enforcePMColor, std::move(dst)));
214 }
215
~ArithmeticFP()216 ~ArithmeticFP() override {}
217
name() const218 const char* name() const override { return "Arithmetic"; }
219
dumpInfo() const220 SkString dumpInfo() const override {
221 SkString str;
222 str.appendf("K1: %.2f K2: %.2f K3: %.2f K4: %.2f", fK1, fK2, fK3, fK4);
223 return str;
224 }
225
k1() const226 float k1() const { return fK1; }
k2() const227 float k2() const { return fK2; }
k3() const228 float k3() const { return fK3; }
k4() const229 float k4() const { return fK4; }
enforcePMColor() const230 bool enforcePMColor() const { return fEnforcePMColor; }
231
232 private:
onCreateGLSLInstance() const233 GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
234 class GLSLFP : public GrGLSLFragmentProcessor {
235 public:
236 void emitCode(EmitArgs& args) override {
237 const ArithmeticFP& arith = args.fFp.cast<ArithmeticFP>();
238
239 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
240 SkString dstColor("dstColor");
241 this->emitChild(0, &dstColor, args);
242
243 fKUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec4f_GrSLType,
244 kDefault_GrSLPrecision, "k");
245 const char* kUni = args.fUniformHandler->getUniformCStr(fKUni);
246
247 // We don't try to optimize for this case at all
248 if (!args.fInputColor) {
249 fragBuilder->codeAppend("const vec4 src = vec4(1);");
250 } else {
251 fragBuilder->codeAppendf("vec4 src = %s;", args.fInputColor);
252 }
253
254 fragBuilder->codeAppendf("vec4 dst = %s;", dstColor.c_str());
255 fragBuilder->codeAppendf("%s = %s.x * src * dst + %s.y * src + %s.z * dst + %s.w;",
256 args.fOutputColor, kUni, kUni, kUni, kUni);
257 fragBuilder->codeAppendf("%s = clamp(%s, 0.0, 1.0);\n", args.fOutputColor,
258 args.fOutputColor);
259 if (arith.fEnforcePMColor) {
260 fragBuilder->codeAppendf("%s.rgb = min(%s.rgb, %s.a);", args.fOutputColor,
261 args.fOutputColor, args.fOutputColor);
262 }
263 }
264
265 protected:
266 void onSetData(const GrGLSLProgramDataManager& pdman,
267 const GrFragmentProcessor& proc) override {
268 const ArithmeticFP& arith = proc.cast<ArithmeticFP>();
269 pdman.set4f(fKUni, arith.k1(), arith.k2(), arith.k3(), arith.k4());
270 }
271
272 private:
273 GrGLSLProgramDataManager::UniformHandle fKUni;
274 };
275 return new GLSLFP;
276 }
277
onGetGLSLProcessorKey(const GrShaderCaps & caps,GrProcessorKeyBuilder * b) const278 void onGetGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {
279 b->add32(fEnforcePMColor ? 1 : 0);
280 }
281
onIsEqual(const GrFragmentProcessor & fpBase) const282 bool onIsEqual(const GrFragmentProcessor& fpBase) const override {
283 const ArithmeticFP& fp = fpBase.cast<ArithmeticFP>();
284 return fK1 == fp.fK1 && fK2 == fp.fK2 && fK3 == fp.fK3 && fK4 == fp.fK4 &&
285 fEnforcePMColor == fp.fEnforcePMColor;
286 }
287
288 // This could implement the const input -> const output optimization but it's unlikely to help.
ArithmeticFP(float k1,float k2,float k3,float k4,bool enforcePMColor,sk_sp<GrFragmentProcessor> dst)289 ArithmeticFP(float k1, float k2, float k3, float k4, bool enforcePMColor,
290 sk_sp<GrFragmentProcessor> dst)
291 : INHERITED(kNone_OptimizationFlags)
292 , fK1(k1)
293 , fK2(k2)
294 , fK3(k3)
295 , fK4(k4)
296 , fEnforcePMColor(enforcePMColor) {
297 this->initClassID<ArithmeticFP>();
298 SkASSERT(dst);
299 SkDEBUGCODE(int dstIndex =) this->registerChildProcessor(std::move(dst));
300 SkASSERT(0 == dstIndex);
301 }
302
303 float fK1, fK2, fK3, fK4;
304 bool fEnforcePMColor;
305
306 GR_DECLARE_FRAGMENT_PROCESSOR_TEST
307 typedef GrFragmentProcessor INHERITED;
308 };
309 }
310
311 #if GR_TEST_UTILS
TestCreate(GrProcessorTestData * d)312 sk_sp<GrFragmentProcessor> ArithmeticFP::TestCreate(GrProcessorTestData* d) {
313 float k1 = d->fRandom->nextF();
314 float k2 = d->fRandom->nextF();
315 float k3 = d->fRandom->nextF();
316 float k4 = d->fRandom->nextF();
317 bool enforcePMColor = d->fRandom->nextBool();
318
319 sk_sp<GrFragmentProcessor> dst(GrProcessorUnitTest::MakeChildFP(d));
320 return ArithmeticFP::Make(k1, k2, k3, k4, enforcePMColor, std::move(dst));
321 }
322 #endif
323
324 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ArithmeticFP);
325
filterImageGPU(SkSpecialImage * source,sk_sp<SkSpecialImage> background,const SkIPoint & backgroundOffset,sk_sp<SkSpecialImage> foreground,const SkIPoint & foregroundOffset,const SkIRect & bounds,const OutputProperties & outputProperties) const326 sk_sp<SkSpecialImage> ArithmeticImageFilterImpl::filterImageGPU(
327 SkSpecialImage* source,
328 sk_sp<SkSpecialImage> background,
329 const SkIPoint& backgroundOffset,
330 sk_sp<SkSpecialImage> foreground,
331 const SkIPoint& foregroundOffset,
332 const SkIRect& bounds,
333 const OutputProperties& outputProperties) const {
334 SkASSERT(source->isTextureBacked());
335
336 GrContext* context = source->getContext();
337
338 sk_sp<GrTextureProxy> backgroundProxy, foregroundProxy;
339
340 if (background) {
341 backgroundProxy = background->asTextureProxyRef(context);
342 }
343
344 if (foreground) {
345 foregroundProxy = foreground->asTextureProxyRef(context);
346 }
347
348 GrPaint paint;
349 sk_sp<GrFragmentProcessor> bgFP;
350
351 if (backgroundProxy) {
352 SkMatrix backgroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX),
353 -SkIntToScalar(backgroundOffset.fY));
354 sk_sp<GrColorSpaceXform> bgXform =
355 GrColorSpaceXform::Make(background->getColorSpace(), outputProperties.colorSpace());
356 bgFP = GrTextureDomainEffect::Make(
357 std::move(backgroundProxy), std::move(bgXform),
358 backgroundMatrix, GrTextureDomain::MakeTexelDomain(background->subset()),
359 GrTextureDomain::kDecal_Mode, GrSamplerParams::kNone_FilterMode);
360 } else {
361 bgFP = GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
362 GrConstColorProcessor::kIgnore_InputMode);
363 }
364
365 if (foregroundProxy) {
366 SkMatrix foregroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(foregroundOffset.fX),
367 -SkIntToScalar(foregroundOffset.fY));
368 sk_sp<GrColorSpaceXform> fgXform =
369 GrColorSpaceXform::Make(foreground->getColorSpace(), outputProperties.colorSpace());
370 sk_sp<GrFragmentProcessor> foregroundFP(GrTextureDomainEffect::Make(
371 std::move(foregroundProxy), std::move(fgXform),
372 foregroundMatrix,
373 GrTextureDomain::MakeTexelDomain(foreground->subset()),
374 GrTextureDomain::kDecal_Mode, GrSamplerParams::kNone_FilterMode));
375 paint.addColorFragmentProcessor(std::move(foregroundFP));
376
377 sk_sp<GrFragmentProcessor> xferFP =
378 ArithmeticFP::Make(fK[0], fK[1], fK[2], fK[3], fEnforcePMColor, std::move(bgFP));
379
380 // A null 'xferFP' here means kSrc_Mode was used in which case we can just proceed
381 if (xferFP) {
382 paint.addColorFragmentProcessor(std::move(xferFP));
383 }
384 } else {
385 paint.addColorFragmentProcessor(std::move(bgFP));
386 }
387
388 paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
389
390 sk_sp<GrRenderTargetContext> renderTargetContext(context->makeDeferredRenderTargetContext(
391 SkBackingFit::kApprox, bounds.width(), bounds.height(),
392 GrRenderableConfigForColorSpace(outputProperties.colorSpace()),
393 sk_ref_sp(outputProperties.colorSpace())));
394 if (!renderTargetContext) {
395 return nullptr;
396 }
397 paint.setGammaCorrect(renderTargetContext->isGammaCorrect());
398
399 SkMatrix matrix;
400 matrix.setTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
401 renderTargetContext->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, matrix,
402 SkRect::Make(bounds));
403
404 return SkSpecialImage::MakeDeferredFromGpu(context,
405 SkIRect::MakeWH(bounds.width(), bounds.height()),
406 kNeedNewImageUniqueID_SpecialImage,
407 renderTargetContext->asTextureProxyRef(),
408 renderTargetContext->refColorSpace());
409 }
410 #endif
411
drawForeground(SkCanvas * canvas,SkSpecialImage * img,const SkIRect & fgBounds) const412 void ArithmeticImageFilterImpl::drawForeground(SkCanvas* canvas, SkSpecialImage* img,
413 const SkIRect& fgBounds) const {
414 SkPixmap dst;
415 if (!canvas->peekPixels(&dst)) {
416 return;
417 }
418
419 const SkMatrix& ctm = canvas->getTotalMatrix();
420 SkASSERT(ctm.getType() <= SkMatrix::kTranslate_Mask);
421 const int dx = SkScalarRoundToInt(ctm.getTranslateX());
422 const int dy = SkScalarRoundToInt(ctm.getTranslateY());
423
424 if (img) {
425 SkBitmap srcBM;
426 SkPixmap src;
427 if (!img->getROPixels(&srcBM)) {
428 return;
429 }
430 if (!srcBM.peekPixels(&src)) {
431 return;
432 }
433
434 auto proc = fEnforcePMColor ? arith_span<true> : arith_span<false>;
435 SkPixmap tmpDst = dst;
436 if (intersect(&tmpDst, &src, fgBounds.fLeft + dx, fgBounds.fTop + dy)) {
437 for (int y = 0; y < tmpDst.height(); ++y) {
438 proc(fK, tmpDst.writable_addr32(0, y), src.addr32(0, y), tmpDst.width());
439 }
440 }
441 }
442
443 // Now apply the mode with transparent-color to the outside of the fg image
444 SkRegion outside(SkIRect::MakeWH(dst.width(), dst.height()));
445 outside.op(fgBounds.makeOffset(dx, dy), SkRegion::kDifference_Op);
446 auto proc = fEnforcePMColor ? arith_transparent<true> : arith_transparent<false>;
447 for (SkRegion::Iterator iter(outside); !iter.done(); iter.next()) {
448 const SkIRect r = iter.rect();
449 for (int y = r.fTop; y < r.fBottom; ++y) {
450 proc(fK, dst.writable_addr32(r.fLeft, y), r.width());
451 }
452 }
453 }
454
onMakeColorSpace(SkColorSpaceXformer * xformer) const455 sk_sp<SkImageFilter> ArithmeticImageFilterImpl::onMakeColorSpace(SkColorSpaceXformer* xformer)
456 const {
457 SkASSERT(2 == this->countInputs());
458 auto background = xformer->apply(this->getInput(0));
459 auto foreground = xformer->apply(this->getInput(1));
460 if (background.get() != this->getInput(0) || foreground.get() != this->getInput(1)) {
461 return SkArithmeticImageFilter::Make(fK[0], fK[1], fK[2], fK[3], fEnforcePMColor,
462 std::move(background), std::move(foreground),
463 getCropRectIfSet());
464 }
465 return this->refMe();
466 }
467
468 #ifndef SK_IGNORE_TO_STRING
toString(SkString * str) const469 void ArithmeticImageFilterImpl::toString(SkString* str) const {
470 str->appendf("SkArithmeticImageFilter: (");
471 str->appendf("K[]: (%f %f %f %f)", fK[0], fK[1], fK[2], fK[3]);
472 if (this->getInput(0)) {
473 str->appendf("foreground: (");
474 this->getInput(0)->toString(str);
475 str->appendf(")");
476 }
477 if (this->getInput(1)) {
478 str->appendf("background: (");
479 this->getInput(1)->toString(str);
480 str->appendf(")");
481 }
482 str->append(")");
483 }
484 #endif
485
Make(float k1,float k2,float k3,float k4,bool enforcePMColor,sk_sp<SkImageFilter> background,sk_sp<SkImageFilter> foreground,const SkImageFilter::CropRect * crop)486 sk_sp<SkImageFilter> SkArithmeticImageFilter::Make(float k1, float k2, float k3, float k4,
487 bool enforcePMColor,
488 sk_sp<SkImageFilter> background,
489 sk_sp<SkImageFilter> foreground,
490 const SkImageFilter::CropRect* crop) {
491 if (!SkScalarIsFinite(k1) || !SkScalarIsFinite(k2) || !SkScalarIsFinite(k3) ||
492 !SkScalarIsFinite(k4)) {
493 return nullptr;
494 }
495
496 // are we nearly some other "std" mode?
497 int mode = -1; // illegal mode
498 if (SkScalarNearlyZero(k1) && SkScalarNearlyEqual(k2, SK_Scalar1) && SkScalarNearlyZero(k3) &&
499 SkScalarNearlyZero(k4)) {
500 mode = (int)SkBlendMode::kSrc;
501 } else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) &&
502 SkScalarNearlyEqual(k3, SK_Scalar1) && SkScalarNearlyZero(k4)) {
503 mode = (int)SkBlendMode::kDst;
504 } else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) && SkScalarNearlyZero(k3) &&
505 SkScalarNearlyZero(k4)) {
506 mode = (int)SkBlendMode::kClear;
507 }
508 if (mode >= 0) {
509 return SkXfermodeImageFilter::Make((SkBlendMode)mode, std::move(background),
510 std::move(foreground), crop);
511 }
512
513 sk_sp<SkImageFilter> inputs[2] = {std::move(background), std::move(foreground)};
514 return sk_sp<SkImageFilter>(
515 new ArithmeticImageFilterImpl(k1, k2, k3, k4, enforcePMColor, inputs, crop));
516 }
517
518 ///////////////////////////////////////////////////////////////////////////////////////////////////
519
520 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkArithmeticImageFilter)
521 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(ArithmeticImageFilterImpl)
522 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
523