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 "SkImageFilterPriv.h"
12 #include "SkNx.h"
13 #include "SkReadBuffer.h"
14 #include "SkSpecialImage.h"
15 #include "SkSpecialSurface.h"
16 #include "SkWriteBuffer.h"
17 #include "SkXfermodeImageFilter.h"
18 #if SK_SUPPORT_GPU
19 #include "GrClip.h"
20 #include "GrColorSpaceXform.h"
21 #include "GrContext.h"
22 #include "GrRenderTargetContext.h"
23 #include "GrTextureProxy.h"
24 #include "SkGr.h"
25 #include "effects/GrArithmeticFP.h"
26 #include "effects/GrConstColorProcessor.h"
27 #include "effects/GrTextureDomain.h"
28 #include "glsl/GrGLSLFragmentProcessor.h"
29 #include "glsl/GrGLSLFragmentShaderBuilder.h"
30 #include "glsl/GrGLSLProgramDataManager.h"
31 #include "glsl/GrGLSLUniformHandler.h"
32 #endif
33
34 class ArithmeticImageFilterImpl : public SkImageFilter {
35 public:
ArithmeticImageFilterImpl(float k1,float k2,float k3,float k4,bool enforcePMColor,sk_sp<SkImageFilter> inputs[2],const CropRect * cropRect)36 ArithmeticImageFilterImpl(float k1, float k2, float k3, float k4, bool enforcePMColor,
37 sk_sp<SkImageFilter> inputs[2], const CropRect* cropRect)
38 : INHERITED(inputs, 2, cropRect), fK{k1, k2, k3, k4}, fEnforcePMColor(enforcePMColor) {}
39
40 SK_TO_STRING_OVERRIDE()
41 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(ArithmeticImageFilterImpl)
42
43 protected:
44 sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
45 SkIPoint* offset) const override;
46
47 SkIRect onFilterBounds(const SkIRect&, const SkMatrix&, MapDirection) const override;
48
49 #if SK_SUPPORT_GPU
50 sk_sp<SkSpecialImage> filterImageGPU(SkSpecialImage* source,
51 sk_sp<SkSpecialImage> background,
52 const SkIPoint& backgroundOffset,
53 sk_sp<SkSpecialImage> foreground,
54 const SkIPoint& foregroundOffset,
55 const SkIRect& bounds,
56 const OutputProperties& outputProperties) const;
57 #endif
58
flatten(SkWriteBuffer & buffer) const59 void flatten(SkWriteBuffer& buffer) const override {
60 this->INHERITED::flatten(buffer);
61 for (int i = 0; i < 4; ++i) {
62 buffer.writeScalar(fK[i]);
63 }
64 buffer.writeBool(fEnforcePMColor);
65 }
66
67 void drawForeground(SkCanvas* canvas, SkSpecialImage*, const SkIRect&) const;
68
69 sk_sp<SkImageFilter> onMakeColorSpace(SkColorSpaceXformer*) const override;
70
71 private:
affectsTransparentBlack() const72 bool affectsTransparentBlack() const override { return !SkScalarNearlyZero(fK[3]); }
73
74 const float fK[4];
75 const bool fEnforcePMColor;
76
77 friend class ::SkArithmeticImageFilter;
78
79 typedef SkImageFilter INHERITED;
80 };
81
CreateProc(SkReadBuffer & buffer)82 sk_sp<SkFlattenable> ArithmeticImageFilterImpl::CreateProc(SkReadBuffer& buffer) {
83 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
84 float k[4];
85 for (int i = 0; i < 4; ++i) {
86 k[i] = buffer.readScalar();
87 }
88 const bool enforcePMColor = buffer.readBool();
89 return SkArithmeticImageFilter::Make(k[0], k[1], k[2], k[3], enforcePMColor, common.getInput(0),
90 common.getInput(1), &common.cropRect());
91 }
92
pin(float min,const Sk4f & val,float max)93 static Sk4f pin(float min, const Sk4f& val, float max) {
94 return Sk4f::Max(min, Sk4f::Min(val, max));
95 }
96
97 template <bool EnforcePMColor>
arith_span(const float k[],SkPMColor dst[],const SkPMColor src[],int count)98 void arith_span(const float k[], SkPMColor dst[], const SkPMColor src[], int count) {
99 const Sk4f k1 = k[0] * (1/255.0f),
100 k2 = k[1],
101 k3 = k[2],
102 k4 = k[3] * 255.0f + 0.5f;
103
104 for (int i = 0; i < count; i++) {
105 Sk4f s = SkNx_cast<float>(Sk4b::Load(src+i)),
106 d = SkNx_cast<float>(Sk4b::Load(dst+i)),
107 r = pin(0, k1*s*d + k2*s + k3*d + k4, 255);
108 if (EnforcePMColor) {
109 Sk4f a = SkNx_shuffle<3,3,3,3>(r);
110 r = Sk4f::Min(a, r);
111 }
112 SkNx_cast<uint8_t>(r).store(dst+i);
113 }
114 }
115
116 // apply mode to src==transparent (0)
arith_transparent(const float k[],SkPMColor dst[],int count)117 template<bool EnforcePMColor> void arith_transparent(const float k[], SkPMColor dst[], int count) {
118 const Sk4f k3 = k[2],
119 k4 = k[3] * 255.0f + 0.5f;
120
121 for (int i = 0; i < count; i++) {
122 Sk4f d = SkNx_cast<float>(Sk4b::Load(dst+i)),
123 r = pin(0, k3*d + k4, 255);
124 if (EnforcePMColor) {
125 Sk4f a = SkNx_shuffle<3,3,3,3>(r);
126 r = Sk4f::Min(a, r);
127 }
128 SkNx_cast<uint8_t>(r).store(dst+i);
129 }
130 }
131
intersect(SkPixmap * dst,SkPixmap * src,int srcDx,int srcDy)132 static bool intersect(SkPixmap* dst, SkPixmap* src, int srcDx, int srcDy) {
133 SkIRect dstR = SkIRect::MakeWH(dst->width(), dst->height());
134 SkIRect srcR = SkIRect::MakeXYWH(srcDx, srcDy, src->width(), src->height());
135 SkIRect sect;
136 if (!sect.intersect(dstR, srcR)) {
137 return false;
138 }
139 *dst = SkPixmap(dst->info().makeWH(sect.width(), sect.height()),
140 dst->addr(sect.fLeft, sect.fTop),
141 dst->rowBytes());
142 *src = SkPixmap(src->info().makeWH(sect.width(), sect.height()),
143 src->addr(SkTMax(0, -srcDx), SkTMax(0, -srcDy)),
144 src->rowBytes());
145 return true;
146 }
147
onFilterImage(SkSpecialImage * source,const Context & ctx,SkIPoint * offset) const148 sk_sp<SkSpecialImage> ArithmeticImageFilterImpl::onFilterImage(SkSpecialImage* source,
149 const Context& ctx,
150 SkIPoint* offset) const {
151 SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
152 sk_sp<SkSpecialImage> background(this->filterInput(0, source, ctx, &backgroundOffset));
153
154 SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
155 sk_sp<SkSpecialImage> foreground(this->filterInput(1, source, ctx, &foregroundOffset));
156
157 SkIRect foregroundBounds = SkIRect::EmptyIRect();
158 if (foreground) {
159 foregroundBounds = SkIRect::MakeXYWH(foregroundOffset.x(), foregroundOffset.y(),
160 foreground->width(), foreground->height());
161 }
162
163 SkIRect srcBounds = SkIRect::EmptyIRect();
164 if (background) {
165 srcBounds = SkIRect::MakeXYWH(backgroundOffset.x(), backgroundOffset.y(),
166 background->width(), background->height());
167 }
168
169 srcBounds.join(foregroundBounds);
170 if (srcBounds.isEmpty()) {
171 return nullptr;
172 }
173
174 SkIRect bounds;
175 if (!this->applyCropRect(ctx, srcBounds, &bounds)) {
176 return nullptr;
177 }
178
179 offset->fX = bounds.left();
180 offset->fY = bounds.top();
181
182 #if SK_SUPPORT_GPU
183 if (source->isTextureBacked()) {
184 return this->filterImageGPU(source, background, backgroundOffset, foreground,
185 foregroundOffset, bounds, ctx.outputProperties());
186 }
187 #endif
188
189 sk_sp<SkSpecialSurface> surf(source->makeSurface(ctx.outputProperties(), bounds.size()));
190 if (!surf) {
191 return nullptr;
192 }
193
194 SkCanvas* canvas = surf->getCanvas();
195 SkASSERT(canvas);
196
197 canvas->clear(0x0); // can't count on background to fully clear the background
198 canvas->translate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
199
200 if (background) {
201 SkPaint paint;
202 paint.setBlendMode(SkBlendMode::kSrc);
203 background->draw(canvas, SkIntToScalar(backgroundOffset.fX),
204 SkIntToScalar(backgroundOffset.fY), &paint);
205 }
206
207 this->drawForeground(canvas, foreground.get(), foregroundBounds);
208
209 return surf->makeImageSnapshot();
210 }
211
onFilterBounds(const SkIRect & src,const SkMatrix & ctm,MapDirection direction) const212 SkIRect ArithmeticImageFilterImpl::onFilterBounds(const SkIRect& src,
213 const SkMatrix& ctm,
214 MapDirection direction) const {
215 if (kReverse_MapDirection == direction) {
216 return SkImageFilter::onFilterBounds(src, ctm, direction);
217 }
218
219 SkASSERT(2 == this->countInputs());
220
221 // result(i1,i2) = k1*i1*i2 + k2*i1 + k3*i2 + k4
222 // Note that background (getInput(0)) is i2, and foreground (getInput(1)) is i1.
223 auto i2 = this->getInput(0) ? this->getInput(0)->filterBounds(src, ctm, direction) : src;
224 auto i1 = this->getInput(1) ? this->getInput(1)->filterBounds(src, ctm, direction) : src;
225
226 // Arithmetic with non-zero k4 may influence the complete filter primitive
227 // region. [k4 > 0 => result(0,0) = k4 => result(i1,i2) >= k4]
228 if (!SkScalarNearlyZero(fK[3])) {
229 i1.join(i2);
230 return i1;
231 }
232
233 // If both K2 or K3 are non-zero, both i1 and i2 appear.
234 if (!SkScalarNearlyZero(fK[1]) && !SkScalarNearlyZero(fK[2])) {
235 i1.join(i2);
236 return i1;
237 }
238
239 // If k2 is non-zero, output can be produced whenever i1 is non-transparent.
240 // [k3 = k4 = 0 => result(i1,i2) = k1*i1*i2 + k2*i1 = (k1*i2 + k2)*i1]
241 if (!SkScalarNearlyZero(fK[1])) {
242 return i1;
243 }
244
245 // If k3 is non-zero, output can be produced whenever i2 is non-transparent.
246 // [k2 = k4 = 0 => result(i1,i2) = k1*i1*i2 + k3*i2 = (k1*i1 + k3)*i2]
247 if (!SkScalarNearlyZero(fK[2])) {
248 return i2;
249 }
250
251 // If just k1 is non-zero, output will only be produce where both inputs
252 // are non-transparent. Use intersection.
253 // [k1 > 0 and k2 = k3 = k4 = 0 => result(i1,i2) = k1*i1*i2]
254 if (!SkScalarNearlyZero(fK[0])) {
255 if (!i1.intersect(i2)) {
256 return SkIRect::MakeEmpty();
257 }
258 return i1;
259 }
260
261 // [k1 = k2 = k3 = k4 = 0 => result(i1,i2) = 0]
262 return SkIRect::MakeEmpty();
263 }
264
265 #if SK_SUPPORT_GPU
266
267 #if GR_TEST_UTILS
TestCreate(GrProcessorTestData * d)268 std::unique_ptr<GrFragmentProcessor> GrArithmeticFP::TestCreate(GrProcessorTestData* d) {
269 float k1 = d->fRandom->nextF();
270 float k2 = d->fRandom->nextF();
271 float k3 = d->fRandom->nextF();
272 float k4 = d->fRandom->nextF();
273 bool enforcePMColor = d->fRandom->nextBool();
274
275 std::unique_ptr<GrFragmentProcessor> dst(GrProcessorUnitTest::MakeChildFP(d));
276 return GrArithmeticFP::Make(k1, k2, k3, k4, enforcePMColor, std::move(dst));
277 }
278 #endif
279
280 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrArithmeticFP);
281
filterImageGPU(SkSpecialImage * source,sk_sp<SkSpecialImage> background,const SkIPoint & backgroundOffset,sk_sp<SkSpecialImage> foreground,const SkIPoint & foregroundOffset,const SkIRect & bounds,const OutputProperties & outputProperties) const282 sk_sp<SkSpecialImage> ArithmeticImageFilterImpl::filterImageGPU(
283 SkSpecialImage* source,
284 sk_sp<SkSpecialImage> background,
285 const SkIPoint& backgroundOffset,
286 sk_sp<SkSpecialImage> foreground,
287 const SkIPoint& foregroundOffset,
288 const SkIRect& bounds,
289 const OutputProperties& outputProperties) const {
290 SkASSERT(source->isTextureBacked());
291
292 GrContext* context = source->getContext();
293
294 sk_sp<GrTextureProxy> backgroundProxy, foregroundProxy;
295
296 if (background) {
297 backgroundProxy = background->asTextureProxyRef(context);
298 }
299
300 if (foreground) {
301 foregroundProxy = foreground->asTextureProxyRef(context);
302 }
303
304 GrPaint paint;
305 std::unique_ptr<GrFragmentProcessor> bgFP;
306
307 if (backgroundProxy) {
308 SkMatrix backgroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX),
309 -SkIntToScalar(backgroundOffset.fY));
310 GrPixelConfig bgConfig = backgroundProxy->config();
311 bgFP = GrTextureDomainEffect::Make(
312 std::move(backgroundProxy), backgroundMatrix,
313 GrTextureDomain::MakeTexelDomain(background->subset()),
314 GrTextureDomain::kDecal_Mode, GrSamplerState::Filter::kNearest);
315 bgFP = GrColorSpaceXformEffect::Make(std::move(bgFP), background->getColorSpace(),
316 bgConfig, outputProperties.colorSpace());
317 } else {
318 bgFP = GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
319 GrConstColorProcessor::InputMode::kIgnore);
320 }
321
322 if (foregroundProxy) {
323 SkMatrix foregroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(foregroundOffset.fX),
324 -SkIntToScalar(foregroundOffset.fY));
325 GrPixelConfig fgConfig = foregroundProxy->config();
326 auto foregroundFP = GrTextureDomainEffect::Make(
327 std::move(foregroundProxy), foregroundMatrix,
328 GrTextureDomain::MakeTexelDomain(foreground->subset()),
329 GrTextureDomain::kDecal_Mode, GrSamplerState::Filter::kNearest);
330 foregroundFP = GrColorSpaceXformEffect::Make(std::move(foregroundFP),
331 foreground->getColorSpace(), fgConfig,
332 outputProperties.colorSpace());
333 paint.addColorFragmentProcessor(std::move(foregroundFP));
334
335 std::unique_ptr<GrFragmentProcessor> xferFP =
336 GrArithmeticFP::Make(fK[0], fK[1], fK[2], fK[3], fEnforcePMColor, std::move(bgFP));
337
338 // A null 'xferFP' here means kSrc_Mode was used in which case we can just proceed
339 if (xferFP) {
340 paint.addColorFragmentProcessor(std::move(xferFP));
341 }
342 } else {
343 paint.addColorFragmentProcessor(std::move(bgFP));
344 }
345
346 paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
347
348 sk_sp<GrRenderTargetContext> renderTargetContext(context->makeDeferredRenderTargetContext(
349 SkBackingFit::kApprox, bounds.width(), bounds.height(),
350 GrRenderableConfigForColorSpace(outputProperties.colorSpace()),
351 sk_ref_sp(outputProperties.colorSpace())));
352 if (!renderTargetContext) {
353 return nullptr;
354 }
355 paint.setGammaCorrect(renderTargetContext->colorSpaceInfo().isGammaCorrect());
356
357 SkMatrix matrix;
358 matrix.setTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
359 renderTargetContext->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, matrix,
360 SkRect::Make(bounds));
361
362 return SkSpecialImage::MakeDeferredFromGpu(
363 context,
364 SkIRect::MakeWH(bounds.width(), bounds.height()),
365 kNeedNewImageUniqueID_SpecialImage,
366 renderTargetContext->asTextureProxyRef(),
367 renderTargetContext->colorSpaceInfo().refColorSpace());
368 }
369 #endif
370
drawForeground(SkCanvas * canvas,SkSpecialImage * img,const SkIRect & fgBounds) const371 void ArithmeticImageFilterImpl::drawForeground(SkCanvas* canvas, SkSpecialImage* img,
372 const SkIRect& fgBounds) const {
373 SkPixmap dst;
374 if (!canvas->peekPixels(&dst)) {
375 return;
376 }
377
378 const SkMatrix& ctm = canvas->getTotalMatrix();
379 SkASSERT(ctm.getType() <= SkMatrix::kTranslate_Mask);
380 const int dx = SkScalarRoundToInt(ctm.getTranslateX());
381 const int dy = SkScalarRoundToInt(ctm.getTranslateY());
382 // be sure to perform this offset using SkIRect, since it saturates to avoid overflows
383 const SkIRect fgoffset = fgBounds.makeOffset(dx, dy);
384
385 if (img) {
386 SkBitmap srcBM;
387 SkPixmap src;
388 if (!img->getROPixels(&srcBM)) {
389 return;
390 }
391 if (!srcBM.peekPixels(&src)) {
392 return;
393 }
394
395 auto proc = fEnforcePMColor ? arith_span<true> : arith_span<false>;
396 SkPixmap tmpDst = dst;
397 if (intersect(&tmpDst, &src, fgoffset.fLeft, fgoffset.fTop)) {
398 for (int y = 0; y < tmpDst.height(); ++y) {
399 proc(fK, tmpDst.writable_addr32(0, y), src.addr32(0, y), tmpDst.width());
400 }
401 }
402 }
403
404 // Now apply the mode with transparent-color to the outside of the fg image
405 SkRegion outside(SkIRect::MakeWH(dst.width(), dst.height()));
406 outside.op(fgoffset, SkRegion::kDifference_Op);
407 auto proc = fEnforcePMColor ? arith_transparent<true> : arith_transparent<false>;
408 for (SkRegion::Iterator iter(outside); !iter.done(); iter.next()) {
409 const SkIRect r = iter.rect();
410 for (int y = r.fTop; y < r.fBottom; ++y) {
411 proc(fK, dst.writable_addr32(r.fLeft, y), r.width());
412 }
413 }
414 }
415
onMakeColorSpace(SkColorSpaceXformer * xformer) const416 sk_sp<SkImageFilter> ArithmeticImageFilterImpl::onMakeColorSpace(SkColorSpaceXformer* xformer)
417 const {
418 SkASSERT(2 == this->countInputs());
419 auto background = xformer->apply(this->getInput(0));
420 auto foreground = xformer->apply(this->getInput(1));
421 if (background.get() != this->getInput(0) || foreground.get() != this->getInput(1)) {
422 return SkArithmeticImageFilter::Make(fK[0], fK[1], fK[2], fK[3], fEnforcePMColor,
423 std::move(background), std::move(foreground),
424 getCropRectIfSet());
425 }
426 return this->refMe();
427 }
428
429 #ifndef SK_IGNORE_TO_STRING
toString(SkString * str) const430 void ArithmeticImageFilterImpl::toString(SkString* str) const {
431 str->appendf("SkArithmeticImageFilter: (");
432 str->appendf("K[]: (%f %f %f %f)", fK[0], fK[1], fK[2], fK[3]);
433 if (this->getInput(0)) {
434 str->appendf("foreground: (");
435 this->getInput(0)->toString(str);
436 str->appendf(")");
437 }
438 if (this->getInput(1)) {
439 str->appendf("background: (");
440 this->getInput(1)->toString(str);
441 str->appendf(")");
442 }
443 str->append(")");
444 }
445 #endif
446
Make(float k1,float k2,float k3,float k4,bool enforcePMColor,sk_sp<SkImageFilter> background,sk_sp<SkImageFilter> foreground,const SkImageFilter::CropRect * crop)447 sk_sp<SkImageFilter> SkArithmeticImageFilter::Make(float k1, float k2, float k3, float k4,
448 bool enforcePMColor,
449 sk_sp<SkImageFilter> background,
450 sk_sp<SkImageFilter> foreground,
451 const SkImageFilter::CropRect* crop) {
452 if (!SkScalarIsFinite(k1) || !SkScalarIsFinite(k2) || !SkScalarIsFinite(k3) ||
453 !SkScalarIsFinite(k4)) {
454 return nullptr;
455 }
456
457 // are we nearly some other "std" mode?
458 int mode = -1; // illegal mode
459 if (SkScalarNearlyZero(k1) && SkScalarNearlyEqual(k2, SK_Scalar1) && SkScalarNearlyZero(k3) &&
460 SkScalarNearlyZero(k4)) {
461 mode = (int)SkBlendMode::kSrc;
462 } else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) &&
463 SkScalarNearlyEqual(k3, SK_Scalar1) && SkScalarNearlyZero(k4)) {
464 mode = (int)SkBlendMode::kDst;
465 } else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) && SkScalarNearlyZero(k3) &&
466 SkScalarNearlyZero(k4)) {
467 mode = (int)SkBlendMode::kClear;
468 }
469 if (mode >= 0) {
470 return SkXfermodeImageFilter::Make((SkBlendMode)mode, std::move(background),
471 std::move(foreground), crop);
472 }
473
474 sk_sp<SkImageFilter> inputs[2] = {std::move(background), std::move(foreground)};
475 return sk_sp<SkImageFilter>(
476 new ArithmeticImageFilterImpl(k1, k2, k3, k4, enforcePMColor, inputs, crop));
477 }
478
479 ///////////////////////////////////////////////////////////////////////////////////////////////////
480
481 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkArithmeticImageFilter)
482 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(ArithmeticImageFilterImpl)
483 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
484