/src/skia/src/gpu/effects/GrMatrixConvolutionEffect.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
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 "src/gpu/effects/GrMatrixConvolutionEffect.h" |
8 | | |
9 | | #include "include/private/SkHalf.h" |
10 | | #include "src/gpu/GrDirectContextPriv.h" |
11 | | #include "src/gpu/GrProxyProvider.h" |
12 | | #include "src/gpu/GrRecordingContextPriv.h" |
13 | | #include "src/gpu/GrTexture.h" |
14 | | #include "src/gpu/GrTextureProxy.h" |
15 | | #include "src/gpu/GrThreadSafeCache.h" |
16 | | #include "src/gpu/SkGr.h" |
17 | | #include "src/gpu/effects/GrTextureEffect.h" |
18 | | #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h" |
19 | | #include "src/gpu/glsl/GrGLSLProgramDataManager.h" |
20 | | #include "src/gpu/glsl/GrGLSLUniformHandler.h" |
21 | | |
22 | | class GrMatrixConvolutionEffect::Impl : public ProgramImpl { |
23 | | public: |
24 | | void emitCode(EmitArgs&) override; |
25 | | |
26 | | private: |
27 | | void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override; |
28 | | |
29 | | typedef GrGLSLProgramDataManager::UniformHandle UniformHandle; |
30 | | |
31 | | void emitKernelBlock(EmitArgs&, SkIPoint); |
32 | | |
33 | | UniformHandle fKernelUni; |
34 | | UniformHandle fKernelOffsetUni; |
35 | | UniformHandle fGainUni; |
36 | | UniformHandle fBiasUni; |
37 | | UniformHandle fKernelBiasUni; |
38 | | |
39 | | using INHERITED = ProgramImpl; |
40 | | }; |
41 | | |
42 | | GrMatrixConvolutionEffect::KernelWrapper::MakeResult |
43 | | GrMatrixConvolutionEffect::KernelWrapper::Make(GrRecordingContext* rContext, |
44 | | SkISize size, |
45 | | const GrCaps& caps, |
46 | 592 | const SkScalar* values) { |
47 | 592 | if (!rContext || !values || size.isEmpty()) { |
48 | 0 | return {}; |
49 | 0 | } |
50 | | |
51 | 592 | const int length = size.area(); |
52 | | // Small kernel -> just fill the array. |
53 | 592 | KernelWrapper result(size); |
54 | 592 | if (length <= kMaxUniformSize) { |
55 | 5.78k | for (int i = 0; i < length; i++) { |
56 | 5.18k | result.fArray[i] = SkScalarToFloat(values[i]); |
57 | 5.18k | } |
58 | 592 | return {result, nullptr}; |
59 | 592 | } |
60 | | |
61 | 0 | BiasAndGain& scalableSampler = result.fBiasAndGain; |
62 | 0 | bool useA16 = |
63 | 0 | rContext->defaultBackendFormat(kA16_float_SkColorType, GrRenderable::kNo).isValid(); |
64 | 0 | SkScalar min = values[0]; |
65 | 0 | if (!useA16) { |
66 | | // Determine min and max values to figure out inner gain & bias. |
67 | 0 | SkScalar max = values[0]; |
68 | 0 | for (int i = 1; i < length; i++) { |
69 | 0 | if (values[i] < min) { |
70 | 0 | min = values[i]; |
71 | 0 | } |
72 | 0 | if (values[i] > max) { |
73 | 0 | max = values[i]; |
74 | 0 | } |
75 | 0 | } |
76 | | // Treat near-0 gain (i.e. box blur) as 1, and let the kernelBias |
77 | | // move everything up to the final value. |
78 | 0 | const SkScalar computedGain = max - min; |
79 | 0 | scalableSampler.fGain = |
80 | 0 | SkScalarNearlyZero(computedGain) ? 1.0f : SkScalarToFloat(computedGain); |
81 | | // Inner bias is pre-inner-gain so we divide that out. |
82 | 0 | scalableSampler.fBias = SkScalarToFloat(min) / scalableSampler.fGain; |
83 | 0 | } |
84 | | |
85 | | // TODO: Pick cache or dont-cache based on observed perf. |
86 | 0 | static constexpr bool kCacheKernelTexture = true; |
87 | |
|
88 | 0 | GrUniqueKey key; |
89 | 0 | if (kCacheKernelTexture) { |
90 | 0 | static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain(); |
91 | 0 | GrUniqueKey::Builder builder(&key, kDomain, length, "Matrix Convolution Kernel"); |
92 | | // Texture cache key is the exact content of the kernel. |
93 | 0 | static_assert(sizeof(float) == 4); |
94 | 0 | for (int i = 0; i < length; i++) { |
95 | 0 | builder[i] = *(const uint32_t*)&values[i]; |
96 | 0 | } |
97 | 0 | builder.finish(); |
98 | 0 | } |
99 | | |
100 | | // Find or create a texture. |
101 | 0 | auto threadSafeCache = rContext->priv().threadSafeCache(); |
102 | |
|
103 | 0 | SkColorType colorType = useA16 ? kA16_float_SkColorType : kAlpha_8_SkColorType; |
104 | |
|
105 | 0 | GrSurfaceProxyView view; |
106 | 0 | if (kCacheKernelTexture && (view = threadSafeCache->find(key))) { |
107 | 0 | SkASSERT(view.origin() == kTopLeft_GrSurfaceOrigin); |
108 | 0 | auto kernelFP = GrTextureEffect::Make(std::move(view), kUnknown_SkAlphaType); |
109 | 0 | return {result, std::move(kernelFP)}; |
110 | 0 | } |
111 | | |
112 | 0 | SkBitmap bm; |
113 | 0 | auto info = SkImageInfo::Make({length, 1}, colorType, kPremul_SkAlphaType, nullptr); |
114 | 0 | if (!bm.tryAllocPixels(info)) { |
115 | 0 | return {}; |
116 | 0 | } |
117 | 0 | for (int i = 0; i < length; i++) { |
118 | 0 | if (useA16) { |
119 | 0 | *bm.getAddr16(i, 0) = SkFloatToHalf(values[i]); |
120 | 0 | } else { |
121 | 0 | *bm.getAddr8(i, 0) = |
122 | 0 | SkScalarRoundToInt((values[i] - min) / scalableSampler.fGain * 255); |
123 | 0 | } |
124 | 0 | } |
125 | 0 | bm.setImmutable(); |
126 | |
|
127 | 0 | view = std::get<0>(GrMakeUncachedBitmapProxyView(rContext, bm)); |
128 | 0 | if (!view) { |
129 | 0 | return {}; |
130 | 0 | } |
131 | | |
132 | 0 | if (kCacheKernelTexture) { |
133 | 0 | view = threadSafeCache->add(key, view); |
134 | 0 | } |
135 | |
|
136 | 0 | SkASSERT(view.origin() == kTopLeft_GrSurfaceOrigin); |
137 | 0 | auto kernelFP = GrTextureEffect::Make(std::move(view), kUnknown_SkAlphaType); |
138 | 0 | return {result, std::move(kernelFP)}; |
139 | 0 | } |
140 | | |
141 | 0 | bool GrMatrixConvolutionEffect::KernelWrapper::operator==(const KernelWrapper& k) const { |
142 | 0 | if (fSize != k.fSize) { |
143 | 0 | return false; |
144 | 0 | } else if (this->isSampled()) { |
145 | 0 | return fBiasAndGain == k.fBiasAndGain; |
146 | 0 | } else { |
147 | 0 | return std::equal(fArray.begin(), fArray.begin() + fSize.area(), k.fArray.begin()); |
148 | 0 | } |
149 | 0 | } |
150 | | |
151 | | bool GrMatrixConvolutionEffect::KernelWrapper::BiasAndGain::operator==( |
152 | 0 | const BiasAndGain& k) const { |
153 | 0 | return fGain == k.fGain && fBias == k.fBias; |
154 | 0 | } |
155 | | |
156 | | // For sampled kernels, emit a for loop that does all the kernel accumulation. |
157 | | // For uniform kernels, emit a single iteration. Function is called repeatedly in a for loop. |
158 | | // loc is ignored for sampled kernels. |
159 | 0 | void GrMatrixConvolutionEffect::Impl::emitKernelBlock(EmitArgs& args, SkIPoint loc) { |
160 | 0 | const GrMatrixConvolutionEffect& mce = args.fFp.cast<GrMatrixConvolutionEffect>(); |
161 | 0 | GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; |
162 | 0 | GrGLSLUniformHandler* uniformHandler = args.fUniformHandler; |
163 | 0 | int kernelWidth = mce.fKernel.size().width(); |
164 | 0 | int kernelHeight = mce.fKernel.size().height(); |
165 | 0 | int kernelArea = kernelWidth * kernelHeight; |
166 | |
|
167 | 0 | if (mce.fKernel.isSampled()) { |
168 | 0 | fragBuilder->codeAppendf("for (int i = 0; i < %d; ++i)", (int)kernelArea); |
169 | 0 | } |
170 | |
|
171 | 0 | GrGLSLShaderBuilder::ShaderBlock block(fragBuilder); |
172 | |
|
173 | 0 | fragBuilder->codeAppend("half k;"); |
174 | 0 | fragBuilder->codeAppend("half2 sourceOffset;"); |
175 | 0 | if (mce.fKernel.isSampled()) { |
176 | 0 | const char* kernelBias = uniformHandler->getUniformCStr(fKernelBiasUni); |
177 | 0 | SkString kernelSample = this->invokeChild(1, args, "float2(float(i) + 0.5, 0.5)"); |
178 | 0 | fragBuilder->codeAppendf("k = %s.w + %s;", kernelSample.c_str(), kernelBias); |
179 | 0 | fragBuilder->codeAppendf("sourceOffset.y = floor(half(i) / %d);", kernelWidth); |
180 | 0 | fragBuilder->codeAppendf("sourceOffset.x = half(i) - sourceOffset.y * %d;", kernelWidth); |
181 | 0 | } else { |
182 | 0 | fragBuilder->codeAppendf("sourceOffset = half2(%d, %d);", loc.x(), loc.y()); |
183 | 0 | int offset = loc.y() * kernelWidth + loc.x(); |
184 | 0 | const char* kernel = uniformHandler->getUniformCStr(fKernelUni); |
185 | 0 | fragBuilder->codeAppendf("k = %s[%d][%d];", kernel, offset / 4, offset & 0x3); |
186 | 0 | } |
187 | |
|
188 | 0 | auto sample = this->invokeChild(0, args, "coord + sourceOffset"); |
189 | 0 | fragBuilder->codeAppendf("half4 c = %s;", sample.c_str()); |
190 | 0 | if (!mce.fConvolveAlpha) { |
191 | 0 | fragBuilder->codeAppend("c = unpremul(c);"); |
192 | 0 | fragBuilder->codeAppend("c.rgb = saturate(c.rgb);"); |
193 | 0 | } |
194 | 0 | fragBuilder->codeAppend("sum += c * k;"); |
195 | 0 | } |
196 | | |
197 | 0 | void GrMatrixConvolutionEffect::Impl::emitCode(EmitArgs& args) { |
198 | 0 | const GrMatrixConvolutionEffect& mce = args.fFp.cast<GrMatrixConvolutionEffect>(); |
199 | |
|
200 | 0 | int kernelWidth = mce.fKernel.size().width(); |
201 | 0 | int kernelHeight = mce.fKernel.size().height(); |
202 | |
|
203 | 0 | int arrayCount = (kernelWidth * kernelHeight + 3) / 4; |
204 | 0 | SkASSERT(4 * arrayCount >= kernelWidth * kernelHeight); |
205 | |
|
206 | 0 | GrGLSLUniformHandler* uniformHandler = args.fUniformHandler; |
207 | 0 | if (mce.fKernel.isSampled()) { |
208 | 0 | fKernelBiasUni = uniformHandler->addUniform(&mce, kFragment_GrShaderFlag, |
209 | 0 | kHalf_GrSLType, "KernelBias"); |
210 | 0 | } else { |
211 | 0 | fKernelUni = uniformHandler->addUniformArray(&mce, kFragment_GrShaderFlag, |
212 | 0 | kHalf4_GrSLType, "Kernel", arrayCount); |
213 | 0 | } |
214 | 0 | fKernelOffsetUni = uniformHandler->addUniform(&mce, kFragment_GrShaderFlag, kHalf2_GrSLType, |
215 | 0 | "KernelOffset"); |
216 | 0 | fGainUni = uniformHandler->addUniform(&mce, kFragment_GrShaderFlag, kHalf_GrSLType, "Gain"); |
217 | 0 | fBiasUni = uniformHandler->addUniform(&mce, kFragment_GrShaderFlag, kHalf_GrSLType, "Bias"); |
218 | |
|
219 | 0 | const char* kernelOffset = uniformHandler->getUniformCStr(fKernelOffsetUni); |
220 | 0 | const char* gain = uniformHandler->getUniformCStr(fGainUni); |
221 | 0 | const char* bias = uniformHandler->getUniformCStr(fBiasUni); |
222 | |
|
223 | 0 | GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; |
224 | 0 | fragBuilder->codeAppend("half4 sum = half4(0);"); |
225 | 0 | fragBuilder->codeAppendf("float2 coord = %s - %s;", args.fSampleCoord, kernelOffset); |
226 | |
|
227 | 0 | if (mce.fKernel.isSampled()) { |
228 | 0 | this->emitKernelBlock(args, {}); |
229 | 0 | } else { |
230 | 0 | for (int x = 0; x < kernelWidth; ++x) { |
231 | 0 | for (int y = 0; y < kernelHeight; ++y) { |
232 | 0 | this->emitKernelBlock(args, SkIPoint::Make(x, y)); |
233 | 0 | } |
234 | 0 | } |
235 | 0 | } |
236 | |
|
237 | 0 | fragBuilder->codeAppendf("half4 color;"); |
238 | 0 | if (mce.fConvolveAlpha) { |
239 | 0 | fragBuilder->codeAppendf("color = sum * %s + %s;", gain, bias); |
240 | 0 | fragBuilder->codeAppendf("color.a = saturate(color.a);"); |
241 | 0 | fragBuilder->codeAppendf("color.rgb = clamp(color.rgb, 0.0, color.a);"); |
242 | 0 | } else { |
243 | 0 | auto sample = this->invokeChild(0, args); |
244 | 0 | fragBuilder->codeAppendf("half4 c = %s;", sample.c_str()); |
245 | 0 | fragBuilder->codeAppendf("color.a = c.a;"); |
246 | 0 | fragBuilder->codeAppendf("color.rgb = saturate(sum.rgb * %s + %s);", gain, bias); |
247 | 0 | fragBuilder->codeAppendf("color.rgb *= color.a;"); |
248 | 0 | } |
249 | 0 | fragBuilder->codeAppendf("return color;"); |
250 | 0 | } Unexecuted instantiation: GrMatrixConvolutionEffect::Impl::emitCode(GrFragmentProcessor::ProgramImpl::EmitArgs&) Unexecuted instantiation: GrMatrixConvolutionEffect::Impl::emitCode(GrFragmentProcessor::ProgramImpl::EmitArgs&) |
251 | | |
252 | | void GrMatrixConvolutionEffect::Impl::onSetData(const GrGLSLProgramDataManager& pdman, |
253 | 0 | const GrFragmentProcessor& processor) { |
254 | 0 | const GrMatrixConvolutionEffect& conv = processor.cast<GrMatrixConvolutionEffect>(); |
255 | 0 | pdman.set2f(fKernelOffsetUni, conv.fKernelOffset.fX, conv.fKernelOffset.fY); |
256 | 0 | float totalGain = conv.fGain; |
257 | 0 | if (conv.fKernel.isSampled()) { |
258 | 0 | totalGain *= conv.fKernel.biasAndGain().fGain; |
259 | 0 | pdman.set1f(fKernelBiasUni, conv.fKernel.biasAndGain().fBias); |
260 | 0 | } else { |
261 | 0 | int kernelCount = conv.fKernel.size().area(); |
262 | 0 | int arrayCount = (kernelCount + 3) / 4; |
263 | 0 | SkASSERT(4 * arrayCount >= kernelCount); |
264 | 0 | pdman.set4fv(fKernelUni, arrayCount, conv.fKernel.array().data()); |
265 | 0 | } |
266 | 0 | pdman.set1f(fBiasUni, conv.fBias); |
267 | 0 | pdman.set1f(fGainUni, totalGain); |
268 | 0 | } Unexecuted instantiation: GrMatrixConvolutionEffect::Impl::onSetData(GrGLSLProgramDataManager const&, GrFragmentProcessor const&) Unexecuted instantiation: GrMatrixConvolutionEffect::Impl::onSetData(GrGLSLProgramDataManager const&, GrFragmentProcessor const&) |
269 | | |
270 | | GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(std::unique_ptr<GrFragmentProcessor> child, |
271 | | const KernelWrapper& kernel, |
272 | | std::unique_ptr<GrFragmentProcessor> kernelFP, |
273 | | SkScalar gain, |
274 | | SkScalar bias, |
275 | | const SkIPoint& kernelOffset, |
276 | | bool convolveAlpha) |
277 | | // To advertise either the modulation or opaqueness optimizations we'd have to examine the |
278 | | // parameters. |
279 | | : INHERITED(kGrMatrixConvolutionEffect_ClassID, kNone_OptimizationFlags) |
280 | | , fKernel(kernel) |
281 | | , fGain(SkScalarToFloat(gain)) |
282 | | , fBias(SkScalarToFloat(bias) / 255.0f) |
283 | 592 | , fConvolveAlpha(convolveAlpha) { |
284 | 592 | this->registerChild(std::move(child), SkSL::SampleUsage::Explicit()); |
285 | 592 | this->registerChild(std::move(kernelFP), SkSL::SampleUsage::Explicit()); |
286 | 592 | fKernelOffset = {static_cast<float>(kernelOffset.x()), |
287 | 592 | static_cast<float>(kernelOffset.y())}; |
288 | 592 | this->setUsesSampleCoordsDirectly(); |
289 | 592 | } |
290 | | |
291 | | GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(const GrMatrixConvolutionEffect& that) |
292 | | : INHERITED(that) |
293 | | , fKernel(that.fKernel) |
294 | | , fGain(that.fGain) |
295 | | , fBias(that.fBias) |
296 | | , fKernelOffset(that.fKernelOffset) |
297 | 0 | , fConvolveAlpha(that.fConvolveAlpha) {} |
298 | | |
299 | 0 | std::unique_ptr<GrFragmentProcessor> GrMatrixConvolutionEffect::clone() const { |
300 | 0 | return std::unique_ptr<GrFragmentProcessor>(new GrMatrixConvolutionEffect(*this)); |
301 | 0 | } |
302 | | |
303 | | void GrMatrixConvolutionEffect::onAddToKey(const GrShaderCaps& caps, |
304 | 0 | GrProcessorKeyBuilder* b) const { |
305 | 0 | SkASSERT(this->fKernel.size().width() <= 0x7FFF && this->fKernel.size().height() <= 0xFFFF); |
306 | 0 | uint32_t key = this->fKernel.size().width() << 16 | this->fKernel.size().height(); |
307 | 0 | key |= fConvolveAlpha ? 1U << 31 : 0; |
308 | 0 | b->add32(key); |
309 | 0 | } Unexecuted instantiation: GrMatrixConvolutionEffect::onAddToKey(GrShaderCaps const&, GrProcessorKeyBuilder*) const Unexecuted instantiation: GrMatrixConvolutionEffect::onAddToKey(GrShaderCaps const&, GrProcessorKeyBuilder*) const |
310 | | |
311 | | std::unique_ptr<GrFragmentProcessor::ProgramImpl> |
312 | 0 | GrMatrixConvolutionEffect::onMakeProgramImpl() const { |
313 | 0 | return std::make_unique<Impl>(); |
314 | 0 | } |
315 | | |
316 | 0 | bool GrMatrixConvolutionEffect::onIsEqual(const GrFragmentProcessor& sBase) const { |
317 | 0 | const GrMatrixConvolutionEffect& s = sBase.cast<GrMatrixConvolutionEffect>(); |
318 | 0 | return fKernel == s.fKernel && |
319 | 0 | fGain == s.fGain && |
320 | 0 | fBias == s.fBias && |
321 | 0 | fKernelOffset == s.fKernelOffset && |
322 | 0 | fConvolveAlpha == s.fConvolveAlpha; |
323 | 0 | } |
324 | | |
325 | | std::unique_ptr<GrFragmentProcessor> GrMatrixConvolutionEffect::Make(GrRecordingContext* context, |
326 | | GrSurfaceProxyView srcView, |
327 | | const SkIRect& srcBounds, |
328 | | const SkISize& kernelSize, |
329 | | const SkScalar* kernel, |
330 | | SkScalar gain, |
331 | | SkScalar bias, |
332 | | const SkIPoint& kernelOffset, |
333 | | GrSamplerState::WrapMode wm, |
334 | | bool convolveAlpha, |
335 | 592 | const GrCaps& caps) { |
336 | 592 | auto [kernelWrapper, kernelFP] = KernelWrapper::Make(context, kernelSize, caps, kernel); |
337 | 592 | if (!kernelWrapper.isValid()) { |
338 | 0 | return nullptr; |
339 | 0 | } |
340 | 592 | GrSamplerState sampler(wm, GrSamplerState::Filter::kNearest); |
341 | 592 | auto child = GrTextureEffect::MakeSubset(std::move(srcView), kPremul_SkAlphaType, SkMatrix::I(), |
342 | 592 | sampler, SkRect::Make(srcBounds), caps); |
343 | 592 | return std::unique_ptr<GrFragmentProcessor>( |
344 | 592 | new GrMatrixConvolutionEffect(std::move(child), kernelWrapper, std::move(kernelFP), |
345 | 592 | gain, bias, kernelOffset, convolveAlpha)); |
346 | 592 | } |
347 | | |
348 | | GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMatrixConvolutionEffect); |
349 | | |
350 | | #if GR_TEST_UTILS |
351 | 0 | std::unique_ptr<GrFragmentProcessor> GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) { |
352 | 0 | auto [view, ct, at] = d->randomView(); |
353 | |
|
354 | 0 | static constexpr size_t kMaxTestKernelSize = 2 * kMaxUniformSize; |
355 | 0 | int width = d->fRandom->nextRangeU(1, kMaxTestKernelSize); |
356 | 0 | int height = d->fRandom->nextRangeU(1, kMaxTestKernelSize / width); |
357 | 0 | SkISize kernelSize = SkISize::Make(width, height); |
358 | 0 | std::unique_ptr<SkScalar[]> kernel(new SkScalar[width * height]); |
359 | 0 | for (int i = 0; i < width * height; i++) { |
360 | 0 | kernel.get()[i] = d->fRandom->nextSScalar1(); |
361 | 0 | } |
362 | 0 | SkScalar gain = d->fRandom->nextSScalar1(); |
363 | 0 | SkScalar bias = d->fRandom->nextSScalar1(); |
364 | |
|
365 | 0 | uint32_t kernalOffsetX = d->fRandom->nextRangeU(0, kernelSize.width()); |
366 | 0 | uint32_t kernalOffsetY = d->fRandom->nextRangeU(0, kernelSize.height()); |
367 | 0 | SkIPoint kernelOffset = SkIPoint::Make(kernalOffsetX, kernalOffsetY); |
368 | |
|
369 | 0 | uint32_t boundsX = d->fRandom->nextRangeU(0, view.width()); |
370 | 0 | uint32_t boundsY = d->fRandom->nextRangeU(0, view.height()); |
371 | 0 | uint32_t boundsW = d->fRandom->nextRangeU(0, view.width()); |
372 | 0 | uint32_t boundsH = d->fRandom->nextRangeU(0, view.height()); |
373 | 0 | SkIRect bounds = SkIRect::MakeXYWH(boundsX, boundsY, boundsW, boundsH); |
374 | |
|
375 | 0 | auto wm = static_cast<GrSamplerState::WrapMode>( |
376 | 0 | d->fRandom->nextULessThan(GrSamplerState::kWrapModeCount)); |
377 | 0 | bool convolveAlpha = d->fRandom->nextBool(); |
378 | 0 | return GrMatrixConvolutionEffect::Make(d->context(), |
379 | 0 | std::move(view), |
380 | 0 | bounds, |
381 | 0 | kernelSize, |
382 | 0 | kernel.get(), |
383 | 0 | gain, |
384 | 0 | bias, |
385 | 0 | kernelOffset, |
386 | 0 | wm, |
387 | 0 | convolveAlpha, |
388 | 0 | *d->caps()); |
389 | 0 | } |
390 | | #endif |