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