blob: 62a53dd38094d35b041f7087da57fb720fa694ad [file] [log] [blame]
joshualittac977922014-07-22 09:52:11 -07001/*
2 * Copyright 2014 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#include "GrMatrixConvolutionEffect.h"
Robert Phillips296b1cc2017-03-15 10:42:12 -04008
Hal Canary6f6961e2017-01-31 13:50:44 -05009#include "GrTextureProxy.h"
egdaniel64c47282015-11-13 06:54:19 -080010#include "glsl/GrGLSLFragmentProcessor.h"
egdaniel7ea439b2015-12-03 09:20:44 -080011#include "glsl/GrGLSLFragmentShaderBuilder.h"
egdaniel018fb622015-10-28 07:26:40 -070012#include "glsl/GrGLSLProgramDataManager.h"
egdaniel7ea439b2015-12-03 09:20:44 -080013#include "glsl/GrGLSLUniformHandler.h"
Brian Salomon94efbf52016-11-29 13:43:05 -050014#include "../private/GrGLSL.h"
joshualittac977922014-07-22 09:52:11 -070015
egdaniel64c47282015-11-13 06:54:19 -080016class GrGLMatrixConvolutionEffect : public GrGLSLFragmentProcessor {
joshualittac977922014-07-22 09:52:11 -070017public:
robertphillips9cdb9922016-02-03 12:25:40 -080018 void emitCode(EmitArgs&) override;
joshualittac977922014-07-22 09:52:11 -070019
Brian Salomon94efbf52016-11-29 13:43:05 -050020 static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
joshualittac977922014-07-22 09:52:11 -070021
wangyixb1daa862015-08-18 11:29:31 -070022protected:
egdaniel018fb622015-10-28 07:26:40 -070023 void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
joshualittac977922014-07-22 09:52:11 -070024
25private:
egdaniel018fb622015-10-28 07:26:40 -070026 typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
joshualittac977922014-07-22 09:52:11 -070027
joshualitt5ae5fc52014-07-29 12:59:27 -070028 UniformHandle fKernelUni;
29 UniformHandle fImageIncrementUni;
30 UniformHandle fKernelOffsetUni;
31 UniformHandle fGainUni;
32 UniformHandle fBiasUni;
33 GrTextureDomain::GLDomain fDomain;
joshualittac977922014-07-22 09:52:11 -070034
egdaniel64c47282015-11-13 06:54:19 -080035 typedef GrGLSLFragmentProcessor INHERITED;
joshualittac977922014-07-22 09:52:11 -070036};
37
wangyix7c157a92015-07-22 15:08:53 -070038void GrGLMatrixConvolutionEffect::emitCode(EmitArgs& args) {
robertphillipsbf536af2016-02-04 06:11:53 -080039 const GrMatrixConvolutionEffect& mce = args.fFp.cast<GrMatrixConvolutionEffect>();
40 const GrTextureDomain& domain = mce.domain();
41
42 int kWidth = mce.kernelSize().width();
43 int kHeight = mce.kernelSize().height();
44
egdaniele506ee62016-03-02 14:29:10 -080045 int arrayCount = (kWidth * kHeight + 3) / 4;
46 SkASSERT(4 * arrayCount >= kWidth * kHeight);
jvanverth78d6eb02016-03-02 13:21:16 -080047
egdaniel7ea439b2015-12-03 09:20:44 -080048 GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
cdalton5e58cee2016-02-11 12:49:47 -080049 fImageIncrementUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
egdaniel7ea439b2015-12-03 09:20:44 -080050 kVec2f_GrSLType, kDefault_GrSLPrecision,
51 "ImageIncrement");
cdalton5e58cee2016-02-11 12:49:47 -080052 fKernelUni = uniformHandler->addUniformArray(kFragment_GrShaderFlag,
jvanverth78d6eb02016-03-02 13:21:16 -080053 kVec4f_GrSLType, kDefault_GrSLPrecision,
egdaniel7ea439b2015-12-03 09:20:44 -080054 "Kernel",
jvanverth78d6eb02016-03-02 13:21:16 -080055 arrayCount);
cdalton5e58cee2016-02-11 12:49:47 -080056 fKernelOffsetUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
egdaniel7ea439b2015-12-03 09:20:44 -080057 kVec2f_GrSLType, kDefault_GrSLPrecision,
58 "KernelOffset");
cdalton5e58cee2016-02-11 12:49:47 -080059 fGainUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
egdaniel7ea439b2015-12-03 09:20:44 -080060 kFloat_GrSLType, kDefault_GrSLPrecision, "Gain");
cdalton5e58cee2016-02-11 12:49:47 -080061 fBiasUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
egdaniel7ea439b2015-12-03 09:20:44 -080062 kFloat_GrSLType, kDefault_GrSLPrecision, "Bias");
joshualittac977922014-07-22 09:52:11 -070063
egdaniel7ea439b2015-12-03 09:20:44 -080064 const char* kernelOffset = uniformHandler->getUniformCStr(fKernelOffsetUni);
65 const char* imgInc = uniformHandler->getUniformCStr(fImageIncrementUni);
66 const char* kernel = uniformHandler->getUniformCStr(fKernelUni);
67 const char* gain = uniformHandler->getUniformCStr(fGainUni);
68 const char* bias = uniformHandler->getUniformCStr(fBiasUni);
joshualittac977922014-07-22 09:52:11 -070069
cdalton85285412016-02-18 12:37:07 -080070 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
bsalomon1a1aa932016-09-12 09:30:36 -070071 SkString coords2D = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
egdaniel4ca2e602015-11-18 08:01:26 -080072 fragBuilder->codeAppend("vec4 sum = vec4(0, 0, 0, 0);");
73 fragBuilder->codeAppendf("vec2 coord = %s - %s * %s;", coords2D.c_str(), kernelOffset, imgInc);
74 fragBuilder->codeAppend("vec4 c;");
joshualitt5ae5fc52014-07-29 12:59:27 -070075
jvanverth78d6eb02016-03-02 13:21:16 -080076 const char* kVecSuffix[4] = { ".x", ".y", ".z", ".w" };
joshualitt5ae5fc52014-07-29 12:59:27 -070077 for (int y = 0; y < kHeight; y++) {
78 for (int x = 0; x < kWidth; x++) {
egdaniel4ca2e602015-11-18 08:01:26 -080079 GrGLSLShaderBuilder::ShaderBlock block(fragBuilder);
jvanverth78d6eb02016-03-02 13:21:16 -080080 int offset = y*kWidth + x;
81
halcanary9d524f22016-03-29 09:03:52 -070082 fragBuilder->codeAppendf("float k = %s[%d]%s;", kernel, offset / 4,
jvanverth78d6eb02016-03-02 13:21:16 -080083 kVecSuffix[offset & 0x3]);
joshualitt5ae5fc52014-07-29 12:59:27 -070084 SkString coord;
85 coord.printf("coord + vec2(%d, %d) * %s", x, y, imgInc);
egdaniela2e3e0f2015-11-19 07:23:45 -080086 fDomain.sampleTexture(fragBuilder,
egdaniel7ea439b2015-12-03 09:20:44 -080087 uniformHandler,
Brian Salomon1edc5b92016-11-29 13:43:46 -050088 args.fShaderCaps,
egdaniela2e3e0f2015-11-19 07:23:45 -080089 domain,
90 "c",
91 coord,
cdalton3f6f76f2016-04-11 12:18:09 -070092 args.fTexSamplers[0]);
robertphillipsbf536af2016-02-04 06:11:53 -080093 if (!mce.convolveAlpha()) {
egdaniel4ca2e602015-11-18 08:01:26 -080094 fragBuilder->codeAppend("c.rgb /= c.a;");
95 fragBuilder->codeAppend("c.rgb = clamp(c.rgb, 0.0, 1.0);");
joshualitt5ae5fc52014-07-29 12:59:27 -070096 }
egdaniel4ca2e602015-11-18 08:01:26 -080097 fragBuilder->codeAppend("sum += c * k;");
joshualitt5ae5fc52014-07-29 12:59:27 -070098 }
joshualittac977922014-07-22 09:52:11 -070099 }
robertphillipsbf536af2016-02-04 06:11:53 -0800100 if (mce.convolveAlpha()) {
egdaniel4ca2e602015-11-18 08:01:26 -0800101 fragBuilder->codeAppendf("%s = sum * %s + %s;", args.fOutputColor, gain, bias);
Brian Salomona12c1532017-02-13 12:41:44 -0500102 fragBuilder->codeAppendf("%s.a = clamp(%s.a, 0, 1);", args.fOutputColor, args.fOutputColor);
egdaniel4ca2e602015-11-18 08:01:26 -0800103 fragBuilder->codeAppendf("%s.rgb = clamp(%s.rgb, 0.0, %s.a);",
104 args.fOutputColor, args.fOutputColor, args.fOutputColor);
joshualittac977922014-07-22 09:52:11 -0700105 } else {
egdaniela2e3e0f2015-11-19 07:23:45 -0800106 fDomain.sampleTexture(fragBuilder,
egdaniel7ea439b2015-12-03 09:20:44 -0800107 uniformHandler,
Brian Salomon1edc5b92016-11-29 13:43:46 -0500108 args.fShaderCaps,
egdaniela2e3e0f2015-11-19 07:23:45 -0800109 domain,
110 "c",
111 coords2D,
cdalton3f6f76f2016-04-11 12:18:09 -0700112 args.fTexSamplers[0]);
egdaniel4ca2e602015-11-18 08:01:26 -0800113 fragBuilder->codeAppendf("%s.a = c.a;", args.fOutputColor);
Brian Salomona12c1532017-02-13 12:41:44 -0500114 fragBuilder->codeAppendf("%s.rgb = clamp(sum.rgb * %s + %s, 0, 1);", args.fOutputColor, gain, bias);
egdaniel4ca2e602015-11-18 08:01:26 -0800115 fragBuilder->codeAppendf("%s.rgb *= %s.a;", args.fOutputColor, args.fOutputColor);
joshualittac977922014-07-22 09:52:11 -0700116 }
joshualitt5acfea72014-08-11 13:55:34 -0700117
118 SkString modulate;
wangyix7c157a92015-07-22 15:08:53 -0700119 GrGLSLMulVarBy4f(&modulate, args.fOutputColor, args.fInputColor);
egdaniel4ca2e602015-11-18 08:01:26 -0800120 fragBuilder->codeAppend(modulate.c_str());
joshualittac977922014-07-22 09:52:11 -0700121}
122
joshualittb0a8a372014-09-23 09:50:21 -0700123void GrGLMatrixConvolutionEffect::GenKey(const GrProcessor& processor,
Brian Salomon94efbf52016-11-29 13:43:05 -0500124 const GrShaderCaps&, GrProcessorKeyBuilder* b) {
joshualittb0a8a372014-09-23 09:50:21 -0700125 const GrMatrixConvolutionEffect& m = processor.cast<GrMatrixConvolutionEffect>();
joshualitt5ae5fc52014-07-29 12:59:27 -0700126 SkASSERT(m.kernelSize().width() <= 0x7FFF && m.kernelSize().height() <= 0xFFFF);
127 uint32_t key = m.kernelSize().width() << 16 | m.kernelSize().height();
caryclark952538e2016-02-26 05:01:42 -0800128 key |= m.convolveAlpha() ? 1U << 31 : 0;
joshualittac977922014-07-22 09:52:11 -0700129 b->add32(key);
joshualitt5ae5fc52014-07-29 12:59:27 -0700130 b->add32(GrTextureDomain::GLDomain::DomainKey(m.domain()));
joshualittac977922014-07-22 09:52:11 -0700131}
132
egdaniel018fb622015-10-28 07:26:40 -0700133void GrGLMatrixConvolutionEffect::onSetData(const GrGLSLProgramDataManager& pdman,
134 const GrProcessor& processor) {
joshualittb0a8a372014-09-23 09:50:21 -0700135 const GrMatrixConvolutionEffect& conv = processor.cast<GrMatrixConvolutionEffect>();
Brian Salomondb4183d2016-11-17 12:48:40 -0500136 GrTexture* texture = conv.textureSampler(0).texture();
robertphillipsbf536af2016-02-04 06:11:53 -0800137
joshualittac977922014-07-22 09:52:11 -0700138 float imageIncrement[2];
Brian Salomon0bbecb22016-11-17 11:38:22 -0500139 float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? 1.0f : -1.0f;
140 imageIncrement[0] = 1.0f / texture->width();
141 imageIncrement[1] = ySign / texture->height();
kkinnunen7510b222014-07-30 00:04:16 -0700142 pdman.set2fv(fImageIncrementUni, 1, imageIncrement);
143 pdman.set2fv(fKernelOffsetUni, 1, conv.kernelOffset());
jvanverth78d6eb02016-03-02 13:21:16 -0800144 int kernelCount = conv.kernelSize().width() * conv.kernelSize().height();
145 int arrayCount = (kernelCount + 3) / 4;
146 SkASSERT(4 * arrayCount >= kernelCount);
147 pdman.set4fv(fKernelUni, arrayCount, conv.kernel());
kkinnunen7510b222014-07-30 00:04:16 -0700148 pdman.set1f(fGainUni, conv.gain());
149 pdman.set1f(fBiasUni, conv.bias());
Robert Phillipse98234f2017-01-09 14:23:59 -0500150 fDomain.setData(pdman, conv.domain(), texture);
joshualittac977922014-07-22 09:52:11 -0700151}
152
Robert Phillips296b1cc2017-03-15 10:42:12 -0400153GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(GrResourceProvider* resourceProvider,
Robert Phillips40fd7c92017-01-30 08:06:27 -0500154 sk_sp<GrTextureProxy> proxy,
155 const SkIRect& bounds,
156 const SkISize& kernelSize,
157 const SkScalar* kernel,
158 SkScalar gain,
159 SkScalar bias,
160 const SkIPoint& kernelOffset,
161 GrTextureDomain::Mode tileMode,
162 bool convolveAlpha)
163 // To advertise either the modulation or opaqueness optimizations we'd have to examine the
164 // parameters.
Robert Phillips296b1cc2017-03-15 10:42:12 -0400165 : INHERITED(resourceProvider, kNone_OptimizationFlags, proxy, nullptr, SkMatrix::I())
Robert Phillips40fd7c92017-01-30 08:06:27 -0500166 , fKernelSize(kernelSize)
167 , fGain(SkScalarToFloat(gain))
168 , fBias(SkScalarToFloat(bias) / 255.0f)
169 , fConvolveAlpha(convolveAlpha)
170 , fDomain(proxy.get(), GrTextureDomain::MakeTexelDomainForMode(bounds, tileMode), tileMode) {
171 this->initClassID<GrMatrixConvolutionEffect>();
172 for (int i = 0; i < kernelSize.width() * kernelSize.height(); i++) {
173 fKernel[i] = SkScalarToFloat(kernel[i]);
174 }
175 fKernelOffset[0] = static_cast<float>(kernelOffset.x());
176 fKernelOffset[1] = static_cast<float>(kernelOffset.y());
177}
178
Brian Salomon94efbf52016-11-29 13:43:05 -0500179void GrMatrixConvolutionEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
egdaniel57d3b032015-11-13 11:57:27 -0800180 GrProcessorKeyBuilder* b) const {
joshualitteb2a6762014-12-04 11:35:33 -0800181 GrGLMatrixConvolutionEffect::GenKey(*this, caps, b);
182}
183
egdaniel57d3b032015-11-13 11:57:27 -0800184GrGLSLFragmentProcessor* GrMatrixConvolutionEffect::onCreateGLSLInstance() const {
robertphillipsbf536af2016-02-04 06:11:53 -0800185 return new GrGLMatrixConvolutionEffect;
joshualittac977922014-07-22 09:52:11 -0700186}
187
bsalomon0e08fc12014-10-15 08:19:04 -0700188bool GrMatrixConvolutionEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
joshualitt49586be2014-09-16 08:21:41 -0700189 const GrMatrixConvolutionEffect& s = sBase.cast<GrMatrixConvolutionEffect>();
bsalomon420d7e92014-10-16 09:18:09 -0700190 return fKernelSize == s.kernelSize() &&
joshualittac977922014-07-22 09:52:11 -0700191 !memcmp(fKernel, s.kernel(),
192 fKernelSize.width() * fKernelSize.height() * sizeof(float)) &&
193 fGain == s.gain() &&
194 fBias == s.bias() &&
195 fKernelOffset == s.kernelOffset() &&
joshualitt5ae5fc52014-07-29 12:59:27 -0700196 fConvolveAlpha == s.convolveAlpha() &&
197 fDomain == s.domain();
joshualittac977922014-07-22 09:52:11 -0700198}
199
Robert Phillips40fd7c92017-01-30 08:06:27 -0500200static void fill_in_2D_gaussian_kernel(float* kernel, int width, int height,
201 SkScalar sigmaX, SkScalar sigmaY) {
joshualitt5acfea72014-08-11 13:55:34 -0700202 SkASSERT(width * height <= MAX_KERNEL_SIZE);
Robert Phillips40fd7c92017-01-30 08:06:27 -0500203 const float sigmaXDenom = 1.0f / (2.0f * SkScalarToFloat(SkScalarSquare(sigmaX)));
204 const float sigmaYDenom = 1.0f / (2.0f * SkScalarToFloat(SkScalarSquare(sigmaY)));
205 const int xRadius = width / 2;
206 const int yRadius = height / 2;
207
joshualitt5acfea72014-08-11 13:55:34 -0700208 float sum = 0.0f;
joshualitt5acfea72014-08-11 13:55:34 -0700209 for (int x = 0; x < width; x++) {
Robert Phillips40fd7c92017-01-30 08:06:27 -0500210 float xTerm = static_cast<float>(x - xRadius);
211 xTerm = xTerm * xTerm * sigmaXDenom;
212 for (int y = 0; y < height; y++) {
213 float yTerm = static_cast<float>(y - yRadius);
214 float xyTerm = sk_float_exp(-(xTerm + yTerm * yTerm * sigmaYDenom));
215 // Note that the constant term (1/(sqrt(2*pi*sigma^2)) of the Gaussian
216 // is dropped here, since we renormalize the kernel below.
217 kernel[y * width + x] = xyTerm;
218 sum += xyTerm;
219 }
joshualitt5acfea72014-08-11 13:55:34 -0700220 }
221 // Normalize the kernel
222 float scale = 1.0f / sum;
223 for (int i = 0; i < width * height; ++i) {
224 kernel[i] *= scale;
225 }
Robert Phillips40fd7c92017-01-30 08:06:27 -0500226}
227
228
229// Static function to create a 2D convolution
Robert Phillips296b1cc2017-03-15 10:42:12 -0400230sk_sp<GrFragmentProcessor> GrMatrixConvolutionEffect::MakeGaussian(
231 GrResourceProvider* resourceProvider,
232 sk_sp<GrTextureProxy> proxy,
233 const SkIRect& bounds,
234 const SkISize& kernelSize,
235 SkScalar gain,
236 SkScalar bias,
237 const SkIPoint& kernelOffset,
238 GrTextureDomain::Mode tileMode,
239 bool convolveAlpha,
240 SkScalar sigmaX,
241 SkScalar sigmaY) {
Robert Phillips40fd7c92017-01-30 08:06:27 -0500242 float kernel[MAX_KERNEL_SIZE];
243
244 fill_in_2D_gaussian_kernel(kernel, kernelSize.width(), kernelSize.height(), sigmaX, sigmaY);
245
246 return sk_sp<GrFragmentProcessor>(
Robert Phillips296b1cc2017-03-15 10:42:12 -0400247 new GrMatrixConvolutionEffect(resourceProvider, std::move(proxy), bounds, kernelSize,
248 kernel, gain, bias, kernelOffset, tileMode, convolveAlpha));
Robert Phillips40fd7c92017-01-30 08:06:27 -0500249}
250
joshualittb0a8a372014-09-23 09:50:21 -0700251GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMatrixConvolutionEffect);
joshualittac977922014-07-22 09:52:11 -0700252
Hal Canary6f6961e2017-01-31 13:50:44 -0500253#if GR_TEST_UTILS
bungeman06ca8ec2016-06-09 08:01:03 -0700254sk_sp<GrFragmentProcessor> GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) {
Robert Phillipsdbc8eeb2017-02-21 10:04:31 -0500255 int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
256 : GrProcessorUnitTest::kAlphaTextureIdx;
257 sk_sp<GrTextureProxy> proxy = d->textureProxy(texIdx);
258
joshualitt0067ff52015-07-08 14:26:19 -0700259 int width = d->fRandom->nextRangeU(1, MAX_KERNEL_SIZE);
260 int height = d->fRandom->nextRangeU(1, MAX_KERNEL_SIZE / width);
joshualittac977922014-07-22 09:52:11 -0700261 SkISize kernelSize = SkISize::Make(width, height);
Ben Wagner7ecc5962016-11-02 17:07:33 -0400262 std::unique_ptr<SkScalar[]> kernel(new SkScalar[width * height]);
joshualittac977922014-07-22 09:52:11 -0700263 for (int i = 0; i < width * height; i++) {
joshualitt0067ff52015-07-08 14:26:19 -0700264 kernel.get()[i] = d->fRandom->nextSScalar1();
joshualittac977922014-07-22 09:52:11 -0700265 }
joshualitt0067ff52015-07-08 14:26:19 -0700266 SkScalar gain = d->fRandom->nextSScalar1();
267 SkScalar bias = d->fRandom->nextSScalar1();
268 SkIPoint kernelOffset = SkIPoint::Make(d->fRandom->nextRangeU(0, kernelSize.width()),
269 d->fRandom->nextRangeU(0, kernelSize.height()));
Robert Phillipsdbc8eeb2017-02-21 10:04:31 -0500270 SkIRect bounds = SkIRect::MakeXYWH(d->fRandom->nextRangeU(0, proxy->width()),
271 d->fRandom->nextRangeU(0, proxy->height()),
272 d->fRandom->nextRangeU(0, proxy->width()),
273 d->fRandom->nextRangeU(0, proxy->height()));
joshualitt0067ff52015-07-08 14:26:19 -0700274 GrTextureDomain::Mode tileMode =
275 static_cast<GrTextureDomain::Mode>(d->fRandom->nextRangeU(0, 2));
276 bool convolveAlpha = d->fRandom->nextBool();
Robert Phillips296b1cc2017-03-15 10:42:12 -0400277 return GrMatrixConvolutionEffect::Make(d->resourceProvider(),
Robert Phillipsdbc8eeb2017-02-21 10:04:31 -0500278 std::move(proxy),
bungeman06ca8ec2016-06-09 08:01:03 -0700279 bounds,
280 kernelSize,
281 kernel.get(),
282 gain,
283 bias,
284 kernelOffset,
285 tileMode,
286 convolveAlpha);
joshualittac977922014-07-22 09:52:11 -0700287}
Hal Canary6f6961e2017-01-31 13:50:44 -0500288#endif