blob: f4ec11de3538268da1e26ac0feef77cf2921d641 [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 */
Mike Kleinc0bd9f92019-04-23 12:05:21 -05007#include "src/gpu/effects/GrMatrixConvolutionEffect.h"
Robert Phillips296b1cc2017-03-15 10:42:12 -04008
Mike Kleinc0bd9f92019-04-23 12:05:21 -05009#include "include/gpu/GrTexture.h"
Greg Danielf91aeb22019-06-18 09:58:02 -040010#include "src/gpu/GrTextureProxy.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050011#include "src/gpu/glsl/GrGLSLFragmentProcessor.h"
12#include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
13#include "src/gpu/glsl/GrGLSLProgramDataManager.h"
14#include "src/gpu/glsl/GrGLSLUniformHandler.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:
Brian Salomonab015ef2017-04-04 10:15:51 -040023 void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) 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;
Ethan Nicholasf7b88202017-09-18 14:10:39 -040049 fImageIncrementUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
egdaniel7ea439b2015-12-03 09:20:44 -080050 "ImageIncrement");
Ethan Nicholasf7b88202017-09-18 14:10:39 -040051 fKernelUni = uniformHandler->addUniformArray(kFragment_GrShaderFlag, kHalf4_GrSLType,
egdaniel7ea439b2015-12-03 09:20:44 -080052 "Kernel",
jvanverth78d6eb02016-03-02 13:21:16 -080053 arrayCount);
Ethan Nicholasf7b88202017-09-18 14:10:39 -040054 fKernelOffsetUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
egdaniel7ea439b2015-12-03 09:20:44 -080055 "KernelOffset");
Ethan Nicholasf7b88202017-09-18 14:10:39 -040056 fGainUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType, "Gain");
57 fBiasUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType, "Bias");
joshualittac977922014-07-22 09:52:11 -070058
egdaniel7ea439b2015-12-03 09:20:44 -080059 const char* kernelOffset = uniformHandler->getUniformCStr(fKernelOffsetUni);
60 const char* imgInc = uniformHandler->getUniformCStr(fImageIncrementUni);
61 const char* kernel = uniformHandler->getUniformCStr(fKernelUni);
62 const char* gain = uniformHandler->getUniformCStr(fGainUni);
63 const char* bias = uniformHandler->getUniformCStr(fBiasUni);
joshualittac977922014-07-22 09:52:11 -070064
cdalton85285412016-02-18 12:37:07 -080065 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
bsalomon1a1aa932016-09-12 09:30:36 -070066 SkString coords2D = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
Ethan Nicholasf7b88202017-09-18 14:10:39 -040067 fragBuilder->codeAppend("half4 sum = half4(0, 0, 0, 0);");
Ethan Nicholas8aa45692017-09-20 11:24:15 -040068 fragBuilder->codeAppendf("float2 coord = %s - %s * %s;", coords2D.c_str(), kernelOffset, imgInc);
Ethan Nicholasf7b88202017-09-18 14:10:39 -040069 fragBuilder->codeAppend("half4 c;");
joshualitt5ae5fc52014-07-29 12:59:27 -070070
jvanverth78d6eb02016-03-02 13:21:16 -080071 const char* kVecSuffix[4] = { ".x", ".y", ".z", ".w" };
joshualitt5ae5fc52014-07-29 12:59:27 -070072 for (int y = 0; y < kHeight; y++) {
73 for (int x = 0; x < kWidth; x++) {
egdaniel4ca2e602015-11-18 08:01:26 -080074 GrGLSLShaderBuilder::ShaderBlock block(fragBuilder);
jvanverth78d6eb02016-03-02 13:21:16 -080075 int offset = y*kWidth + x;
76
Ethan Nicholasf7b88202017-09-18 14:10:39 -040077 fragBuilder->codeAppendf("half k = %s[%d]%s;", kernel, offset / 4,
jvanverth78d6eb02016-03-02 13:21:16 -080078 kVecSuffix[offset & 0x3]);
joshualitt5ae5fc52014-07-29 12:59:27 -070079 SkString coord;
Ethan Nicholasf7b88202017-09-18 14:10:39 -040080 coord.printf("coord + half2(%d, %d) * %s", x, y, imgInc);
egdaniela2e3e0f2015-11-19 07:23:45 -080081 fDomain.sampleTexture(fragBuilder,
egdaniel7ea439b2015-12-03 09:20:44 -080082 uniformHandler,
Brian Salomon1edc5b92016-11-29 13:43:46 -050083 args.fShaderCaps,
egdaniela2e3e0f2015-11-19 07:23:45 -080084 domain,
85 "c",
86 coord,
cdalton3f6f76f2016-04-11 12:18:09 -070087 args.fTexSamplers[0]);
robertphillipsbf536af2016-02-04 06:11:53 -080088 if (!mce.convolveAlpha()) {
egdaniel4ca2e602015-11-18 08:01:26 -080089 fragBuilder->codeAppend("c.rgb /= c.a;");
Ethan Nicholas12fb9cf2018-08-03 16:16:57 -040090 fragBuilder->codeAppend("c.rgb = saturate(c.rgb);");
joshualitt5ae5fc52014-07-29 12:59:27 -070091 }
egdaniel4ca2e602015-11-18 08:01:26 -080092 fragBuilder->codeAppend("sum += c * k;");
joshualitt5ae5fc52014-07-29 12:59:27 -070093 }
joshualittac977922014-07-22 09:52:11 -070094 }
robertphillipsbf536af2016-02-04 06:11:53 -080095 if (mce.convolveAlpha()) {
egdaniel4ca2e602015-11-18 08:01:26 -080096 fragBuilder->codeAppendf("%s = sum * %s + %s;", args.fOutputColor, gain, bias);
Ethan Nicholas12fb9cf2018-08-03 16:16:57 -040097 fragBuilder->codeAppendf("%s.a = saturate(%s.a);", args.fOutputColor, args.fOutputColor);
egdaniel4ca2e602015-11-18 08:01:26 -080098 fragBuilder->codeAppendf("%s.rgb = clamp(%s.rgb, 0.0, %s.a);",
99 args.fOutputColor, args.fOutputColor, args.fOutputColor);
joshualittac977922014-07-22 09:52:11 -0700100 } else {
egdaniela2e3e0f2015-11-19 07:23:45 -0800101 fDomain.sampleTexture(fragBuilder,
egdaniel7ea439b2015-12-03 09:20:44 -0800102 uniformHandler,
Brian Salomon1edc5b92016-11-29 13:43:46 -0500103 args.fShaderCaps,
egdaniela2e3e0f2015-11-19 07:23:45 -0800104 domain,
105 "c",
106 coords2D,
cdalton3f6f76f2016-04-11 12:18:09 -0700107 args.fTexSamplers[0]);
egdaniel4ca2e602015-11-18 08:01:26 -0800108 fragBuilder->codeAppendf("%s.a = c.a;", args.fOutputColor);
Ethan Nicholas12fb9cf2018-08-03 16:16:57 -0400109 fragBuilder->codeAppendf("%s.rgb = saturate(sum.rgb * %s + %s);", args.fOutputColor, gain, bias);
egdaniel4ca2e602015-11-18 08:01:26 -0800110 fragBuilder->codeAppendf("%s.rgb *= %s.a;", args.fOutputColor, args.fOutputColor);
joshualittac977922014-07-22 09:52:11 -0700111 }
Ethan Nicholas2983f402017-05-08 09:36:08 -0400112 fragBuilder->codeAppendf("%s *= %s;\n", args.fOutputColor, args.fInputColor);
joshualittac977922014-07-22 09:52:11 -0700113}
114
joshualittb0a8a372014-09-23 09:50:21 -0700115void GrGLMatrixConvolutionEffect::GenKey(const GrProcessor& processor,
Brian Salomon94efbf52016-11-29 13:43:05 -0500116 const GrShaderCaps&, GrProcessorKeyBuilder* b) {
joshualittb0a8a372014-09-23 09:50:21 -0700117 const GrMatrixConvolutionEffect& m = processor.cast<GrMatrixConvolutionEffect>();
joshualitt5ae5fc52014-07-29 12:59:27 -0700118 SkASSERT(m.kernelSize().width() <= 0x7FFF && m.kernelSize().height() <= 0xFFFF);
119 uint32_t key = m.kernelSize().width() << 16 | m.kernelSize().height();
caryclark952538e2016-02-26 05:01:42 -0800120 key |= m.convolveAlpha() ? 1U << 31 : 0;
joshualittac977922014-07-22 09:52:11 -0700121 b->add32(key);
joshualitt5ae5fc52014-07-29 12:59:27 -0700122 b->add32(GrTextureDomain::GLDomain::DomainKey(m.domain()));
joshualittac977922014-07-22 09:52:11 -0700123}
124
egdaniel018fb622015-10-28 07:26:40 -0700125void GrGLMatrixConvolutionEffect::onSetData(const GrGLSLProgramDataManager& pdman,
Brian Salomonab015ef2017-04-04 10:15:51 -0400126 const GrFragmentProcessor& processor) {
joshualittb0a8a372014-09-23 09:50:21 -0700127 const GrMatrixConvolutionEffect& conv = processor.cast<GrMatrixConvolutionEffect>();
Brian Salomon7da2fc72018-12-10 13:40:07 -0500128 GrTextureProxy* proxy = conv.textureSampler(0).proxy();
Brian Salomonfd98c2c2018-07-31 17:25:29 -0400129 GrTexture* texture = proxy->peekTexture();
robertphillipsbf536af2016-02-04 06:11:53 -0800130
joshualittac977922014-07-22 09:52:11 -0700131 float imageIncrement[2];
Robert Phillipsc686ce32017-07-21 14:12:29 -0400132 float ySign = proxy->origin() == kTopLeft_GrSurfaceOrigin ? 1.0f : -1.0f;
Brian Salomon0bbecb22016-11-17 11:38:22 -0500133 imageIncrement[0] = 1.0f / texture->width();
134 imageIncrement[1] = ySign / texture->height();
kkinnunen7510b222014-07-30 00:04:16 -0700135 pdman.set2fv(fImageIncrementUni, 1, imageIncrement);
136 pdman.set2fv(fKernelOffsetUni, 1, conv.kernelOffset());
jvanverth78d6eb02016-03-02 13:21:16 -0800137 int kernelCount = conv.kernelSize().width() * conv.kernelSize().height();
138 int arrayCount = (kernelCount + 3) / 4;
139 SkASSERT(4 * arrayCount >= kernelCount);
140 pdman.set4fv(fKernelUni, arrayCount, conv.kernel());
kkinnunen7510b222014-07-30 00:04:16 -0700141 pdman.set1f(fGainUni, conv.gain());
142 pdman.set1f(fBiasUni, conv.bias());
Michael Ludwigbe315a22018-12-17 09:50:51 -0500143 fDomain.setData(pdman, conv.domain(), proxy, conv.textureSampler(0).samplerState());
joshualittac977922014-07-22 09:52:11 -0700144}
145
Robert Phillips5140f9a2018-05-11 16:11:45 -0400146GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(sk_sp<GrTextureProxy> srcProxy,
147 const SkIRect& srcBounds,
Robert Phillips40fd7c92017-01-30 08:06:27 -0500148 const SkISize& kernelSize,
149 const SkScalar* kernel,
150 SkScalar gain,
151 SkScalar bias,
152 const SkIPoint& kernelOffset,
153 GrTextureDomain::Mode tileMode,
154 bool convolveAlpha)
Brian Salomon6cd51b52017-07-26 19:07:15 -0400155 // To advertise either the modulation or opaqueness optimizations we'd have to examine the
156 // parameters.
Ethan Nicholasabff9562017-10-09 10:54:08 -0400157 : INHERITED(kGrMatrixConvolutionEffect_ClassID, kNone_OptimizationFlags)
Robert Phillips5140f9a2018-05-11 16:11:45 -0400158 , fCoordTransform(srcProxy.get())
Michael Ludwigbe315a22018-12-17 09:50:51 -0500159 , fDomain(srcProxy.get(), GrTextureDomain::MakeTexelDomain(srcBounds, tileMode),
160 tileMode, tileMode)
Robert Phillips5140f9a2018-05-11 16:11:45 -0400161 , fTextureSampler(std::move(srcProxy))
Brian Salomon6cd51b52017-07-26 19:07:15 -0400162 , fKernelSize(kernelSize)
163 , fGain(SkScalarToFloat(gain))
164 , fBias(SkScalarToFloat(bias) / 255.0f)
165 , fConvolveAlpha(convolveAlpha) {
Brian Salomon6cd51b52017-07-26 19:07:15 -0400166 this->addCoordTransform(&fCoordTransform);
Brian Salomonf7dcd762018-07-30 14:48:15 -0400167 this->setTextureSamplerCnt(1);
Robert Phillips40fd7c92017-01-30 08:06:27 -0500168 for (int i = 0; i < kernelSize.width() * kernelSize.height(); i++) {
169 fKernel[i] = SkScalarToFloat(kernel[i]);
170 }
171 fKernelOffset[0] = static_cast<float>(kernelOffset.x());
172 fKernelOffset[1] = static_cast<float>(kernelOffset.y());
173}
174
Brian Salomon3f6f9652017-07-28 07:34:05 -0400175GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(const GrMatrixConvolutionEffect& that)
Ethan Nicholasabff9562017-10-09 10:54:08 -0400176 : INHERITED(kGrMatrixConvolutionEffect_ClassID, kNone_OptimizationFlags)
Brian Salomon3f6f9652017-07-28 07:34:05 -0400177 , fCoordTransform(that.fCoordTransform)
178 , fDomain(that.fDomain)
179 , fTextureSampler(that.fTextureSampler)
180 , fKernelSize(that.fKernelSize)
181 , fGain(that.fGain)
182 , fBias(that.fBias)
183 , fConvolveAlpha(that.fConvolveAlpha) {
Brian Salomon3f6f9652017-07-28 07:34:05 -0400184 this->addCoordTransform(&fCoordTransform);
Brian Salomonf7dcd762018-07-30 14:48:15 -0400185 this->setTextureSamplerCnt(1);
Brian Salomon3f6f9652017-07-28 07:34:05 -0400186 memcpy(fKernel, that.fKernel, sizeof(float) * fKernelSize.width() * fKernelSize.height());
187 memcpy(fKernelOffset, that.fKernelOffset, sizeof(fKernelOffset));
188}
189
Brian Salomonaff329b2017-08-11 09:40:37 -0400190std::unique_ptr<GrFragmentProcessor> GrMatrixConvolutionEffect::clone() const {
191 return std::unique_ptr<GrFragmentProcessor>(new GrMatrixConvolutionEffect(*this));
Brian Salomon3f6f9652017-07-28 07:34:05 -0400192}
193
Brian Salomon94efbf52016-11-29 13:43:05 -0500194void GrMatrixConvolutionEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
egdaniel57d3b032015-11-13 11:57:27 -0800195 GrProcessorKeyBuilder* b) const {
joshualitteb2a6762014-12-04 11:35:33 -0800196 GrGLMatrixConvolutionEffect::GenKey(*this, caps, b);
197}
198
egdaniel57d3b032015-11-13 11:57:27 -0800199GrGLSLFragmentProcessor* GrMatrixConvolutionEffect::onCreateGLSLInstance() const {
robertphillipsbf536af2016-02-04 06:11:53 -0800200 return new GrGLMatrixConvolutionEffect;
joshualittac977922014-07-22 09:52:11 -0700201}
202
bsalomon0e08fc12014-10-15 08:19:04 -0700203bool GrMatrixConvolutionEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
joshualitt49586be2014-09-16 08:21:41 -0700204 const GrMatrixConvolutionEffect& s = sBase.cast<GrMatrixConvolutionEffect>();
bsalomon420d7e92014-10-16 09:18:09 -0700205 return fKernelSize == s.kernelSize() &&
joshualittac977922014-07-22 09:52:11 -0700206 !memcmp(fKernel, s.kernel(),
207 fKernelSize.width() * fKernelSize.height() * sizeof(float)) &&
208 fGain == s.gain() &&
209 fBias == s.bias() &&
Brian Salomonce06e262017-08-01 16:23:40 -0400210 !memcmp(fKernelOffset, s.kernelOffset(), sizeof(fKernelOffset)) &&
joshualitt5ae5fc52014-07-29 12:59:27 -0700211 fConvolveAlpha == s.convolveAlpha() &&
212 fDomain == s.domain();
joshualittac977922014-07-22 09:52:11 -0700213}
214
Robert Phillips4e962c62018-06-20 07:46:19 -0400215static void fill_in_1D_gaussian_kernel_with_stride(float* kernel, int size, int stride,
216 float twoSigmaSqrd) {
217 SkASSERT(!SkScalarNearlyZero(twoSigmaSqrd, SK_ScalarNearlyZero));
218
219 const float sigmaDenom = 1.0f / twoSigmaSqrd;
220 const int radius = size / 2;
221
222 float sum = 0.0f;
223 for (int i = 0; i < size; ++i) {
224 float term = static_cast<float>(i - radius);
225 // Note that the constant term (1/(sqrt(2*pi*sigma^2)) of the Gaussian
226 // is dropped here, since we renormalize the kernel below.
227 kernel[i * stride] = sk_float_exp(-term * term * sigmaDenom);
228 sum += kernel[i * stride];
229 }
230 // Normalize the kernel
231 float scale = 1.0f / sum;
232 for (int i = 0; i < size; ++i) {
233 kernel[i * stride] *= scale;
234 }
235}
236
Robert Phillips40fd7c92017-01-30 08:06:27 -0500237static void fill_in_2D_gaussian_kernel(float* kernel, int width, int height,
238 SkScalar sigmaX, SkScalar sigmaY) {
joshualitt5acfea72014-08-11 13:55:34 -0700239 SkASSERT(width * height <= MAX_KERNEL_SIZE);
Greg Daniel4eda8d92018-04-03 14:03:15 -0400240 const float twoSigmaSqrdX = 2.0f * SkScalarToFloat(SkScalarSquare(sigmaX));
241 const float twoSigmaSqrdY = 2.0f * SkScalarToFloat(SkScalarSquare(sigmaY));
242
Robert Phillips4e962c62018-06-20 07:46:19 -0400243 // TODO: in all of these degenerate cases we're uploading (and using) a whole lot of zeros.
Greg Daniel4eda8d92018-04-03 14:03:15 -0400244 if (SkScalarNearlyZero(twoSigmaSqrdX, SK_ScalarNearlyZero) ||
245 SkScalarNearlyZero(twoSigmaSqrdY, SK_ScalarNearlyZero)) {
Robert Phillips4e962c62018-06-20 07:46:19 -0400246 // In this case the 2D Gaussian degenerates to a 1D Gaussian (in X or Y) or a point
247 SkASSERT(3 == width || 3 == height);
248 memset(kernel, 0, width*height*sizeof(float));
249
250 if (SkScalarNearlyZero(twoSigmaSqrdX, SK_ScalarNearlyZero) &&
251 SkScalarNearlyZero(twoSigmaSqrdY, SK_ScalarNearlyZero)) {
252 // A point
253 SkASSERT(3 == width && 3 == height);
254 kernel[4] = 1.0f;
255 } else if (SkScalarNearlyZero(twoSigmaSqrdX, SK_ScalarNearlyZero)) {
256 // A 1D Gaussian in Y
257 SkASSERT(3 == width);
258 // Down the middle column of the kernel with a stride of width
259 fill_in_1D_gaussian_kernel_with_stride(&kernel[1], height, width, twoSigmaSqrdY);
260 } else {
261 // A 1D Gaussian in X
262 SkASSERT(SkScalarNearlyZero(twoSigmaSqrdY, SK_ScalarNearlyZero));
263 SkASSERT(3 == height);
264 // Down the middle row of the kernel with a stride of 1
265 fill_in_1D_gaussian_kernel_with_stride(&kernel[width], width, 1, twoSigmaSqrdX);
Greg Daniel4eda8d92018-04-03 14:03:15 -0400266 }
267 return;
268 }
269
270 const float sigmaXDenom = 1.0f / twoSigmaSqrdX;
271 const float sigmaYDenom = 1.0f / twoSigmaSqrdY;
Robert Phillips40fd7c92017-01-30 08:06:27 -0500272 const int xRadius = width / 2;
273 const int yRadius = height / 2;
274
joshualitt5acfea72014-08-11 13:55:34 -0700275 float sum = 0.0f;
joshualitt5acfea72014-08-11 13:55:34 -0700276 for (int x = 0; x < width; x++) {
Robert Phillips40fd7c92017-01-30 08:06:27 -0500277 float xTerm = static_cast<float>(x - xRadius);
278 xTerm = xTerm * xTerm * sigmaXDenom;
279 for (int y = 0; y < height; y++) {
280 float yTerm = static_cast<float>(y - yRadius);
281 float xyTerm = sk_float_exp(-(xTerm + yTerm * yTerm * sigmaYDenom));
282 // Note that the constant term (1/(sqrt(2*pi*sigma^2)) of the Gaussian
283 // is dropped here, since we renormalize the kernel below.
284 kernel[y * width + x] = xyTerm;
285 sum += xyTerm;
286 }
joshualitt5acfea72014-08-11 13:55:34 -0700287 }
288 // Normalize the kernel
289 float scale = 1.0f / sum;
290 for (int i = 0; i < width * height; ++i) {
291 kernel[i] *= scale;
292 }
Robert Phillips40fd7c92017-01-30 08:06:27 -0500293}
294
Robert Phillips40fd7c92017-01-30 08:06:27 -0500295// Static function to create a 2D convolution
Brian Salomonaff329b2017-08-11 09:40:37 -0400296std::unique_ptr<GrFragmentProcessor> GrMatrixConvolutionEffect::MakeGaussian(
Robert Phillips5140f9a2018-05-11 16:11:45 -0400297 sk_sp<GrTextureProxy> srcProxy,
298 const SkIRect& srcBounds,
Brian Salomonaff329b2017-08-11 09:40:37 -0400299 const SkISize& kernelSize,
300 SkScalar gain,
301 SkScalar bias,
302 const SkIPoint& kernelOffset,
303 GrTextureDomain::Mode tileMode,
304 bool convolveAlpha,
305 SkScalar sigmaX,
306 SkScalar sigmaY) {
Robert Phillips40fd7c92017-01-30 08:06:27 -0500307 float kernel[MAX_KERNEL_SIZE];
308
309 fill_in_2D_gaussian_kernel(kernel, kernelSize.width(), kernelSize.height(), sigmaX, sigmaY);
310
Brian Salomonaff329b2017-08-11 09:40:37 -0400311 return std::unique_ptr<GrFragmentProcessor>(
Robert Phillips5140f9a2018-05-11 16:11:45 -0400312 new GrMatrixConvolutionEffect(std::move(srcProxy), srcBounds, kernelSize, kernel,
313 gain, bias, kernelOffset, tileMode, convolveAlpha));
Robert Phillips40fd7c92017-01-30 08:06:27 -0500314}
315
joshualittb0a8a372014-09-23 09:50:21 -0700316GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMatrixConvolutionEffect);
joshualittac977922014-07-22 09:52:11 -0700317
Hal Canary6f6961e2017-01-31 13:50:44 -0500318#if GR_TEST_UTILS
Brian Salomonaff329b2017-08-11 09:40:37 -0400319std::unique_ptr<GrFragmentProcessor> GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) {
Robert Phillipsdbc8eeb2017-02-21 10:04:31 -0500320 int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
321 : GrProcessorUnitTest::kAlphaTextureIdx;
322 sk_sp<GrTextureProxy> proxy = d->textureProxy(texIdx);
323
joshualitt0067ff52015-07-08 14:26:19 -0700324 int width = d->fRandom->nextRangeU(1, MAX_KERNEL_SIZE);
325 int height = d->fRandom->nextRangeU(1, MAX_KERNEL_SIZE / width);
joshualittac977922014-07-22 09:52:11 -0700326 SkISize kernelSize = SkISize::Make(width, height);
Ben Wagner7ecc5962016-11-02 17:07:33 -0400327 std::unique_ptr<SkScalar[]> kernel(new SkScalar[width * height]);
joshualittac977922014-07-22 09:52:11 -0700328 for (int i = 0; i < width * height; i++) {
joshualitt0067ff52015-07-08 14:26:19 -0700329 kernel.get()[i] = d->fRandom->nextSScalar1();
joshualittac977922014-07-22 09:52:11 -0700330 }
joshualitt0067ff52015-07-08 14:26:19 -0700331 SkScalar gain = d->fRandom->nextSScalar1();
332 SkScalar bias = d->fRandom->nextSScalar1();
333 SkIPoint kernelOffset = SkIPoint::Make(d->fRandom->nextRangeU(0, kernelSize.width()),
334 d->fRandom->nextRangeU(0, kernelSize.height()));
Robert Phillipsdbc8eeb2017-02-21 10:04:31 -0500335 SkIRect bounds = SkIRect::MakeXYWH(d->fRandom->nextRangeU(0, proxy->width()),
336 d->fRandom->nextRangeU(0, proxy->height()),
337 d->fRandom->nextRangeU(0, proxy->width()),
338 d->fRandom->nextRangeU(0, proxy->height()));
joshualitt0067ff52015-07-08 14:26:19 -0700339 GrTextureDomain::Mode tileMode =
340 static_cast<GrTextureDomain::Mode>(d->fRandom->nextRangeU(0, 2));
341 bool convolveAlpha = d->fRandom->nextBool();
Robert Phillipsfbcef6e2017-06-15 12:07:18 -0400342 return GrMatrixConvolutionEffect::Make(std::move(proxy),
bungeman06ca8ec2016-06-09 08:01:03 -0700343 bounds,
344 kernelSize,
345 kernel.get(),
346 gain,
347 bias,
348 kernelOffset,
349 tileMode,
350 convolveAlpha);
joshualittac977922014-07-22 09:52:11 -0700351}
Hal Canary6f6961e2017-01-31 13:50:44 -0500352#endif