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 "SkTypes.h"
9 #include "Test.h"
10
11 #include "GrClip.h"
12 #include "GrContext.h"
13 #include "GrContextPriv.h"
14 #include "GrGpuResource.h"
15 #include "GrMemoryPool.h"
16 #include "GrProxyProvider.h"
17 #include "GrRenderTargetContext.h"
18 #include "GrRenderTargetContextPriv.h"
19 #include "GrResourceProvider.h"
20 #include "glsl/GrGLSLFragmentProcessor.h"
21 #include "glsl/GrGLSLFragmentShaderBuilder.h"
22 #include "ops/GrFillRectOp.h"
23 #include "ops/GrMeshDrawOp.h"
24 #include "TestUtils.h"
25
26 #include <atomic>
27 #include <random>
28
29 namespace {
30 class TestOp : public GrMeshDrawOp {
31 public:
32 DEFINE_OP_CLASS_ID
Make(GrContext * context,std::unique_ptr<GrFragmentProcessor> fp)33 static std::unique_ptr<GrDrawOp> Make(GrContext* context,
34 std::unique_ptr<GrFragmentProcessor> fp) {
35 GrOpMemoryPool* pool = context->priv().opMemoryPool();
36
37 return pool->allocate<TestOp>(std::move(fp));
38 }
39
name() const40 const char* name() const override { return "TestOp"; }
41
visitProxies(const VisitProxyFunc & func,VisitorType) const42 void visitProxies(const VisitProxyFunc& func, VisitorType) const override {
43 fProcessors.visitProxies(func);
44 }
45
fixedFunctionFlags() const46 FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; }
47
finalize(const GrCaps & caps,const GrAppliedClip * clip,GrFSAAType fsaaType,GrClampType clampType)48 GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
49 GrFSAAType fsaaType, GrClampType clampType) override {
50 static constexpr GrProcessorAnalysisColor kUnknownColor;
51 SkPMColor4f overrideColor;
52 return fProcessors.finalize(
53 kUnknownColor, GrProcessorAnalysisCoverage::kNone, clip,
54 &GrUserStencilSettings::kUnused, fsaaType, caps, clampType, &overrideColor);
55 }
56
57 private:
58 friend class ::GrOpMemoryPool; // for ctor
59
TestOp(std::unique_ptr<GrFragmentProcessor> fp)60 TestOp(std::unique_ptr<GrFragmentProcessor> fp)
61 : INHERITED(ClassID()), fProcessors(std::move(fp)) {
62 this->setBounds(SkRect::MakeWH(100, 100), HasAABloat::kNo, IsZeroArea::kNo);
63 }
64
onPrepareDraws(Target * target)65 void onPrepareDraws(Target* target) override { return; }
onExecute(GrOpFlushState *,const SkRect &)66 void onExecute(GrOpFlushState*, const SkRect&) override { return; }
67
68 GrProcessorSet fProcessors;
69
70 typedef GrMeshDrawOp INHERITED;
71 };
72
73 /**
74 * FP used to test ref/IO counts on owned GrGpuResources. Can also be a parent FP to test counts
75 * of resources owned by child FPs.
76 */
77 class TestFP : public GrFragmentProcessor {
78 public:
Make(std::unique_ptr<GrFragmentProcessor> child)79 static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor> child) {
80 return std::unique_ptr<GrFragmentProcessor>(new TestFP(std::move(child)));
81 }
Make(const SkTArray<sk_sp<GrTextureProxy>> & proxies,const SkTArray<sk_sp<GrGpuBuffer>> & buffers)82 static std::unique_ptr<GrFragmentProcessor> Make(const SkTArray<sk_sp<GrTextureProxy>>& proxies,
83 const SkTArray<sk_sp<GrGpuBuffer>>& buffers) {
84 return std::unique_ptr<GrFragmentProcessor>(new TestFP(proxies, buffers));
85 }
86
name() const87 const char* name() const override { return "test"; }
88
onGetGLSLProcessorKey(const GrShaderCaps &,GrProcessorKeyBuilder * b) const89 void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const override {
90 static std::atomic<int32_t> nextKey{0};
91 b->add32(nextKey++);
92 }
93
clone() const94 std::unique_ptr<GrFragmentProcessor> clone() const override {
95 return std::unique_ptr<GrFragmentProcessor>(new TestFP(*this));
96 }
97
98 private:
TestFP(const SkTArray<sk_sp<GrTextureProxy>> & proxies,const SkTArray<sk_sp<GrGpuBuffer>> & buffers)99 TestFP(const SkTArray<sk_sp<GrTextureProxy>>& proxies,
100 const SkTArray<sk_sp<GrGpuBuffer>>& buffers)
101 : INHERITED(kTestFP_ClassID, kNone_OptimizationFlags), fSamplers(4) {
102 for (const auto& proxy : proxies) {
103 fSamplers.emplace_back(proxy);
104 }
105 this->setTextureSamplerCnt(fSamplers.count());
106 }
107
TestFP(std::unique_ptr<GrFragmentProcessor> child)108 TestFP(std::unique_ptr<GrFragmentProcessor> child)
109 : INHERITED(kTestFP_ClassID, kNone_OptimizationFlags), fSamplers(4) {
110 this->registerChildProcessor(std::move(child));
111 }
112
TestFP(const TestFP & that)113 explicit TestFP(const TestFP& that)
114 : INHERITED(kTestFP_ClassID, that.optimizationFlags()), fSamplers(4) {
115 for (int i = 0; i < that.fSamplers.count(); ++i) {
116 fSamplers.emplace_back(that.fSamplers[i]);
117 }
118 for (int i = 0; i < that.numChildProcessors(); ++i) {
119 this->registerChildProcessor(that.childProcessor(i).clone());
120 }
121 this->setTextureSamplerCnt(fSamplers.count());
122 }
123
onCreateGLSLInstance() const124 virtual GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
125 class TestGLSLFP : public GrGLSLFragmentProcessor {
126 public:
127 TestGLSLFP() {}
128 void emitCode(EmitArgs& args) override {
129 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
130 fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, args.fInputColor);
131 }
132
133 private:
134 };
135 return new TestGLSLFP();
136 }
137
onIsEqual(const GrFragmentProcessor &) const138 bool onIsEqual(const GrFragmentProcessor&) const override { return false; }
onTextureSampler(int i) const139 const TextureSampler& onTextureSampler(int i) const override { return fSamplers[i]; }
140
141 GrTAllocator<TextureSampler> fSamplers;
142 typedef GrFragmentProcessor INHERITED;
143 };
144 }
145
146 template <typename T>
testingOnly_getIORefCnts(const T * resource,int * refCnt,int * readCnt,int * writeCnt)147 inline void testingOnly_getIORefCnts(const T* resource, int* refCnt, int* readCnt, int* writeCnt) {
148 *refCnt = resource->fRefCnt;
149 *readCnt = resource->fPendingReads;
150 *writeCnt = resource->fPendingWrites;
151 }
152
testingOnly_getIORefCnts(GrTextureProxy * proxy,int * refCnt,int * readCnt,int * writeCnt)153 void testingOnly_getIORefCnts(GrTextureProxy* proxy, int* refCnt, int* readCnt, int* writeCnt) {
154 *refCnt = proxy->getBackingRefCnt_TestOnly();
155 *readCnt = proxy->getPendingReadCnt_TestOnly();
156 *writeCnt = proxy->getPendingWriteCnt_TestOnly();
157 }
158
DEF_GPUTEST_FOR_ALL_CONTEXTS(ProcessorRefTest,reporter,ctxInfo)159 DEF_GPUTEST_FOR_ALL_CONTEXTS(ProcessorRefTest, reporter, ctxInfo) {
160 GrContext* context = ctxInfo.grContext();
161 GrProxyProvider* proxyProvider = context->priv().proxyProvider();
162
163 GrSurfaceDesc desc;
164 desc.fWidth = 10;
165 desc.fHeight = 10;
166 desc.fConfig = kRGBA_8888_GrPixelConfig;
167
168 const GrBackendFormat format =
169 context->priv().caps()->getBackendFormatFromColorType(kRGBA_8888_SkColorType);
170
171 for (bool makeClone : {false, true}) {
172 for (int parentCnt = 0; parentCnt < 2; parentCnt++) {
173 sk_sp<GrRenderTargetContext> renderTargetContext(
174 context->priv().makeDeferredRenderTargetContext(
175 format, SkBackingFit::kApprox, 1, 1,
176 kRGBA_8888_GrPixelConfig, nullptr));
177 {
178 sk_sp<GrTextureProxy> proxy1 = proxyProvider->createProxy(
179 format, desc, kTopLeft_GrSurfaceOrigin, SkBackingFit::kExact,
180 SkBudgeted::kYes);
181 sk_sp<GrTextureProxy> proxy2 = proxyProvider->createProxy(
182 format, desc, kTopLeft_GrSurfaceOrigin, SkBackingFit::kExact,
183 SkBudgeted::kYes);
184 sk_sp<GrTextureProxy> proxy3 = proxyProvider->createProxy(
185 format, desc, kTopLeft_GrSurfaceOrigin, SkBackingFit::kExact,
186 SkBudgeted::kYes);
187 sk_sp<GrTextureProxy> proxy4 = proxyProvider->createProxy(
188 format, desc, kTopLeft_GrSurfaceOrigin, SkBackingFit::kExact,
189 SkBudgeted::kYes);
190 {
191 SkTArray<sk_sp<GrTextureProxy>> proxies;
192 SkTArray<sk_sp<GrGpuBuffer>> buffers;
193 proxies.push_back(proxy1);
194 auto fp = TestFP::Make(std::move(proxies), std::move(buffers));
195 for (int i = 0; i < parentCnt; ++i) {
196 fp = TestFP::Make(std::move(fp));
197 }
198 std::unique_ptr<GrFragmentProcessor> clone;
199 if (makeClone) {
200 clone = fp->clone();
201 }
202 std::unique_ptr<GrDrawOp> op(TestOp::Make(context, std::move(fp)));
203 renderTargetContext->priv().testingOnly_addDrawOp(std::move(op));
204 if (clone) {
205 op = TestOp::Make(context, std::move(clone));
206 renderTargetContext->priv().testingOnly_addDrawOp(std::move(op));
207 }
208 }
209 int refCnt, readCnt, writeCnt;
210
211 testingOnly_getIORefCnts(proxy1.get(), &refCnt, &readCnt, &writeCnt);
212 // IO counts should be double if there is a clone of the FP.
213 int ioRefMul = makeClone ? 2 : 1;
214 REPORTER_ASSERT(reporter, -1 == refCnt);
215 REPORTER_ASSERT(reporter, ioRefMul * 1 == readCnt);
216 REPORTER_ASSERT(reporter, ioRefMul * 0 == writeCnt);
217
218 context->flush();
219
220 testingOnly_getIORefCnts(proxy1.get(), &refCnt, &readCnt, &writeCnt);
221 REPORTER_ASSERT(reporter, 1 == refCnt);
222 REPORTER_ASSERT(reporter, ioRefMul * 0 == readCnt);
223 REPORTER_ASSERT(reporter, ioRefMul * 0 == writeCnt);
224
225 }
226 }
227 }
228 }
229
230 // This test uses the random GrFragmentProcessor test factory, which relies on static initializers.
231 #if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
232
233 #include "SkCommandLineFlags.h"
234 DEFINE_bool(randomProcessorTest, false, "Use non-deterministic seed for random processor tests?");
235 DEFINE_uint32(processorSeed, 0, "Use specific seed for processor tests. Overridden by " \
236 "--randomProcessorTest.");
237
238 #if GR_TEST_UTILS
239
input_texel_color(int i,int j,SkScalar delta)240 static GrColor input_texel_color(int i, int j, SkScalar delta) {
241 // Delta must be less than 0.5 to prevent over/underflow issues with the input color
242 SkASSERT(delta <= 0.5);
243
244 SkColor color = SkColorSetARGB((uint8_t)(i & 0xFF),
245 (uint8_t)(j & 0xFF),
246 (uint8_t)((i + j) & 0xFF),
247 (uint8_t)((2 * j - i) & 0xFF));
248 SkColor4f color4f = SkColor4f::FromColor(color);
249 for (int i = 0; i < 4; i++) {
250 if (color4f[i] > 0.5) {
251 color4f[i] -= delta;
252 } else {
253 color4f[i] += delta;
254 }
255 }
256 return color4f.premul().toBytes_RGBA();
257 }
258
test_draw_op(GrContext * context,GrRenderTargetContext * rtc,std::unique_ptr<GrFragmentProcessor> fp,sk_sp<GrTextureProxy> inputDataProxy)259 void test_draw_op(GrContext* context,
260 GrRenderTargetContext* rtc,
261 std::unique_ptr<GrFragmentProcessor> fp,
262 sk_sp<GrTextureProxy> inputDataProxy) {
263 GrPaint paint;
264 paint.addColorTextureProcessor(std::move(inputDataProxy), SkMatrix::I());
265 paint.addColorFragmentProcessor(std::move(fp));
266 paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
267
268 auto op = GrFillRectOp::Make(context, std::move(paint), GrAAType::kNone, SkMatrix::I(),
269 SkRect::MakeWH(rtc->width(), rtc->height()));
270 rtc->addDrawOp(GrNoClip(), std::move(op));
271 }
272
273 // This assumes that the output buffer will be the same size as inputDataProxy
render_fp(GrContext * context,GrRenderTargetContext * rtc,GrFragmentProcessor * fp,sk_sp<GrTextureProxy> inputDataProxy,GrColor * buffer)274 void render_fp(GrContext* context, GrRenderTargetContext* rtc, GrFragmentProcessor* fp,
275 sk_sp<GrTextureProxy> inputDataProxy, GrColor* buffer) {
276 int width = inputDataProxy->width();
277 int height = inputDataProxy->height();
278
279 // test_draw_op needs to take ownership of an FP, so give it a clone that it can own
280 test_draw_op(context, rtc, fp->clone(), inputDataProxy);
281 memset(buffer, 0x0, sizeof(GrColor) * width * height);
282 rtc->readPixels(SkImageInfo::Make(width, height, kRGBA_8888_SkColorType,
283 kPremul_SkAlphaType),
284 buffer, 0, 0, 0);
285 }
286
287 /** Initializes the two test texture proxies that are available to the FP test factories. */
init_test_textures(GrProxyProvider * proxyProvider,SkRandom * random,sk_sp<GrTextureProxy> proxies[2])288 bool init_test_textures(GrProxyProvider* proxyProvider, SkRandom* random,
289 sk_sp<GrTextureProxy> proxies[2]) {
290 static const int kTestTextureSize = 256;
291
292 {
293 // Put premul data into the RGBA texture that the test FPs can optionally use.
294 std::unique_ptr<GrColor[]> rgbaData(new GrColor[kTestTextureSize * kTestTextureSize]);
295 for (int y = 0; y < kTestTextureSize; ++y) {
296 for (int x = 0; x < kTestTextureSize; ++x) {
297 rgbaData[kTestTextureSize * y + x] = input_texel_color(
298 random->nextULessThan(256), random->nextULessThan(256), 0.0f);
299 }
300 }
301
302 SkImageInfo ii = SkImageInfo::Make(kTestTextureSize, kTestTextureSize,
303 kRGBA_8888_SkColorType, kPremul_SkAlphaType);
304 SkPixmap pixmap(ii, rgbaData.get(), ii.minRowBytes());
305 sk_sp<SkImage> img = SkImage::MakeRasterCopy(pixmap);
306 proxies[0] = proxyProvider->createTextureProxy(img, kNone_GrSurfaceFlags, 1,
307 SkBudgeted::kYes, SkBackingFit::kExact);
308 }
309
310 {
311 // Put random values into the alpha texture that the test FPs can optionally use.
312 std::unique_ptr<uint8_t[]> alphaData(new uint8_t[kTestTextureSize * kTestTextureSize]);
313 for (int y = 0; y < kTestTextureSize; ++y) {
314 for (int x = 0; x < kTestTextureSize; ++x) {
315 alphaData[kTestTextureSize * y + x] = random->nextULessThan(256);
316 }
317 }
318
319 SkImageInfo ii = SkImageInfo::Make(kTestTextureSize, kTestTextureSize,
320 kAlpha_8_SkColorType, kPremul_SkAlphaType);
321 SkPixmap pixmap(ii, alphaData.get(), ii.minRowBytes());
322 sk_sp<SkImage> img = SkImage::MakeRasterCopy(pixmap);
323 proxies[1] = proxyProvider->createTextureProxy(img, kNone_GrSurfaceFlags, 1,
324 SkBudgeted::kYes, SkBackingFit::kExact);
325 }
326
327 return proxies[0] && proxies[1];
328 }
329
330 // Creates a texture of premul colors used as the output of the fragment processor that precedes
331 // the fragment processor under test. Color values are those provided by input_texel_color().
make_input_texture(GrProxyProvider * proxyProvider,int width,int height,SkScalar delta)332 sk_sp<GrTextureProxy> make_input_texture(GrProxyProvider* proxyProvider, int width, int height,
333 SkScalar delta) {
334 std::unique_ptr<GrColor[]> data(new GrColor[width * height]);
335 for (int y = 0; y < width; ++y) {
336 for (int x = 0; x < height; ++x) {
337 data.get()[width * y + x] = input_texel_color(x, y, delta);
338 }
339 }
340
341 SkImageInfo ii = SkImageInfo::Make(width, height, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
342 SkPixmap pixmap(ii, data.get(), ii.minRowBytes());
343 sk_sp<SkImage> img = SkImage::MakeRasterCopy(pixmap);
344 return proxyProvider->createTextureProxy(img, kNone_GrSurfaceFlags, 1,
345 SkBudgeted::kYes, SkBackingFit::kExact);
346 }
347
log_surface_context(sk_sp<GrSurfaceContext> src,SkString * dst)348 bool log_surface_context(sk_sp<GrSurfaceContext> src, SkString* dst) {
349 SkImageInfo ii = SkImageInfo::Make(src->width(), src->height(), kRGBA_8888_SkColorType,
350 kPremul_SkAlphaType);
351 SkBitmap bm;
352 SkAssertResult(bm.tryAllocPixels(ii));
353 SkAssertResult(src->readPixels(ii, bm.getPixels(), bm.rowBytes(), 0, 0));
354
355 return bitmap_to_base64_data_uri(bm, dst);
356 }
357
log_surface_proxy(GrContext * context,sk_sp<GrSurfaceProxy> src,SkString * dst)358 bool log_surface_proxy(GrContext* context, sk_sp<GrSurfaceProxy> src, SkString* dst) {
359 sk_sp<GrSurfaceContext> sContext(context->priv().makeWrappedSurfaceContext(src));
360 return log_surface_context(sContext, dst);
361 }
362
fuzzy_color_equals(const SkPMColor4f & c1,const SkPMColor4f & c2)363 bool fuzzy_color_equals(const SkPMColor4f& c1, const SkPMColor4f& c2) {
364 // With the loss of precision of rendering into 32-bit color, then estimating the FP's output
365 // from that, it is not uncommon for a valid output to differ from estimate by up to 0.01
366 // (really 1/128 ~ .0078, but frequently floating point issues make that tolerance a little
367 // too unforgiving).
368 static constexpr SkScalar kTolerance = 0.01f;
369 for (int i = 0; i < 4; i++) {
370 if (!SkScalarNearlyEqual(c1[i], c2[i], kTolerance)) {
371 return false;
372 }
373 }
374 return true;
375 }
376
modulation_index(int channelIndex,bool alphaModulation)377 int modulation_index(int channelIndex, bool alphaModulation) {
378 return alphaModulation ? 3 : channelIndex;
379 }
380
381 // Given three input colors (color preceding the FP being tested), and the output of the FP, this
382 // ensures that the out1 = fp * in1.a, out2 = fp * in2.a, and out3 = fp * in3.a, where fp is the
383 // pre-modulated color that should not be changing across frames (FP's state doesn't change).
384 //
385 // When alphaModulation is false, this tests the very similar conditions that out1 = fp * in1,
386 // etc. using per-channel modulation instead of modulation by just the input alpha channel.
387 // - This estimates the pre-modulated fp color from one of the input/output pairs and confirms the
388 // conditions hold for the other two pairs.
legal_modulation(const GrColor & in1,const GrColor & in2,const GrColor & in3,const GrColor & out1,const GrColor & out2,const GrColor & out3,bool alphaModulation)389 bool legal_modulation(const GrColor& in1, const GrColor& in2, const GrColor& in3,
390 const GrColor& out1, const GrColor& out2, const GrColor& out3,
391 bool alphaModulation) {
392 // Convert to floating point, which is the number space the FP operates in (more or less)
393 SkPMColor4f in1f = SkPMColor4f::FromBytes_RGBA(in1);
394 SkPMColor4f in2f = SkPMColor4f::FromBytes_RGBA(in2);
395 SkPMColor4f in3f = SkPMColor4f::FromBytes_RGBA(in3);
396 SkPMColor4f out1f = SkPMColor4f::FromBytes_RGBA(out1);
397 SkPMColor4f out2f = SkPMColor4f::FromBytes_RGBA(out2);
398 SkPMColor4f out3f = SkPMColor4f::FromBytes_RGBA(out3);
399
400 // Reconstruct the output of the FP before the shader modulated its color with the input value.
401 // When the original input is very small, it may cause the final output color to round
402 // to 0, in which case we estimate the pre-modulated color using one of the stepped frames that
403 // will then have a guaranteed larger channel value (since the offset will be added to it).
404 SkPMColor4f fpPreModulation;
405 for (int i = 0; i < 4; i++) {
406 int modulationIndex = modulation_index(i, alphaModulation);
407 if (in1f[modulationIndex] < 0.2f) {
408 // Use the stepped frame
409 fpPreModulation[i] = out2f[i] / in2f[modulationIndex];
410 } else {
411 fpPreModulation[i] = out1f[i] / in1f[modulationIndex];
412 }
413 }
414
415 // With reconstructed pre-modulated FP output, derive the expected value of fp * input for each
416 // of the transformed input colors.
417 SkPMColor4f expected1 = alphaModulation ? (fpPreModulation * in1f.fA)
418 : (fpPreModulation * in1f);
419 SkPMColor4f expected2 = alphaModulation ? (fpPreModulation * in2f.fA)
420 : (fpPreModulation * in2f);
421 SkPMColor4f expected3 = alphaModulation ? (fpPreModulation * in3f.fA)
422 : (fpPreModulation * in3f);
423
424 return fuzzy_color_equals(out1f, expected1) &&
425 fuzzy_color_equals(out2f, expected2) &&
426 fuzzy_color_equals(out3f, expected3);
427 }
428
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest,reporter,ctxInfo)429 DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, reporter, ctxInfo) {
430 GrContext* context = ctxInfo.grContext();
431 GrProxyProvider* proxyProvider = context->priv().proxyProvider();
432 auto resourceProvider = context->priv().resourceProvider();
433 using FPFactory = GrFragmentProcessorTestFactory;
434
435 uint32_t seed = FLAGS_processorSeed;
436 if (FLAGS_randomProcessorTest) {
437 std::random_device rd;
438 seed = rd();
439 }
440 // If a non-deterministic bot fails this test, check the output to see what seed it used, then
441 // use --processorSeed <seed> (without --randomProcessorTest) to reproduce.
442 SkRandom random(seed);
443
444 const GrBackendFormat format =
445 context->priv().caps()->getBackendFormatFromColorType(kRGBA_8888_SkColorType);
446
447 // Make the destination context for the test.
448 static constexpr int kRenderSize = 256;
449 sk_sp<GrRenderTargetContext> rtc = context->priv().makeDeferredRenderTargetContext(
450 format, SkBackingFit::kExact, kRenderSize, kRenderSize, kRGBA_8888_GrPixelConfig,
451 nullptr);
452
453 sk_sp<GrTextureProxy> proxies[2];
454 if (!init_test_textures(proxyProvider, &random, proxies)) {
455 ERRORF(reporter, "Could not create test textures");
456 return;
457 }
458 GrProcessorTestData testData(&random, context, rtc.get(), proxies);
459
460 // Coverage optimization uses three frames with a linearly transformed input texture. The first
461 // frame has no offset, second frames add .2 and .4, which should then be present as a fixed
462 // difference between the frame outputs if the FP is properly following the modulation
463 // requirements of the coverage optimization.
464 static constexpr SkScalar kInputDelta = 0.2f;
465 auto inputTexture1 = make_input_texture(proxyProvider, kRenderSize, kRenderSize, 0.0f);
466 auto inputTexture2 = make_input_texture(proxyProvider, kRenderSize, kRenderSize, kInputDelta);
467 auto inputTexture3 = make_input_texture(proxyProvider, kRenderSize, kRenderSize, 2*kInputDelta);
468
469 // Encoded images are very verbose and this tests many potential images, so only export the
470 // first failure (subsequent failures have a reasonable chance of being related).
471 bool loggedFirstFailure = false;
472 bool loggedFirstWarning = false;
473
474 // Storage for the three frames required for coverage compatibility optimization. Each frame
475 // uses the correspondingly numbered inputTextureX.
476 std::unique_ptr<GrColor[]> readData1(new GrColor[kRenderSize * kRenderSize]);
477 std::unique_ptr<GrColor[]> readData2(new GrColor[kRenderSize * kRenderSize]);
478 std::unique_ptr<GrColor[]> readData3(new GrColor[kRenderSize * kRenderSize]);
479
480 // Because processor factories configure themselves in random ways, this is not exhaustive.
481 for (int i = 0; i < FPFactory::Count(); ++i) {
482 int timesToInvokeFactory = 5;
483 // Increase the number of attempts if the FP has child FPs since optimizations likely depend
484 // on child optimizations being present.
485 std::unique_ptr<GrFragmentProcessor> fp = FPFactory::MakeIdx(i, &testData);
486 for (int j = 0; j < fp->numChildProcessors(); ++j) {
487 // This value made a reasonable trade off between time and coverage when this test was
488 // written.
489 timesToInvokeFactory *= FPFactory::Count() / 2;
490 }
491 #if defined(__MSVC_RUNTIME_CHECKS)
492 // This test is infuriatingly slow with MSVC runtime checks enabled
493 timesToInvokeFactory = 1;
494 #endif
495 for (int j = 0; j < timesToInvokeFactory; ++j) {
496 fp = FPFactory::MakeIdx(i, &testData);
497 if (!fp->instantiate(resourceProvider)) {
498 continue;
499 }
500
501 if (!fp->hasConstantOutputForConstantInput() && !fp->preservesOpaqueInput() &&
502 !fp->compatibleWithCoverageAsAlpha()) {
503 continue;
504 }
505
506 if (fp->compatibleWithCoverageAsAlpha()) {
507 // 2nd and 3rd frames are only used when checking coverage optimization
508 render_fp(context, rtc.get(), fp.get(), inputTexture2, readData2.get());
509 render_fp(context, rtc.get(), fp.get(), inputTexture3, readData3.get());
510 }
511 // Draw base frame last so that rtc holds the original FP behavior if we need to
512 // dump the image to the log.
513 render_fp(context, rtc.get(), fp.get(), inputTexture1, readData1.get());
514
515 if (0) { // Useful to see what FPs are being tested.
516 SkString children;
517 for (int c = 0; c < fp->numChildProcessors(); ++c) {
518 if (!c) {
519 children.append("(");
520 }
521 children.append(fp->childProcessor(c).name());
522 children.append(c == fp->numChildProcessors() - 1 ? ")" : ", ");
523 }
524 SkDebugf("%s %s\n", fp->name(), children.c_str());
525 }
526
527 // This test has a history of being flaky on a number of devices. If an FP is logically
528 // violating the optimizations, it's reasonable to expect it to violate requirements on
529 // a large number of pixels in the image. Sporadic pixel violations are more indicative
530 // of device errors and represents a separate problem.
531 #if defined(SK_BUILD_FOR_SKQP)
532 static constexpr int kMaxAcceptableFailedPixels = 0; // Strict when running as SKQP
533 #else
534 static constexpr int kMaxAcceptableFailedPixels = 2 * kRenderSize; // ~0.7% of the image
535 #endif
536
537 int failedPixelCount = 0;
538 // Collect first optimization failure message, to be output later as a warning or an
539 // error depending on whether the rendering "passed" or failed.
540 SkString coverageMessage;
541 SkString opaqueMessage;
542 SkString constMessage;
543 for (int y = 0; y < kRenderSize; ++y) {
544 for (int x = 0; x < kRenderSize; ++x) {
545 bool passing = true;
546 GrColor input = input_texel_color(x, y, 0.0f);
547 GrColor output = readData1.get()[y * kRenderSize + x];
548
549 if (fp->compatibleWithCoverageAsAlpha()) {
550 GrColor i2 = input_texel_color(x, y, kInputDelta);
551 GrColor i3 = input_texel_color(x, y, 2 * kInputDelta);
552
553 GrColor o2 = readData2.get()[y * kRenderSize + x];
554 GrColor o3 = readData3.get()[y * kRenderSize + x];
555
556 // A compatible processor is allowed to modulate either the input color or
557 // just the input alpha.
558 bool legalAlphaModulation = legal_modulation(input, i2, i3, output, o2, o3,
559 /* alpha */ true);
560 bool legalColorModulation = legal_modulation(input, i2, i3, output, o2, o3,
561 /* alpha */ false);
562
563 if (!legalColorModulation && !legalAlphaModulation) {
564 passing = false;
565
566 if (coverageMessage.isEmpty()) {
567 coverageMessage.printf("\"Modulating\" processor %s did not match "
568 "alpha-modulation nor color-modulation rules. "
569 "Input: 0x%08x, Output: 0x%08x, pixel (%d, %d).",
570 fp->name(), input, output, x, y);
571 }
572 }
573 }
574
575 SkPMColor4f input4f = SkPMColor4f::FromBytes_RGBA(input);
576 SkPMColor4f output4f = SkPMColor4f::FromBytes_RGBA(output);
577 SkPMColor4f expected4f;
578 if (fp->hasConstantOutputForConstantInput(input4f, &expected4f)) {
579 float rDiff = fabsf(output4f.fR - expected4f.fR);
580 float gDiff = fabsf(output4f.fG - expected4f.fG);
581 float bDiff = fabsf(output4f.fB - expected4f.fB);
582 float aDiff = fabsf(output4f.fA - expected4f.fA);
583 static constexpr float kTol = 4 / 255.f;
584 if (rDiff > kTol || gDiff > kTol || bDiff > kTol || aDiff > kTol) {
585 if (constMessage.isEmpty()) {
586 passing = false;
587
588 constMessage.printf("Processor %s claimed output for const input "
589 "doesn't match actual output. Error: %f, Tolerance: %f, "
590 "input: (%f, %f, %f, %f), actual: (%f, %f, %f, %f), "
591 "expected(%f, %f, %f, %f)", fp->name(),
592 SkTMax(rDiff, SkTMax(gDiff, SkTMax(bDiff, aDiff))), kTol,
593 input4f.fR, input4f.fG, input4f.fB, input4f.fA,
594 output4f.fR, output4f.fG, output4f.fB, output4f.fA,
595 expected4f.fR, expected4f.fG, expected4f.fB, expected4f.fA);
596 }
597 }
598 }
599 if (input4f.isOpaque() && fp->preservesOpaqueInput() && !output4f.isOpaque()) {
600 passing = false;
601
602 if (opaqueMessage.isEmpty()) {
603 opaqueMessage.printf("Processor %s claimed opaqueness is preserved but "
604 "it is not. Input: 0x%08x, Output: 0x%08x.",
605 fp->name(), input, output);
606 }
607 }
608
609 if (!passing) {
610 // Regardless of how many optimizations the pixel violates, count it as a
611 // single bad pixel.
612 failedPixelCount++;
613 }
614 }
615 }
616
617 // Finished analyzing the entire image, see if the number of pixel failures meets the
618 // threshold for an FP violating the optimization requirements.
619 if (failedPixelCount > kMaxAcceptableFailedPixels) {
620 ERRORF(reporter, "Processor violated %d of %d pixels, seed: 0x%08x, processor: %s"
621 ", first failing pixel details are below:",
622 failedPixelCount, kRenderSize * kRenderSize, seed,
623 fp->dumpInfo().c_str());
624
625 // Print first failing pixel's details.
626 if (!coverageMessage.isEmpty()) {
627 ERRORF(reporter, coverageMessage.c_str());
628 }
629 if (!constMessage.isEmpty()) {
630 ERRORF(reporter, constMessage.c_str());
631 }
632 if (!opaqueMessage.isEmpty()) {
633 ERRORF(reporter, opaqueMessage.c_str());
634 }
635
636 if (!loggedFirstFailure) {
637 // Print with ERRORF to make sure the encoded image is output
638 SkString input;
639 log_surface_proxy(context, inputTexture1, &input);
640 SkString output;
641 log_surface_context(rtc, &output);
642 ERRORF(reporter, "Input image: %s\n\n"
643 "===========================================================\n\n"
644 "Output image: %s\n", input.c_str(), output.c_str());
645 loggedFirstFailure = true;
646 }
647 } else if(failedPixelCount > 0) {
648 // Don't trigger an error, but don't just hide the failures either.
649 INFOF(reporter, "Processor violated %d of %d pixels (below error threshold), seed: "
650 "0x%08x, processor: %s", failedPixelCount, kRenderSize * kRenderSize,
651 seed, fp->dumpInfo().c_str());
652 if (!coverageMessage.isEmpty()) {
653 INFOF(reporter, coverageMessage.c_str());
654 }
655 if (!constMessage.isEmpty()) {
656 INFOF(reporter, constMessage.c_str());
657 }
658 if (!opaqueMessage.isEmpty()) {
659 INFOF(reporter, opaqueMessage.c_str());
660 }
661 if (!loggedFirstWarning) {
662 SkString input;
663 log_surface_proxy(context, inputTexture1, &input);
664 SkString output;
665 log_surface_context(rtc, &output);
666 INFOF(reporter, "Input image: %s\n\n"
667 "===========================================================\n\n"
668 "Output image: %s\n", input.c_str(), output.c_str());
669 loggedFirstWarning = true;
670 }
671 }
672 }
673 }
674 }
675
676 // Tests that fragment processors returned by GrFragmentProcessor::clone() are equivalent to their
677 // progenitors.
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorCloneTest,reporter,ctxInfo)678 DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorCloneTest, reporter, ctxInfo) {
679 GrContext* context = ctxInfo.grContext();
680 GrProxyProvider* proxyProvider = context->priv().proxyProvider();
681 auto resourceProvider = context->priv().resourceProvider();
682
683 SkRandom random;
684
685 const GrBackendFormat format =
686 context->priv().caps()->getBackendFormatFromColorType(kRGBA_8888_SkColorType);
687
688 // Make the destination context for the test.
689 static constexpr int kRenderSize = 1024;
690 sk_sp<GrRenderTargetContext> rtc = context->priv().makeDeferredRenderTargetContext(
691 format, SkBackingFit::kExact, kRenderSize, kRenderSize, kRGBA_8888_GrPixelConfig,
692 nullptr);
693
694 sk_sp<GrTextureProxy> proxies[2];
695 if (!init_test_textures(proxyProvider, &random, proxies)) {
696 ERRORF(reporter, "Could not create test textures");
697 return;
698 }
699 GrProcessorTestData testData(&random, context, rtc.get(), proxies);
700
701 auto inputTexture = make_input_texture(proxyProvider, kRenderSize, kRenderSize, 0.0f);
702 std::unique_ptr<GrColor[]> readData1(new GrColor[kRenderSize * kRenderSize]);
703 std::unique_ptr<GrColor[]> readData2(new GrColor[kRenderSize * kRenderSize]);
704 auto readInfo = SkImageInfo::Make(kRenderSize, kRenderSize, kRGBA_8888_SkColorType,
705 kPremul_SkAlphaType);
706
707 // Because processor factories configure themselves in random ways, this is not exhaustive.
708 for (int i = 0; i < GrFragmentProcessorTestFactory::Count(); ++i) {
709 static constexpr int kTimesToInvokeFactory = 10;
710 for (int j = 0; j < kTimesToInvokeFactory; ++j) {
711 auto fp = GrFragmentProcessorTestFactory::MakeIdx(i, &testData);
712 auto clone = fp->clone();
713 if (!clone) {
714 ERRORF(reporter, "Clone of processor %s failed.", fp->name());
715 continue;
716 }
717 const char* name = fp->name();
718 if (!fp->instantiate(resourceProvider) || !clone->instantiate(resourceProvider)) {
719 continue;
720 }
721 REPORTER_ASSERT(reporter, !strcmp(fp->name(), clone->name()));
722 REPORTER_ASSERT(reporter, fp->compatibleWithCoverageAsAlpha() ==
723 clone->compatibleWithCoverageAsAlpha());
724 REPORTER_ASSERT(reporter, fp->isEqual(*clone));
725 REPORTER_ASSERT(reporter, fp->preservesOpaqueInput() == clone->preservesOpaqueInput());
726 REPORTER_ASSERT(reporter, fp->hasConstantOutputForConstantInput() ==
727 clone->hasConstantOutputForConstantInput());
728 REPORTER_ASSERT(reporter, fp->numChildProcessors() == clone->numChildProcessors());
729 REPORTER_ASSERT(reporter, fp->usesLocalCoords() == clone->usesLocalCoords());
730 // Draw with original and read back the results.
731 render_fp(context, rtc.get(), fp.get(), inputTexture, readData1.get());
732
733 // Draw with clone and read back the results.
734 render_fp(context, rtc.get(), clone.get(), inputTexture, readData2.get());
735
736 // Check that the results are the same.
737 bool passing = true;
738 for (int y = 0; y < kRenderSize && passing; ++y) {
739 for (int x = 0; x < kRenderSize && passing; ++x) {
740 int idx = y * kRenderSize + x;
741 if (readData1[idx] != readData2[idx]) {
742 ERRORF(reporter,
743 "Processor %s made clone produced different output. "
744 "Input color: 0x%08x, Original Output Color: 0x%08x, "
745 "Clone Output Color: 0x%08x..",
746 name, input_texel_color(x, y, 0.0f), readData1[idx], readData2[idx]);
747 passing = false;
748 }
749 }
750 }
751 }
752 }
753 }
754
755 #endif // GR_TEST_UTILS
756 #endif // SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
757