blob: 0a7ad7566e9146fb270b39bde847fc97fb66f567 [file] [log] [blame]
Brian Salomonbc6b99d2017-01-11 10:32:34 -05001/*
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
Brian Salomonac70f842017-05-08 10:43:33 -040011#include <random>
Brian Salomonc65aec92017-03-09 09:03:58 -050012#include "GrClip.h"
Brian Salomonbc6b99d2017-01-11 10:32:34 -050013#include "GrContext.h"
Robert Phillips1afd4cd2018-01-08 13:40:32 -050014#include "GrContextPriv.h"
Brian Salomonbc6b99d2017-01-11 10:32:34 -050015#include "GrGpuResource.h"
Robert Phillips7c525e62018-06-12 10:11:12 -040016#include "GrMemoryPool.h"
Robert Phillips0bd24dc2018-01-16 08:06:32 -050017#include "GrProxyProvider.h"
Brian Salomonbc6b99d2017-01-11 10:32:34 -050018#include "GrRenderTargetContext.h"
19#include "GrRenderTargetContextPriv.h"
20#include "GrResourceProvider.h"
21#include "glsl/GrGLSLFragmentProcessor.h"
22#include "glsl/GrGLSLFragmentShaderBuilder.h"
Brian Salomon82ddc942017-07-14 12:00:13 -040023#include "ops/GrMeshDrawOp.h"
Brian Salomonbaaf4392017-06-15 09:59:23 -040024#include "ops/GrRectOpFactory.h"
Brian Salomonbc6b99d2017-01-11 10:32:34 -050025
26namespace {
Brian Salomon82ddc942017-07-14 12:00:13 -040027class TestOp : public GrMeshDrawOp {
Brian Salomonbc6b99d2017-01-11 10:32:34 -050028public:
29 DEFINE_OP_CLASS_ID
Robert Phillips7c525e62018-06-12 10:11:12 -040030 static std::unique_ptr<GrDrawOp> Make(GrContext* context,
31 std::unique_ptr<GrFragmentProcessor> fp) {
Robert Phillipsc994a932018-06-19 13:09:54 -040032 GrOpMemoryPool* pool = context->contextPriv().opMemoryPool();
33
34 return pool->allocate<TestOp>(std::move(fp));
Brian Salomon82ddc942017-07-14 12:00:13 -040035 }
36
Robert Phillips5f567c72017-09-14 08:27:37 -040037 const char* name() const override { return "TestOp"; }
38
Robert Phillipsf1748f52017-09-14 14:11:24 -040039 void visitProxies(const VisitProxyFunc& func) const override {
Robert Phillips5f567c72017-09-14 08:27:37 -040040 fProcessors.visitProxies(func);
41 }
42
Brian Salomon82ddc942017-07-14 12:00:13 -040043 FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; }
44
Brian Osman532b3f92018-07-11 10:02:07 -040045 RequiresDstTexture finalize(const GrCaps& caps, const GrAppliedClip* clip) override {
Brian Salomon82ddc942017-07-14 12:00:13 -040046 static constexpr GrProcessorAnalysisColor kUnknownColor;
47 GrColor overrideColor;
48 fProcessors.finalize(kUnknownColor, GrProcessorAnalysisCoverage::kNone, clip, false, caps,
Brian Osman532b3f92018-07-11 10:02:07 -040049 &overrideColor);
Brian Salomon82ddc942017-07-14 12:00:13 -040050 return RequiresDstTexture::kNo;
Brian Salomon649a3412017-03-09 13:50:43 -050051 }
Brian Salomonbc6b99d2017-01-11 10:32:34 -050052
53private:
Robert Phillips7c525e62018-06-12 10:11:12 -040054 friend class ::GrOpMemoryPool; // for ctor
55
Brian Salomonaff329b2017-08-11 09:40:37 -040056 TestOp(std::unique_ptr<GrFragmentProcessor> fp)
57 : INHERITED(ClassID()), fProcessors(std::move(fp)) {
Brian Salomon82ddc942017-07-14 12:00:13 -040058 this->setBounds(SkRect::MakeWH(100, 100), HasAABloat::kNo, IsZeroArea::kNo);
59 }
Brian Salomonbc6b99d2017-01-11 10:32:34 -050060
Brian Salomon91326c32017-08-09 16:02:19 -040061 void onPrepareDraws(Target* target) override { return; }
Brian Salomonbc6b99d2017-01-11 10:32:34 -050062
Brian Salomon82ddc942017-07-14 12:00:13 -040063 GrProcessorSet fProcessors;
64
65 typedef GrMeshDrawOp INHERITED;
Brian Salomonbc6b99d2017-01-11 10:32:34 -050066};
67
68/**
69 * FP used to test ref/IO counts on owned GrGpuResources. Can also be a parent FP to test counts
70 * of resources owned by child FPs.
71 */
72class TestFP : public GrFragmentProcessor {
73public:
Brian Salomonaff329b2017-08-11 09:40:37 -040074 static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor> child) {
75 return std::unique_ptr<GrFragmentProcessor>(new TestFP(std::move(child)));
Brian Salomonbc6b99d2017-01-11 10:32:34 -050076 }
Brian Salomonaff329b2017-08-11 09:40:37 -040077 static std::unique_ptr<GrFragmentProcessor> Make(const SkTArray<sk_sp<GrTextureProxy>>& proxies,
Brian Salomon559f5562017-11-15 14:28:33 -050078 const SkTArray<sk_sp<GrBuffer>>& buffers) {
79 return std::unique_ptr<GrFragmentProcessor>(new TestFP(proxies, buffers));
Brian Salomonbc6b99d2017-01-11 10:32:34 -050080 }
81
82 const char* name() const override { return "test"; }
83
84 void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const override {
85 // We don't really care about reusing these.
86 static int32_t gKey = 0;
87 b->add32(sk_atomic_inc(&gKey));
88 }
89
Brian Salomonaff329b2017-08-11 09:40:37 -040090 std::unique_ptr<GrFragmentProcessor> clone() const override {
91 return std::unique_ptr<GrFragmentProcessor>(new TestFP(*this));
Brian Salomonb17e6392017-07-28 13:41:51 -040092 }
93
Brian Salomonbc6b99d2017-01-11 10:32:34 -050094private:
Brian Salomon559f5562017-11-15 14:28:33 -050095 TestFP(const SkTArray<sk_sp<GrTextureProxy>>& proxies, const SkTArray<sk_sp<GrBuffer>>& buffers)
Brian Salomon662ea4b2018-07-12 14:53:49 -040096 : INHERITED(kTestFP_ClassID, kNone_OptimizationFlags), fSamplers(4) {
Robert Phillips30f9bc62017-02-22 15:28:38 -050097 for (const auto& proxy : proxies) {
Brian Salomonf7dcd762018-07-30 14:48:15 -040098 fSamplers.emplace_back(proxy);
Brian Salomonbc6b99d2017-01-11 10:32:34 -050099 }
Brian Salomonf7dcd762018-07-30 14:48:15 -0400100 this->setTextureSamplerCnt(fSamplers.count());
Brian Salomonbc6b99d2017-01-11 10:32:34 -0500101 }
102
Brian Salomonaff329b2017-08-11 09:40:37 -0400103 TestFP(std::unique_ptr<GrFragmentProcessor> child)
Brian Salomon662ea4b2018-07-12 14:53:49 -0400104 : INHERITED(kTestFP_ClassID, kNone_OptimizationFlags), fSamplers(4) {
Brian Salomonbc6b99d2017-01-11 10:32:34 -0500105 this->registerChildProcessor(std::move(child));
106 }
107
Brian Salomon96271cd2017-07-31 16:27:23 -0400108 explicit TestFP(const TestFP& that)
Brian Salomon662ea4b2018-07-12 14:53:49 -0400109 : INHERITED(kTestFP_ClassID, that.optimizationFlags()), fSamplers(4) {
Brian Salomonb17e6392017-07-28 13:41:51 -0400110 for (int i = 0; i < that.fSamplers.count(); ++i) {
111 fSamplers.emplace_back(that.fSamplers[i]);
Brian Salomonb17e6392017-07-28 13:41:51 -0400112 }
Brian Salomon96271cd2017-07-31 16:27:23 -0400113 for (int i = 0; i < that.numChildProcessors(); ++i) {
114 this->registerChildProcessor(that.childProcessor(i).clone());
Brian Salomonb17e6392017-07-28 13:41:51 -0400115 }
Brian Salomonf7dcd762018-07-30 14:48:15 -0400116 this->setTextureSamplerCnt(fSamplers.count());
Brian Salomonb17e6392017-07-28 13:41:51 -0400117 }
118
Brian Salomonbc6b99d2017-01-11 10:32:34 -0500119 virtual GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
120 class TestGLSLFP : public GrGLSLFragmentProcessor {
121 public:
122 TestGLSLFP() {}
123 void emitCode(EmitArgs& args) override {
124 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
125 fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, args.fInputColor);
126 }
127
128 private:
129 };
130 return new TestGLSLFP();
131 }
132
133 bool onIsEqual(const GrFragmentProcessor&) const override { return false; }
Brian Salomonf7dcd762018-07-30 14:48:15 -0400134 const TextureSampler& onTextureSampler(int i) const override { return fSamplers[i]; }
Brian Salomonbc6b99d2017-01-11 10:32:34 -0500135
136 GrTAllocator<TextureSampler> fSamplers;
Brian Salomon587e08f2017-01-27 10:59:27 -0500137 typedef GrFragmentProcessor INHERITED;
Brian Salomonbc6b99d2017-01-11 10:32:34 -0500138};
139}
140
Brian Salomonf046e152017-01-11 15:24:47 -0500141template <typename T>
142inline void testingOnly_getIORefCnts(const T* resource, int* refCnt, int* readCnt, int* writeCnt) {
143 *refCnt = resource->fRefCnt;
144 *readCnt = resource->fPendingReads;
145 *writeCnt = resource->fPendingWrites;
Brian Salomonbc6b99d2017-01-11 10:32:34 -0500146}
147
Robert Phillips2f493142017-03-02 18:18:38 -0500148void testingOnly_getIORefCnts(GrTextureProxy* proxy, int* refCnt, int* readCnt, int* writeCnt) {
Robert Phillips30f9bc62017-02-22 15:28:38 -0500149 *refCnt = proxy->getBackingRefCnt_TestOnly();
150 *readCnt = proxy->getPendingReadCnt_TestOnly();
151 *writeCnt = proxy->getPendingWriteCnt_TestOnly();
152}
153
Brian Salomonbc6b99d2017-01-11 10:32:34 -0500154DEF_GPUTEST_FOR_ALL_CONTEXTS(ProcessorRefTest, reporter, ctxInfo) {
155 GrContext* context = ctxInfo.grContext();
Robert Phillips1afd4cd2018-01-08 13:40:32 -0500156 GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
Brian Salomonbc6b99d2017-01-11 10:32:34 -0500157
Robert Phillips16d8ec62017-07-27 16:16:25 -0400158 GrSurfaceDesc desc;
Brian Salomonbc6b99d2017-01-11 10:32:34 -0500159 desc.fWidth = 10;
160 desc.fHeight = 10;
Robert Phillips16d8ec62017-07-27 16:16:25 -0400161 desc.fConfig = kRGBA_8888_GrPixelConfig;
Brian Salomonbc6b99d2017-01-11 10:32:34 -0500162
Brian Salomonb17e6392017-07-28 13:41:51 -0400163 for (bool makeClone : {false, true}) {
164 for (int parentCnt = 0; parentCnt < 2; parentCnt++) {
165 sk_sp<GrRenderTargetContext> renderTargetContext(
Robert Phillips0c4b7b12018-03-06 08:20:37 -0500166 context->contextPriv().makeDeferredRenderTargetContext(
167 SkBackingFit::kApprox, 1, 1,
Brian Salomon2a4f9832018-03-03 22:43:43 -0500168 kRGBA_8888_GrPixelConfig, nullptr));
Brian Salomonbc6b99d2017-01-11 10:32:34 -0500169 {
Brian Salomon2a4f9832018-03-03 22:43:43 -0500170 sk_sp<GrTextureProxy> proxy1 = proxyProvider->createProxy(
171 desc, kTopLeft_GrSurfaceOrigin, SkBackingFit::kExact, SkBudgeted::kYes);
172 sk_sp<GrTextureProxy> proxy2 = proxyProvider->createProxy(
173 desc, kTopLeft_GrSurfaceOrigin, SkBackingFit::kExact, SkBudgeted::kYes);
174 sk_sp<GrTextureProxy> proxy3 = proxyProvider->createProxy(
175 desc, kTopLeft_GrSurfaceOrigin, SkBackingFit::kExact, SkBudgeted::kYes);
176 sk_sp<GrTextureProxy> proxy4 = proxyProvider->createProxy(
177 desc, kTopLeft_GrSurfaceOrigin, SkBackingFit::kExact, SkBudgeted::kYes);
Brian Salomonb17e6392017-07-28 13:41:51 -0400178 {
179 SkTArray<sk_sp<GrTextureProxy>> proxies;
180 SkTArray<sk_sp<GrBuffer>> buffers;
Brian Salomonb17e6392017-07-28 13:41:51 -0400181 proxies.push_back(proxy1);
Brian Salomon559f5562017-11-15 14:28:33 -0500182 auto fp = TestFP::Make(std::move(proxies), std::move(buffers));
Brian Salomonb17e6392017-07-28 13:41:51 -0400183 for (int i = 0; i < parentCnt; ++i) {
184 fp = TestFP::Make(std::move(fp));
185 }
Brian Salomonaff329b2017-08-11 09:40:37 -0400186 std::unique_ptr<GrFragmentProcessor> clone;
Brian Salomonb17e6392017-07-28 13:41:51 -0400187 if (makeClone) {
188 clone = fp->clone();
189 }
Robert Phillips7c525e62018-06-12 10:11:12 -0400190 std::unique_ptr<GrDrawOp> op(TestOp::Make(context, std::move(fp)));
Brian Salomonb17e6392017-07-28 13:41:51 -0400191 renderTargetContext->priv().testingOnly_addDrawOp(std::move(op));
192 if (clone) {
Robert Phillips7c525e62018-06-12 10:11:12 -0400193 op = TestOp::Make(context, std::move(clone));
Brian Salomonb17e6392017-07-28 13:41:51 -0400194 renderTargetContext->priv().testingOnly_addDrawOp(std::move(op));
195 }
196 }
197 int refCnt, readCnt, writeCnt;
198
199 testingOnly_getIORefCnts(proxy1.get(), &refCnt, &readCnt, &writeCnt);
200 // IO counts should be double if there is a clone of the FP.
201 int ioRefMul = makeClone ? 2 : 1;
Robert Phillips715d08c2018-07-18 13:56:48 -0400202 REPORTER_ASSERT(reporter, -1 == refCnt);
Brian Salomonb17e6392017-07-28 13:41:51 -0400203 REPORTER_ASSERT(reporter, ioRefMul * 1 == readCnt);
204 REPORTER_ASSERT(reporter, ioRefMul * 0 == writeCnt);
205
Brian Salomonb17e6392017-07-28 13:41:51 -0400206 context->flush();
207
208 testingOnly_getIORefCnts(proxy1.get(), &refCnt, &readCnt, &writeCnt);
209 REPORTER_ASSERT(reporter, 1 == refCnt);
210 REPORTER_ASSERT(reporter, ioRefMul * 0 == readCnt);
211 REPORTER_ASSERT(reporter, ioRefMul * 0 == writeCnt);
212
Brian Salomonbc6b99d2017-01-11 10:32:34 -0500213 }
214 }
215 }
216}
Brian Salomon587e08f2017-01-27 10:59:27 -0500217
218// This test uses the random GrFragmentProcessor test factory, which relies on static initializers.
219#if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
220
Brian Salomon0e05a822017-07-25 09:43:22 -0400221#include "SkCommandLineFlags.h"
222DEFINE_bool(randomProcessorTest, false, "Use non-deterministic seed for random processor tests?");
223
224#if GR_TEST_UTILS
225
226static GrColor input_texel_color(int i, int j) {
227 GrColor color = GrColorPackRGBA((uint8_t)j, (uint8_t)(i + j), (uint8_t)(2 * j - i), (uint8_t)i);
Brian Salomon587e08f2017-01-27 10:59:27 -0500228 return GrPremulColor(color);
229}
230
Brian Salomon0e05a822017-07-25 09:43:22 -0400231static GrColor4f input_texel_color4f(int i, int j) {
232 return GrColor4f::FromGrColor(input_texel_color(i, j));
233}
Brian Salomon587e08f2017-01-27 10:59:27 -0500234
Robert Phillips7c525e62018-06-12 10:11:12 -0400235void test_draw_op(GrContext* context,
236 GrRenderTargetContext* rtc,
237 std::unique_ptr<GrFragmentProcessor> fp,
Robert Phillips30f9bc62017-02-22 15:28:38 -0500238 sk_sp<GrTextureProxy> inputDataProxy) {
Brian Salomon5d4cd9e2017-02-09 11:16:46 -0500239 GrPaint paint;
Brian Osman2240be92017-10-18 13:15:13 -0400240 paint.addColorTextureProcessor(std::move(inputDataProxy), SkMatrix::I());
Brian Salomon5d4cd9e2017-02-09 11:16:46 -0500241 paint.addColorFragmentProcessor(std::move(fp));
242 paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
Brian Salomonac70f842017-05-08 10:43:33 -0400243
Robert Phillips7c525e62018-06-12 10:11:12 -0400244 auto op = GrRectOpFactory::MakeNonAAFill(context, std::move(paint), SkMatrix::I(),
Brian Salomonbaaf4392017-06-15 09:59:23 -0400245 SkRect::MakeWH(rtc->width(), rtc->height()),
246 GrAAType::kNone);
Brian Salomonac70f842017-05-08 10:43:33 -0400247 rtc->addDrawOp(GrNoClip(), std::move(op));
Brian Salomon5d4cd9e2017-02-09 11:16:46 -0500248}
249
Brian Salomon0e05a822017-07-25 09:43:22 -0400250/** Initializes the two test texture proxies that are available to the FP test factories. */
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500251bool init_test_textures(GrProxyProvider* proxyProvider, SkRandom* random,
252 sk_sp<GrTextureProxy> proxies[2]) {
Brian Salomon0e05a822017-07-25 09:43:22 -0400253 static const int kTestTextureSize = 256;
254 GrSurfaceDesc desc;
Brian Salomon0e05a822017-07-25 09:43:22 -0400255 desc.fWidth = kTestTextureSize;
256 desc.fHeight = kTestTextureSize;
257 desc.fConfig = kRGBA_8888_GrPixelConfig;
Brian Osmanc35a2d42017-03-17 10:58:53 -0400258
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500259 {
260 // Put premul data into the RGBA texture that the test FPs can optionally use.
261 std::unique_ptr<GrColor[]> rgbaData(new GrColor[kTestTextureSize * kTestTextureSize]);
262 for (int y = 0; y < kTestTextureSize; ++y) {
263 for (int x = 0; x < kTestTextureSize; ++x) {
264 rgbaData[kTestTextureSize * y + x] =
265 input_texel_color(random->nextULessThan(256), random->nextULessThan(256));
266 }
Brian Salomon0e05a822017-07-25 09:43:22 -0400267 }
Brian Salomon0e05a822017-07-25 09:43:22 -0400268
Brian Salomon58389b92018-03-07 13:01:25 -0500269 proxies[0] = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes, rgbaData.get(),
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500270 kTestTextureSize * sizeof(GrColor));
Brian Salomon0e05a822017-07-25 09:43:22 -0400271 }
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500272
273 {
274 // Put random values into the alpha texture that the test FPs can optionally use.
275 desc.fConfig = kAlpha_8_GrPixelConfig;
276 std::unique_ptr<uint8_t[]> alphaData(new uint8_t[kTestTextureSize * kTestTextureSize]);
277 for (int y = 0; y < kTestTextureSize; ++y) {
278 for (int x = 0; x < kTestTextureSize; ++x) {
279 alphaData[kTestTextureSize * y + x] = random->nextULessThan(256);
280 }
281 }
282
Brian Salomon58389b92018-03-07 13:01:25 -0500283 proxies[1] = proxyProvider->createTextureProxy(desc, SkBudgeted::kYes, alphaData.get(),
Brian Salomon2a4f9832018-03-03 22:43:43 -0500284 kTestTextureSize);
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500285 }
Brian Salomon0e05a822017-07-25 09:43:22 -0400286
287 return proxies[0] && proxies[1];
288}
289
290// Creates a texture of premul colors used as the output of the fragment processor that precedes
291// the fragment processor under test. Color values are those provided by input_texel_color().
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500292sk_sp<GrTextureProxy> make_input_texture(GrProxyProvider* proxyProvider, int width, int height) {
Brian Salomon0e05a822017-07-25 09:43:22 -0400293 std::unique_ptr<GrColor[]> data(new GrColor[width * height]);
294 for (int y = 0; y < width; ++y) {
295 for (int x = 0; x < height; ++x) {
296 data.get()[width * y + x] = input_texel_color(x, y);
297 }
298 }
299 GrSurfaceDesc desc;
Brian Salomon0e05a822017-07-25 09:43:22 -0400300 desc.fWidth = width;
301 desc.fHeight = height;
302 desc.fConfig = kRGBA_8888_GrPixelConfig;
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500303
Brian Salomon58389b92018-03-07 13:01:25 -0500304 return proxyProvider->createTextureProxy(desc, SkBudgeted::kYes, data.get(),
305 width * sizeof(GrColor));
Brian Salomon0e05a822017-07-25 09:43:22 -0400306}
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500307
Brian Salomon5d4cd9e2017-02-09 11:16:46 -0500308DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, reporter, ctxInfo) {
Brian Salomon587e08f2017-01-27 10:59:27 -0500309 GrContext* context = ctxInfo.grContext();
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500310 GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
Robert Phillips6be756b2018-01-16 15:07:54 -0500311 auto resourceProvider = context->contextPriv().resourceProvider();
Brian Salomon1c053642017-07-24 10:16:19 -0400312 using FPFactory = GrFragmentProcessorTestFactory;
Brian Osmanc35a2d42017-03-17 10:58:53 -0400313
314 uint32_t seed = 0;
315 if (FLAGS_randomProcessorTest) {
316 std::random_device rd;
317 seed = rd();
318 }
319 // If a non-deterministic bot fails this test, check the output to see what seed it used, then
320 // hard-code that value here:
321 SkRandom random(seed);
322
Brian Salomon0e05a822017-07-25 09:43:22 -0400323 // Make the destination context for the test.
324 static constexpr int kRenderSize = 256;
Robert Phillips0c4b7b12018-03-06 08:20:37 -0500325 sk_sp<GrRenderTargetContext> rtc = context->contextPriv().makeDeferredRenderTargetContext(
Brian Salomon0e05a822017-07-25 09:43:22 -0400326 SkBackingFit::kExact, kRenderSize, kRenderSize, kRGBA_8888_GrPixelConfig, nullptr);
Brian Salomond1a8bdf2017-02-10 12:39:26 -0500327
Robert Phillipse78b7252017-04-06 07:59:41 -0400328 sk_sp<GrTextureProxy> proxies[2];
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500329 if (!init_test_textures(proxyProvider, &random, proxies)) {
Brian Salomon0e05a822017-07-25 09:43:22 -0400330 ERRORF(reporter, "Could not create test textures");
Robert Phillipsbb581ce2017-05-29 15:05:15 -0400331 return;
332 }
Robert Phillipse78b7252017-04-06 07:59:41 -0400333 GrProcessorTestData testData(&random, context, rtc.get(), proxies);
Brian Salomon587e08f2017-01-27 10:59:27 -0500334
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500335 auto inputTexture = make_input_texture(proxyProvider, kRenderSize, kRenderSize);
Robert Phillips30f9bc62017-02-22 15:28:38 -0500336
Ben Wagner8c791942017-07-25 11:47:48 -0400337 std::unique_ptr<GrColor[]> readData(new GrColor[kRenderSize * kRenderSize]);
Brian Salomon0e05a822017-07-25 09:43:22 -0400338 // Because processor factories configure themselves in random ways, this is not exhaustive.
Brian Salomon587e08f2017-01-27 10:59:27 -0500339 for (int i = 0; i < FPFactory::Count(); ++i) {
340 int timesToInvokeFactory = 5;
341 // Increase the number of attempts if the FP has child FPs since optimizations likely depend
342 // on child optimizations being present.
Brian Salomonaff329b2017-08-11 09:40:37 -0400343 std::unique_ptr<GrFragmentProcessor> fp = FPFactory::MakeIdx(i, &testData);
Brian Salomon587e08f2017-01-27 10:59:27 -0500344 for (int j = 0; j < fp->numChildProcessors(); ++j) {
345 // This value made a reasonable trade off between time and coverage when this test was
346 // written.
347 timesToInvokeFactory *= FPFactory::Count() / 2;
348 }
349 for (int j = 0; j < timesToInvokeFactory; ++j) {
350 fp = FPFactory::MakeIdx(i, &testData);
Robert Phillips6be756b2018-01-16 15:07:54 -0500351 if (!fp->instantiate(resourceProvider)) {
Robert Phillipsa91e0b72017-05-01 13:12:20 -0400352 continue;
353 }
354
Brian Salomon587e08f2017-01-27 10:59:27 -0500355 if (!fp->hasConstantOutputForConstantInput() && !fp->preservesOpaqueInput() &&
Brian Salomonf3b995b2017-02-15 10:22:23 -0500356 !fp->compatibleWithCoverageAsAlpha()) {
Brian Salomon587e08f2017-01-27 10:59:27 -0500357 continue;
358 }
Brian Salomonaff329b2017-08-11 09:40:37 -0400359
360 // Since we transfer away ownership of the original FP, we make a clone.
361 auto clone = fp->clone();
362
Robert Phillips7c525e62018-06-12 10:11:12 -0400363 test_draw_op(context, rtc.get(), std::move(fp), inputTexture);
Brian Salomon0e05a822017-07-25 09:43:22 -0400364 memset(readData.get(), 0x0, sizeof(GrColor) * kRenderSize * kRenderSize);
365 rtc->readPixels(SkImageInfo::Make(kRenderSize, kRenderSize, kRGBA_8888_SkColorType,
366 kPremul_SkAlphaType),
367 readData.get(), 0, 0, 0);
Brian Salomon587e08f2017-01-27 10:59:27 -0500368 bool passing = true;
369 if (0) { // Useful to see what FPs are being tested.
370 SkString children;
Brian Salomonaff329b2017-08-11 09:40:37 -0400371 for (int c = 0; c < clone->numChildProcessors(); ++c) {
Brian Salomon587e08f2017-01-27 10:59:27 -0500372 if (!c) {
373 children.append("(");
374 }
Brian Salomonaff329b2017-08-11 09:40:37 -0400375 children.append(clone->name());
376 children.append(c == clone->numChildProcessors() - 1 ? ")" : ", ");
Brian Salomon587e08f2017-01-27 10:59:27 -0500377 }
Brian Salomonaff329b2017-08-11 09:40:37 -0400378 SkDebugf("%s %s\n", clone->name(), children.c_str());
Brian Salomon587e08f2017-01-27 10:59:27 -0500379 }
Brian Salomon0e05a822017-07-25 09:43:22 -0400380 for (int y = 0; y < kRenderSize && passing; ++y) {
381 for (int x = 0; x < kRenderSize && passing; ++x) {
382 GrColor input = input_texel_color(x, y);
383 GrColor output = readData.get()[y * kRenderSize + x];
Brian Salomonaff329b2017-08-11 09:40:37 -0400384 if (clone->compatibleWithCoverageAsAlpha()) {
Brian Salomon587e08f2017-01-27 10:59:27 -0500385 // A modulating processor is allowed to modulate either the input color or
386 // just the input alpha.
387 bool legalColorModulation =
388 GrColorUnpackA(output) <= GrColorUnpackA(input) &&
389 GrColorUnpackR(output) <= GrColorUnpackR(input) &&
390 GrColorUnpackG(output) <= GrColorUnpackG(input) &&
391 GrColorUnpackB(output) <= GrColorUnpackB(input);
392 bool legalAlphaModulation =
393 GrColorUnpackA(output) <= GrColorUnpackA(input) &&
394 GrColorUnpackR(output) <= GrColorUnpackA(input) &&
395 GrColorUnpackG(output) <= GrColorUnpackA(input) &&
396 GrColorUnpackB(output) <= GrColorUnpackA(input);
397 if (!legalColorModulation && !legalAlphaModulation) {
398 ERRORF(reporter,
399 "\"Modulating\" processor %s made color/alpha value larger. "
Greg Daniel10ed2432017-12-01 16:19:43 -0500400 "Input: 0x%08x, Output: 0x%08x, pixel (%d, %d).",
401 clone->name(), input, output, x, y);
Brian Salomon587e08f2017-01-27 10:59:27 -0500402 passing = false;
403 }
404 }
Brian Salomon0e05a822017-07-25 09:43:22 -0400405 GrColor4f input4f = input_texel_color4f(x, y);
Brian Salomon587e08f2017-01-27 10:59:27 -0500406 GrColor4f output4f = GrColor4f::FromGrColor(output);
407 GrColor4f expected4f;
Brian Salomonaff329b2017-08-11 09:40:37 -0400408 if (clone->hasConstantOutputForConstantInput(input4f, &expected4f)) {
Brian Salomon587e08f2017-01-27 10:59:27 -0500409 float rDiff = fabsf(output4f.fRGBA[0] - expected4f.fRGBA[0]);
410 float gDiff = fabsf(output4f.fRGBA[1] - expected4f.fRGBA[1]);
411 float bDiff = fabsf(output4f.fRGBA[2] - expected4f.fRGBA[2]);
412 float aDiff = fabsf(output4f.fRGBA[3] - expected4f.fRGBA[3]);
Brian Salomon5d4cd9e2017-02-09 11:16:46 -0500413 static constexpr float kTol = 4 / 255.f;
Brian Salomon587e08f2017-01-27 10:59:27 -0500414 if (rDiff > kTol || gDiff > kTol || bDiff > kTol || aDiff > kTol) {
415 ERRORF(reporter,
416 "Processor %s claimed output for const input doesn't match "
Brian Salomon5d4cd9e2017-02-09 11:16:46 -0500417 "actual output. Error: %f, Tolerance: %f, input: (%f, %f, %f, "
418 "%f), actual: (%f, %f, %f, %f), expected(%f, %f, %f, %f)",
Brian Salomonf61711a2018-02-16 10:44:28 -0500419 clone->name(),
420 SkTMax(rDiff, SkTMax(gDiff, SkTMax(bDiff, aDiff))), kTol,
421 input4f.fRGBA[0], input4f.fRGBA[1], input4f.fRGBA[2],
Brian Salomon5d4cd9e2017-02-09 11:16:46 -0500422 input4f.fRGBA[3], output4f.fRGBA[0], output4f.fRGBA[1],
423 output4f.fRGBA[2], output4f.fRGBA[3], expected4f.fRGBA[0],
424 expected4f.fRGBA[1], expected4f.fRGBA[2], expected4f.fRGBA[3]);
Brian Salomon587e08f2017-01-27 10:59:27 -0500425 passing = false;
426 }
427 }
Brian Salomonaff329b2017-08-11 09:40:37 -0400428 if (GrColorIsOpaque(input) && clone->preservesOpaqueInput() &&
Brian Salomon587e08f2017-01-27 10:59:27 -0500429 !GrColorIsOpaque(output)) {
430 ERRORF(reporter,
431 "Processor %s claimed opaqueness is preserved but it is not. Input: "
Brian Osman2f3865b2017-03-15 13:35:51 -0400432 "0x%08x, Output: 0x%08x.",
Brian Salomonaff329b2017-08-11 09:40:37 -0400433 clone->name(), input, output);
Brian Salomon587e08f2017-01-27 10:59:27 -0500434 passing = false;
435 }
Brian Osmanbd1f76f2017-03-15 11:33:12 -0400436 if (!passing) {
Brian Salomonaff329b2017-08-11 09:40:37 -0400437 ERRORF(reporter, "Seed: 0x%08x, Processor details: %s", seed,
438 clone->dumpInfo().c_str());
Brian Osmanbd1f76f2017-03-15 11:33:12 -0400439 }
Brian Salomon587e08f2017-01-27 10:59:27 -0500440 }
441 }
442 }
443 }
444}
Robert Phillips18166ee2017-06-01 12:55:44 -0400445
Brian Salomon0e05a822017-07-25 09:43:22 -0400446// Tests that fragment processors returned by GrFragmentProcessor::clone() are equivalent to their
447// progenitors.
448DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorCloneTest, reporter, ctxInfo) {
449 GrContext* context = ctxInfo.grContext();
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500450 GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
Robert Phillips6be756b2018-01-16 15:07:54 -0500451 auto resourceProvider = context->contextPriv().resourceProvider();
Brian Salomon0e05a822017-07-25 09:43:22 -0400452
453 SkRandom random;
454
455 // Make the destination context for the test.
456 static constexpr int kRenderSize = 1024;
Robert Phillips0c4b7b12018-03-06 08:20:37 -0500457 sk_sp<GrRenderTargetContext> rtc = context->contextPriv().makeDeferredRenderTargetContext(
Brian Salomon0e05a822017-07-25 09:43:22 -0400458 SkBackingFit::kExact, kRenderSize, kRenderSize, kRGBA_8888_GrPixelConfig, nullptr);
459
460 sk_sp<GrTextureProxy> proxies[2];
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500461 if (!init_test_textures(proxyProvider, &random, proxies)) {
Brian Salomon0e05a822017-07-25 09:43:22 -0400462 ERRORF(reporter, "Could not create test textures");
463 return;
464 }
465 GrProcessorTestData testData(&random, context, rtc.get(), proxies);
466
Robert Phillips0bd24dc2018-01-16 08:06:32 -0500467 auto inputTexture = make_input_texture(proxyProvider, kRenderSize, kRenderSize);
Brian Salomon0e05a822017-07-25 09:43:22 -0400468 std::unique_ptr<GrColor[]> readData1(new GrColor[kRenderSize * kRenderSize]);
469 std::unique_ptr<GrColor[]> readData2(new GrColor[kRenderSize * kRenderSize]);
470 auto readInfo = SkImageInfo::Make(kRenderSize, kRenderSize, kRGBA_8888_SkColorType,
471 kPremul_SkAlphaType);
472
473 // Because processor factories configure themselves in random ways, this is not exhaustive.
474 for (int i = 0; i < GrFragmentProcessorTestFactory::Count(); ++i) {
475 static constexpr int kTimesToInvokeFactory = 10;
476 for (int j = 0; j < kTimesToInvokeFactory; ++j) {
477 auto fp = GrFragmentProcessorTestFactory::MakeIdx(i, &testData);
478 auto clone = fp->clone();
Brian Salomon0e05a822017-07-25 09:43:22 -0400479 if (!clone) {
Brian Salomon96271cd2017-07-31 16:27:23 -0400480 ERRORF(reporter, "Clone of processor %s failed.", fp->name());
Brian Salomon0e05a822017-07-25 09:43:22 -0400481 continue;
482 }
Brian Salomonaff329b2017-08-11 09:40:37 -0400483 const char* name = fp->name();
Robert Phillips6be756b2018-01-16 15:07:54 -0500484 if (!fp->instantiate(resourceProvider) || !clone->instantiate(resourceProvider)) {
Brian Salomon0e05a822017-07-25 09:43:22 -0400485 continue;
486 }
Brian Salomonce06e262017-08-01 16:23:40 -0400487 REPORTER_ASSERT(reporter, !strcmp(fp->name(), clone->name()));
488 REPORTER_ASSERT(reporter, fp->compatibleWithCoverageAsAlpha() ==
489 clone->compatibleWithCoverageAsAlpha());
490 REPORTER_ASSERT(reporter, fp->isEqual(*clone));
491 REPORTER_ASSERT(reporter, fp->preservesOpaqueInput() == clone->preservesOpaqueInput());
492 REPORTER_ASSERT(reporter, fp->hasConstantOutputForConstantInput() ==
493 clone->hasConstantOutputForConstantInput());
494 REPORTER_ASSERT(reporter, fp->numChildProcessors() == clone->numChildProcessors());
495 REPORTER_ASSERT(reporter, fp->usesLocalCoords() == clone->usesLocalCoords());
Brian Salomon0e05a822017-07-25 09:43:22 -0400496 // Draw with original and read back the results.
Robert Phillips7c525e62018-06-12 10:11:12 -0400497 test_draw_op(context, rtc.get(), std::move(fp), inputTexture);
Brian Salomon0e05a822017-07-25 09:43:22 -0400498 memset(readData1.get(), 0x0, sizeof(GrColor) * kRenderSize * kRenderSize);
499 rtc->readPixels(readInfo, readData1.get(), 0, 0, 0);
500
501 // Draw with clone and read back the results.
Robert Phillips7c525e62018-06-12 10:11:12 -0400502 test_draw_op(context, rtc.get(), std::move(clone), inputTexture);
Brian Salomon0e05a822017-07-25 09:43:22 -0400503 memset(readData2.get(), 0x0, sizeof(GrColor) * kRenderSize * kRenderSize);
504 rtc->readPixels(readInfo, readData2.get(), 0, 0, 0);
505
506 // Check that the results are the same.
507 bool passing = true;
508 for (int y = 0; y < kRenderSize && passing; ++y) {
509 for (int x = 0; x < kRenderSize && passing; ++x) {
510 int idx = y * kRenderSize + x;
511 if (readData1[idx] != readData2[idx]) {
512 ERRORF(reporter,
513 "Processor %s made clone produced different output. "
514 "Input color: 0x%08x, Original Output Color: 0x%08x, "
515 "Clone Output Color: 0x%08x..",
Brian Salomonaff329b2017-08-11 09:40:37 -0400516 name, input_texel_color(x, y), readData1[idx], readData2[idx]);
Brian Salomon0e05a822017-07-25 09:43:22 -0400517 passing = false;
518 }
519 }
520 }
521 }
522 }
523}
524
Hal Canary6f6961e2017-01-31 13:50:44 -0500525#endif // GR_TEST_UTILS
526#endif // SK_ALLOW_STATIC_GLOBAL_INITIALIZERS