blob: c7fcb0662b756cd85f25a38c304e9e6f2e937d93 [file] [log] [blame]
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkFlattenable.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkM44.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkRegion.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkImageFilters.h"
#include "include/effects/SkRuntimeEffect.h"
#include "include/private/SkColorData.h"
#include "src/base/SkVx.h"
#include "src/core/SkImageFilter_Base.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkRuntimeEffectPriv.h"
#include "src/core/SkSpecialImage.h"
#include "src/core/SkSpecialSurface.h"
#include "src/core/SkWriteBuffer.h"
#include <algorithm>
#include <cstdint>
#include <memory>
#include <utility>
#if defined(SK_GANESH)
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrRecordingContext.h"
#include "include/gpu/GrTypes.h"
#include "src/gpu/SkBackingFit.h"
#include "src/gpu/ganesh/GrColorSpaceXform.h"
#include "src/gpu/ganesh/GrFragmentProcessor.h"
#include "src/gpu/ganesh/GrImageInfo.h"
#include "src/gpu/ganesh/GrRecordingContextPriv.h"
#include "src/gpu/ganesh/GrSamplerState.h"
#include "src/gpu/ganesh/GrSurfaceProxy.h"
#include "src/gpu/ganesh/GrSurfaceProxyView.h"
#include "src/gpu/ganesh/SurfaceFillContext.h"
#include "src/gpu/ganesh/effects/GrSkSLFP.h"
#include "src/gpu/ganesh/effects/GrTextureEffect.h"
#endif
namespace {
class SkArithmeticImageFilter final : public SkImageFilter_Base {
public:
SkArithmeticImageFilter(float k1, float k2, float k3, float k4, bool enforcePMColor,
sk_sp<SkImageFilter> inputs[2], const SkRect* cropRect)
: INHERITED(inputs, 2, cropRect)
, fK{k1, k2, k3, k4}
, fEnforcePMColor(enforcePMColor) {}
protected:
sk_sp<SkSpecialImage> onFilterImage(const Context&, SkIPoint* offset) const override;
SkIRect onFilterBounds(const SkIRect&, const SkMatrix& ctm,
MapDirection, const SkIRect* inputRect) const override;
#if defined(SK_GANESH)
sk_sp<SkSpecialImage> filterImageGPU(const Context& ctx,
sk_sp<SkSpecialImage> background,
const SkIPoint& backgroundOffset,
sk_sp<SkSpecialImage> foreground,
const SkIPoint& foregroundOffset,
const SkIRect& bounds) const;
#endif
void flatten(SkWriteBuffer& buffer) const override;
void drawForeground(SkCanvas* canvas, SkSpecialImage*, const SkIRect&) const;
private:
friend void ::SkRegisterArithmeticImageFilterFlattenable();
SK_FLATTENABLE_HOOKS(SkArithmeticImageFilter)
bool onAffectsTransparentBlack() const override { return !SkScalarNearlyZero(fK[3]); }
SkV4 fK;
bool fEnforcePMColor;
using INHERITED = SkImageFilter_Base;
};
} // end namespace
sk_sp<SkImageFilter> SkImageFilters::Arithmetic(
SkScalar k1, SkScalar k2, SkScalar k3, SkScalar k4, bool enforcePMColor,
sk_sp<SkImageFilter> background, sk_sp<SkImageFilter> foreground,
const CropRect& cropRect) {
if (!SkScalarIsFinite(k1) || !SkScalarIsFinite(k2) || !SkScalarIsFinite(k3) ||
!SkScalarIsFinite(k4)) {
return nullptr;
}
// are we nearly some other "std" mode?
int mode = -1; // illegal mode
if (SkScalarNearlyZero(k1) && SkScalarNearlyEqual(k2, SK_Scalar1) && SkScalarNearlyZero(k3) &&
SkScalarNearlyZero(k4)) {
mode = (int)SkBlendMode::kSrc;
} else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) &&
SkScalarNearlyEqual(k3, SK_Scalar1) && SkScalarNearlyZero(k4)) {
mode = (int)SkBlendMode::kDst;
} else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) && SkScalarNearlyZero(k3) &&
SkScalarNearlyZero(k4)) {
mode = (int)SkBlendMode::kClear;
}
if (mode >= 0) {
return SkImageFilters::Blend((SkBlendMode)mode, std::move(background),
std::move(foreground), cropRect);
}
sk_sp<SkImageFilter> inputs[2] = {std::move(background), std::move(foreground)};
return sk_sp<SkImageFilter>(
new SkArithmeticImageFilter(k1, k2, k3, k4, enforcePMColor, inputs, cropRect));
}
void SkRegisterArithmeticImageFilterFlattenable() {
SK_REGISTER_FLATTENABLE(SkArithmeticImageFilter);
SkFlattenable::Register("ArithmeticImageFilterImpl", SkArithmeticImageFilter::CreateProc);
}
sk_sp<SkFlattenable> SkArithmeticImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
float k[4];
for (int i = 0; i < 4; ++i) {
k[i] = buffer.readScalar();
}
const bool enforcePMColor = buffer.readBool();
if (!buffer.isValid()) {
return nullptr;
}
return SkImageFilters::Arithmetic(k[0], k[1], k[2], k[3], enforcePMColor, common.getInput(0),
common.getInput(1), common.cropRect());
}
void SkArithmeticImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
for (int i = 0; i < 4; ++i) {
buffer.writeScalar(fK[i]);
}
buffer.writeBool(fEnforcePMColor);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
template <bool EnforcePMColor>
void arith_span(const SkV4& k, SkPMColor dst[], const SkPMColor src[], int count) {
const skvx::float4 k1 = k[0] * (1/255.0f),
k2 = k[1],
k3 = k[2],
k4 = k[3] * 255.0f + 0.5f;
for (int i = 0; i < count; i++) {
skvx::float4 s = skvx::cast<float>(skvx::byte4::Load(src+i)),
d = skvx::cast<float>(skvx::byte4::Load(dst+i)),
r = pin(k1*s*d + k2*s + k3*d + k4, skvx::float4(0.f), skvx::float4(255.f));
if (EnforcePMColor) {
auto a = skvx::shuffle<3,3,3,3>(r);
r = min(a, r);
}
skvx::cast<uint8_t>(r).store(dst+i);
}
}
// apply mode to src==transparent (0)
template<bool EnforcePMColor> void arith_transparent(const SkV4& k, SkPMColor dst[], int count) {
const skvx::float4 k3 = k[2],
k4 = k[3] * 255.0f + 0.5f;
for (int i = 0; i < count; i++) {
skvx::float4 d = skvx::cast<float>(skvx::byte4::Load(dst+i)),
r = pin(k3*d + k4, skvx::float4(0.f), skvx::float4(255.f));
if (EnforcePMColor) {
auto a = skvx::shuffle<3,3,3,3>(r);
r = min(a, r);
}
skvx::cast<uint8_t>(r).store(dst+i);
}
}
static bool intersect(SkPixmap* dst, SkPixmap* src, int srcDx, int srcDy) {
SkIRect dstR = SkIRect::MakeWH(dst->width(), dst->height());
SkIRect srcR = SkIRect::MakeXYWH(srcDx, srcDy, src->width(), src->height());
SkIRect sect;
if (!sect.intersect(dstR, srcR)) {
return false;
}
*dst = SkPixmap(dst->info().makeDimensions(sect.size()),
dst->addr(sect.fLeft, sect.fTop),
dst->rowBytes());
*src = SkPixmap(src->info().makeDimensions(sect.size()),
src->addr(std::max(0, -srcDx), std::max(0, -srcDy)),
src->rowBytes());
return true;
}
sk_sp<SkSpecialImage> SkArithmeticImageFilter::onFilterImage(const Context& ctx,
SkIPoint* offset) const {
SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
sk_sp<SkSpecialImage> background(this->filterInput(0, ctx, &backgroundOffset));
SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
sk_sp<SkSpecialImage> foreground(this->filterInput(1, ctx, &foregroundOffset));
SkIRect foregroundBounds = SkIRect::MakeEmpty();
if (foreground) {
foregroundBounds = SkIRect::MakeXYWH(foregroundOffset.x(), foregroundOffset.y(),
foreground->width(), foreground->height());
}
SkIRect srcBounds = SkIRect::MakeEmpty();
if (background) {
srcBounds = SkIRect::MakeXYWH(backgroundOffset.x(), backgroundOffset.y(),
background->width(), background->height());
}
srcBounds.join(foregroundBounds);
if (srcBounds.isEmpty()) {
return nullptr;
}
SkIRect bounds;
if (!this->applyCropRect(ctx, srcBounds, &bounds)) {
return nullptr;
}
offset->fX = bounds.left();
offset->fY = bounds.top();
#if defined(SK_GANESH)
if (ctx.gpuBacked()) {
return this->filterImageGPU(ctx, background, backgroundOffset, foreground,
foregroundOffset, bounds);
}
#endif
sk_sp<SkSpecialSurface> surf(ctx.makeSurface(bounds.size()));
if (!surf) {
return nullptr;
}
SkCanvas* canvas = surf->getCanvas();
SkASSERT(canvas);
canvas->clear(0x0); // can't count on background to fully clear the background
canvas->translate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
if (background) {
SkPaint paint;
paint.setBlendMode(SkBlendMode::kSrc);
background->draw(canvas, SkIntToScalar(backgroundOffset.fX),
SkIntToScalar(backgroundOffset.fY), SkSamplingOptions(), &paint);
}
this->drawForeground(canvas, foreground.get(), foregroundBounds);
return surf->makeImageSnapshot();
}
SkIRect SkArithmeticImageFilter::onFilterBounds(const SkIRect& src,
const SkMatrix& ctm,
MapDirection dir,
const SkIRect* inputRect) const {
if (kReverse_MapDirection == dir) {
return INHERITED::onFilterBounds(src, ctm, dir, inputRect);
}
SkASSERT(2 == this->countInputs());
// result(i1,i2) = k1*i1*i2 + k2*i1 + k3*i2 + k4
// Note that background (getInput(0)) is i2, and foreground (getInput(1)) is i1.
auto i2 = this->getInput(0) ? this->getInput(0)->filterBounds(src, ctm, dir, nullptr) : src;
auto i1 = this->getInput(1) ? this->getInput(1)->filterBounds(src, ctm, dir, nullptr) : src;
// Arithmetic with non-zero k4 may influence the complete filter primitive
// region. [k4 > 0 => result(0,0) = k4 => result(i1,i2) >= k4]
if (!SkScalarNearlyZero(fK[3])) {
i1.join(i2);
return i1;
}
// If both K2 or K3 are non-zero, both i1 and i2 appear.
if (!SkScalarNearlyZero(fK[1]) && !SkScalarNearlyZero(fK[2])) {
i1.join(i2);
return i1;
}
// If k2 is non-zero, output can be produced whenever i1 is non-transparent.
// [k3 = k4 = 0 => result(i1,i2) = k1*i1*i2 + k2*i1 = (k1*i2 + k2)*i1]
if (!SkScalarNearlyZero(fK[1])) {
return i1;
}
// If k3 is non-zero, output can be produced whenever i2 is non-transparent.
// [k2 = k4 = 0 => result(i1,i2) = k1*i1*i2 + k3*i2 = (k1*i1 + k3)*i2]
if (!SkScalarNearlyZero(fK[2])) {
return i2;
}
// If just k1 is non-zero, output will only be produce where both inputs
// are non-transparent. Use intersection.
// [k1 > 0 and k2 = k3 = k4 = 0 => result(i1,i2) = k1*i1*i2]
if (!SkScalarNearlyZero(fK[0])) {
if (!i1.intersect(i2)) {
return SkIRect::MakeEmpty();
}
return i1;
}
// [k1 = k2 = k3 = k4 = 0 => result(i1,i2) = 0]
return SkIRect::MakeEmpty();
}
#if defined(SK_GANESH)
std::unique_ptr<GrFragmentProcessor> make_arithmetic_fp(
std::unique_ptr<GrFragmentProcessor> srcFP,
std::unique_ptr<GrFragmentProcessor> dstFP,
const SkV4& k,
bool enforcePMColor) {
static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
"uniform shader srcFP;"
"uniform shader dstFP;"
"uniform half4 k;"
"uniform half pmClamp;"
"half4 main(float2 xy) {"
"half4 src = srcFP.eval(xy);"
"half4 dst = dstFP.eval(xy);"
"half4 color = saturate(k.x * src * dst +"
"k.y * src +"
"k.z * dst +"
"k.w);"
"color.rgb = min(color.rgb, max(color.a, pmClamp));"
"return color;"
"}"
);
return GrSkSLFP::Make(effect, "arithmetic_fp", /*inputFP=*/nullptr, GrSkSLFP::OptFlags::kNone,
"srcFP", std::move(srcFP),
"dstFP", std::move(dstFP),
"k", k,
"pmClamp", enforcePMColor ? 0.0f : 1.0f);
}
sk_sp<SkSpecialImage> SkArithmeticImageFilter::filterImageGPU(
const Context& ctx,
sk_sp<SkSpecialImage> background,
const SkIPoint& backgroundOffset,
sk_sp<SkSpecialImage> foreground,
const SkIPoint& foregroundOffset,
const SkIRect& bounds) const {
SkASSERT(ctx.gpuBacked());
auto rContext = ctx.getContext();
GrSurfaceProxyView backgroundView, foregroundView;
GrProtected isProtected = GrProtected::kNo;
if (background) {
backgroundView = background->view(rContext);
SkASSERT(backgroundView.proxy());
isProtected = backgroundView.proxy()->isProtected();
}
if (foreground) {
foregroundView = foreground->view(rContext);
SkASSERT(foregroundView.proxy());
isProtected = foregroundView.proxy()->isProtected();
}
std::unique_ptr<GrFragmentProcessor> fp;
const auto& caps = *ctx.getContext()->priv().caps();
GrSamplerState sampler(GrSamplerState::WrapMode::kClampToBorder,
GrSamplerState::Filter::kNearest);
if (background) {
SkRect bgSubset = SkRect::Make(background->subset());
SkMatrix backgroundMatrix = SkMatrix::Translate(
SkIntToScalar(bgSubset.left() - backgroundOffset.fX),
SkIntToScalar(bgSubset.top() - backgroundOffset.fY));
fp = GrTextureEffect::MakeSubset(std::move(backgroundView),
background->alphaType(),
backgroundMatrix,
sampler,
bgSubset,
caps);
fp = GrColorSpaceXformEffect::Make(std::move(fp),
background->getColorSpace(),
background->alphaType(),
ctx.colorSpace(),
kPremul_SkAlphaType);
} else {
fp = GrFragmentProcessor::MakeColor(SK_PMColor4fTRANSPARENT);
}
if (foreground) {
SkRect fgSubset = SkRect::Make(foreground->subset());
SkMatrix foregroundMatrix = SkMatrix::Translate(
SkIntToScalar(fgSubset.left() - foregroundOffset.fX),
SkIntToScalar(fgSubset.top() - foregroundOffset.fY));
auto fgFP = GrTextureEffect::MakeSubset(std::move(foregroundView),
foreground->alphaType(),
foregroundMatrix,
sampler,
fgSubset,
caps);
fgFP = GrColorSpaceXformEffect::Make(std::move(fgFP),
foreground->getColorSpace(),
foreground->alphaType(),
ctx.colorSpace(),
kPremul_SkAlphaType);
fp = make_arithmetic_fp(std::move(fgFP), std::move(fp), fK, fEnforcePMColor);
}
GrImageInfo info(ctx.grColorType(), kPremul_SkAlphaType, ctx.refColorSpace(), bounds.size());
auto sfc = rContext->priv().makeSFC(info,
"ArithmeticImageFilter_FilterImageGPU",
SkBackingFit::kApprox,
1,
GrMipmapped::kNo,
isProtected,
kBottomLeft_GrSurfaceOrigin);
if (!sfc) {
return nullptr;
}
sfc->fillRectToRectWithFP(bounds, SkIRect::MakeSize(bounds.size()), std::move(fp));
return SkSpecialImage::MakeDeferredFromGpu(rContext,
SkIRect::MakeWH(bounds.width(), bounds.height()),
kNeedNewImageUniqueID_SpecialImage,
sfc->readSurfaceView(),
sfc->colorInfo(),
ctx.surfaceProps());
}
#endif
void SkArithmeticImageFilter::drawForeground(SkCanvas* canvas, SkSpecialImage* img,
const SkIRect& fgBounds) const {
SkPixmap dst;
if (!canvas->peekPixels(&dst)) {
return;
}
const SkMatrix& ctm = canvas->getTotalMatrix();
SkASSERT(ctm.getType() <= SkMatrix::kTranslate_Mask);
const int dx = SkScalarRoundToInt(ctm.getTranslateX());
const int dy = SkScalarRoundToInt(ctm.getTranslateY());
// be sure to perform this offset using SkIRect, since it saturates to avoid overflows
const SkIRect fgoffset = fgBounds.makeOffset(dx, dy);
if (img) {
SkBitmap srcBM;
SkPixmap src;
if (!img->getROPixels(&srcBM)) {
return;
}
if (!srcBM.peekPixels(&src)) {
return;
}
auto proc = fEnforcePMColor ? arith_span<true> : arith_span<false>;
SkPixmap tmpDst = dst;
if (intersect(&tmpDst, &src, fgoffset.fLeft, fgoffset.fTop)) {
for (int y = 0; y < tmpDst.height(); ++y) {
proc(fK, tmpDst.writable_addr32(0, y), src.addr32(0, y), tmpDst.width());
}
}
}
// Now apply the mode with transparent-color to the outside of the fg image
SkRegion outside(SkIRect::MakeWH(dst.width(), dst.height()));
outside.op(fgoffset, SkRegion::kDifference_Op);
auto proc = fEnforcePMColor ? arith_transparent<true> : arith_transparent<false>;
for (SkRegion::Iterator iter(outside); !iter.done(); iter.next()) {
const SkIRect r = iter.rect();
for (int y = r.fTop; y < r.fBottom; ++y) {
proc(fK, dst.writable_addr32(r.fLeft, y), r.width());
}
}
}