Revert of Make NVPR a GL context option instead of a GL context (patchset #2 id:20001 of https://codereview.chromium.org/1448883002/ )
Reason for revert:
BUG=skia:4609
skbug.com/4609
Seems like GrContextFactory needs to fail when the NVPR option is requested but the driver version isn't sufficiently high.
Original issue's description:
> Make NVPR a GL context option instead of a GL context
>
> Make NVPR a GL context option instead of a GL context.
> This may enable NVPR to be run with command buffer
> interface.
>
> No functionality change in DM or nanobench. NVPR can
> only be run with normal GL APIs.
>
> BUG=skia:2992
>
> Committed: https://skia.googlesource.com/skia/+/eeebdb538d476c1bfc8b63a946094ca1b505ecd1
TBR=mtklein@google.com,jvanverth@google.com,kkinnunen@nvidia.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:2992
Review URL: https://codereview.chromium.org/1486153002
diff --git a/bench/nanobench.cpp b/bench/nanobench.cpp
index f742ef9..ee6e385 100644
--- a/bench/nanobench.cpp
+++ b/bench/nanobench.cpp
@@ -169,13 +169,10 @@
uint32_t flags = this->config.useDFText ? SkSurfaceProps::kUseDeviceIndependentFonts_Flag :
0;
SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
- this->surface.reset(SkSurface::NewRenderTarget(gGrFactory->get(this->config.ctxType,
- kNone_GrGLStandard,
- this->config.ctxOptions),
+ this->surface.reset(SkSurface::NewRenderTarget(gGrFactory->get(this->config.ctxType),
SkSurface::kNo_Budgeted, info,
this->config.samples, &props));
- this->gl = gGrFactory->getContextInfo(this->config.ctxType, kNone_GrGLStandard,
- this->config.ctxOptions)->fGLContext;
+ this->gl = gGrFactory->getContextInfo(this->config.ctxType)->fGLContext;
if (!this->surface.get()) {
return false;
}
@@ -387,12 +384,11 @@
#if SK_SUPPORT_GPU
static bool is_gpu_config_allowed(const char* name, GrContextFactory::GLContextType ctxType,
- GrContextFactory::GLContextOptions ctxOptions,
int sampleCnt) {
if (!is_cpu_config_allowed(name)) {
return false;
}
- if (const GrContext* ctx = gGrFactory->get(ctxType, kNone_GrGLStandard, ctxOptions)) {
+ if (const GrContext* ctx = gGrFactory->get(ctxType)) {
return sampleCnt <= ctx->caps()->maxSampleCount();
}
return false;
@@ -401,20 +397,17 @@
#if SK_SUPPORT_GPU
#define kBogusGLContextType GrContextFactory::kNative_GLContextType
-#define kBogusGLContextOptions GrContextFactory::kNone_GLContextOptions
#else
#define kBogusGLContextType 0
-#define kBogusGLContextOptions 0
#endif
// Append all configs that are enabled and supported.
static void create_configs(SkTDArray<Config>* configs) {
- #define CPU_CONFIG(name, backend, color, alpha) \
- if (is_cpu_config_allowed(#name)) { \
- Config config = { #name, Benchmark::backend, color, alpha, 0, \
- kBogusGLContextType, kBogusGLContextOptions, \
- false }; \
- configs->push(config); \
+ #define CPU_CONFIG(name, backend, color, alpha) \
+ if (is_cpu_config_allowed(#name)) { \
+ Config config = { #name, Benchmark::backend, color, alpha, 0, \
+ kBogusGLContextType, false }; \
+ configs->push(config); \
}
if (FLAGS_cpu) {
@@ -424,9 +417,8 @@
}
#if SK_SUPPORT_GPU
- #define GPU_CONFIG(name, ctxType, ctxOptions, samples, useDFText) \
- if (is_gpu_config_allowed(#name, GrContextFactory::ctxType, \
- GrContextFactory::ctxOptions, samples)) { \
+ #define GPU_CONFIG(name, ctxType, samples, useDFText) \
+ if (is_gpu_config_allowed(#name, GrContextFactory::ctxType, samples)) { \
Config config = { \
#name, \
Benchmark::kGPU_Backend, \
@@ -434,29 +426,28 @@
kPremul_SkAlphaType, \
samples, \
GrContextFactory::ctxType, \
- GrContextFactory::ctxOptions, \
useDFText }; \
configs->push(config); \
}
if (FLAGS_gpu) {
- GPU_CONFIG(gpu, kNative_GLContextType, kNone_GLContextOptions, 0, false)
- GPU_CONFIG(msaa4, kNative_GLContextType, kNone_GLContextOptions, 4, false)
- GPU_CONFIG(msaa16, kNative_GLContextType, kNone_GLContextOptions, 16, false)
- GPU_CONFIG(nvprmsaa4, kNative_GLContextType, kEnableNVPR_GLContextOptions, 4, false)
- GPU_CONFIG(nvprmsaa16, kNative_GLContextType, kEnableNVPR_GLContextOptions, 16, false)
- GPU_CONFIG(gpudft, kNative_GLContextType, kNone_GLContextOptions, 0, true)
- GPU_CONFIG(debug, kDebug_GLContextType, kNone_GLContextOptions, 0, false)
- GPU_CONFIG(nullgpu, kNull_GLContextType, kNone_GLContextOptions, 0, false)
+ GPU_CONFIG(gpu, kNative_GLContextType, 0, false)
+ GPU_CONFIG(msaa4, kNative_GLContextType, 4, false)
+ GPU_CONFIG(msaa16, kNative_GLContextType, 16, false)
+ GPU_CONFIG(nvprmsaa4, kNVPR_GLContextType, 4, false)
+ GPU_CONFIG(nvprmsaa16, kNVPR_GLContextType, 16, false)
+ GPU_CONFIG(gpudft, kNative_GLContextType, 0, true)
+ GPU_CONFIG(debug, kDebug_GLContextType, 0, false)
+ GPU_CONFIG(nullgpu, kNull_GLContextType, 0, false)
#ifdef SK_ANGLE
- GPU_CONFIG(angle, kANGLE_GLContextType, kNone_GLContextOptions, 0, false)
- GPU_CONFIG(angle-gl, kANGLE_GL_GLContextType, kNone_GLContextOptions, 0, false)
+ GPU_CONFIG(angle, kANGLE_GLContextType, 0, false)
+ GPU_CONFIG(angle-gl, kANGLE_GL_GLContextType, 0, false)
#endif
#ifdef SK_COMMAND_BUFFER
- GPU_CONFIG(commandbuffer, kCommandBuffer_GLContextType, kNone_GLContextOptions, 0, false)
+ GPU_CONFIG(commandbuffer, kCommandBuffer_GLContextType, 0, false)
#endif
#if SK_MESA
- GPU_CONFIG(mesa, kMESA_GLContextType, kNone_GLContextOptions, 0, false)
+ GPU_CONFIG(mesa, kMESA_GLContextType, 0, false)
#endif
}
#endif
@@ -1253,10 +1244,8 @@
#if SK_SUPPORT_GPU
if (FLAGS_gpuStats &&
Benchmark::kGPU_Backend == configs[i].backend) {
- GrContext* context = gGrFactory->get(configs[i].ctxType,
- kNone_GrGLStandard, configs[i].ctxOptions);
- context->printCacheStats();
- context->printGpuStats();
+ gGrFactory->get(configs[i].ctxType)->printCacheStats();
+ gGrFactory->get(configs[i].ctxType)->printGpuStats();
}
#endif
if (FLAGS_verbose) {
diff --git a/bench/nanobench.h b/bench/nanobench.h
index 2dac30a..36f5ad5 100644
--- a/bench/nanobench.h
+++ b/bench/nanobench.h
@@ -29,11 +29,9 @@
int samples;
#if SK_SUPPORT_GPU
GrContextFactory::GLContextType ctxType;
- GrContextFactory::GLContextOptions ctxOptions;
bool useDFText;
#else
int bogusInt;
- int bogusIntOption;
bool bogusBool;
#endif
};
diff --git a/dm/DM.cpp b/dm/DM.cpp
index 6549af5..7497161 100644
--- a/dm/DM.cpp
+++ b/dm/DM.cpp
@@ -609,8 +609,8 @@
SINK("gpudft", GPUSink, Gr::kNative_GLContextType, api, 0, true, FLAGS_gpu_threading);
SINK("msaa4", GPUSink, Gr::kNative_GLContextType, api, 4, false, FLAGS_gpu_threading);
SINK("msaa16", GPUSink, Gr::kNative_GLContextType, api, 16, false, FLAGS_gpu_threading);
- SINK("nvprmsaa4", GPUSink, Gr::kNative_GLContextType, Gr::kEnableNVPR_GLContextOptions, api, 4, true, FLAGS_gpu_threading);
- SINK("nvprmsaa16", GPUSink, Gr::kNative_GLContextType, Gr::kEnableNVPR_GLContextOptions, api, 16, true, FLAGS_gpu_threading);
+ SINK("nvprmsaa4", GPUSink, Gr::kNVPR_GLContextType, api, 4, true, FLAGS_gpu_threading);
+ SINK("nvprmsaa16", GPUSink, Gr::kNVPR_GLContextType, api, 16, true, FLAGS_gpu_threading);
#if SK_ANGLE
SINK("angle", GPUSink, Gr::kANGLE_GLContextType, api, 0, false, FLAGS_gpu_threading);
SINK("angle-gl", GPUSink, Gr::kANGLE_GL_GLContextType, api, 0, false, FLAGS_gpu_threading);
@@ -1171,7 +1171,6 @@
void RunWithGPUTestContexts(T test, GPUTestContexts testContexts, Reporter* reporter,
GrContextFactory* factory) {
#if SK_SUPPORT_GPU
- const GrGLStandard api = get_gpu_api();
for (int i = 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
int contextSelector = kNone_GPUTestContexts;
@@ -1187,12 +1186,7 @@
if ((testContexts & contextSelector) == 0) {
continue;
}
- if (GrContextFactory::ContextInfo* context = factory->getContextInfo(glCtxType, api)) {
- call_test(test, reporter, context);
- }
- if (GrContextFactory::ContextInfo* context =
- factory->getContextInfo(glCtxType, api,
- GrContextFactory::kEnableNVPR_GLContextOptions)) {
+ if (GrContextFactory::ContextInfo* context = factory->getContextInfo(glCtxType)) {
call_test(test, reporter, context);
}
}
diff --git a/dm/DMGpuSupport.h b/dm/DMGpuSupport.h
index 6a59558..9f20dd5 100644
--- a/dm/DMGpuSupport.h
+++ b/dm/DMGpuSupport.h
@@ -26,14 +26,13 @@
static inline SkSurface* NewGpuSurface(GrContextFactory* grFactory,
GrContextFactory::GLContextType type,
- GrContextFactory::GLContextOptions options,
GrGLStandard gpuAPI,
SkImageInfo info,
int samples,
bool useDIText) {
uint32_t flags = useDIText ? SkSurfaceProps::kUseDeviceIndependentFonts_Flag : 0;
SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
- return SkSurface::NewRenderTarget(grFactory->get(type, gpuAPI, options), SkSurface::kNo_Budgeted,
+ return SkSurface::NewRenderTarget(grFactory->get(type, gpuAPI), SkSurface::kNo_Budgeted,
info, samples, &props);
}
@@ -77,10 +76,6 @@
kNative_GLContextType = 0,
kNull_GLContextType = 0;
static const int kGLContextTypeCnt = 1;
- enum GLContextOptions {
- kNone_GLContextOptions = 0,
- kEnableNVPR_GLContextOptions = 0x1,
- };
void destroyContexts() {}
void abandonContexts() {}
@@ -92,7 +87,6 @@
static inline SkSurface* NewGpuSurface(GrContextFactory*,
GrContextFactory::GLContextType,
- GrContextFactory::GLContextOptions,
GrGLStandard,
SkImageInfo,
int,
diff --git a/dm/DMSrcSink.cpp b/dm/DMSrcSink.cpp
index 365ebc2..2861ae8 100644
--- a/dm/DMSrcSink.cpp
+++ b/dm/DMSrcSink.cpp
@@ -789,26 +789,12 @@
DEFINE_bool(gpuStats, false, "Append GPU stats to the log for each GPU task?");
GPUSink::GPUSink(GrContextFactory::GLContextType ct,
- GrGLStandard gpuAPI,
+ GrGLStandard api,
int samples,
bool diText,
bool threaded)
: fContextType(ct)
- , fContextOptions(GrContextFactory::kNone_GLContextOptions)
- , fGpuAPI(gpuAPI)
- , fSampleCount(samples)
- , fUseDIText(diText)
- , fThreaded(threaded) {}
-
-GPUSink::GPUSink(GrContextFactory::GLContextType ct,
- GrContextFactory::GLContextOptions options,
- GrGLStandard gpuAPI,
- int samples,
- bool diText,
- bool threaded)
- : fContextType(ct)
- , fContextOptions(options)
- , fGpuAPI(gpuAPI)
+ , fGpuAPI(api)
, fSampleCount(samples)
, fUseDIText(diText)
, fThreaded(threaded) {}
@@ -823,21 +809,21 @@
DEFINE_bool(batchClip, false, "Clip each GrBatch to its device bounds for testing.");
Error GPUSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString* log) const {
- GrContextOptions grOptions;
+ GrContextOptions options;
if (FLAGS_imm) {
- grOptions.fImmediateMode = true;
+ options.fImmediateMode = true;
}
if (FLAGS_batchClip) {
- grOptions.fClipBatchToBounds = true;
+ options.fClipBatchToBounds = true;
}
- src.modifyGrContextOptions(&grOptions);
+ src.modifyGrContextOptions(&options);
- GrContextFactory factory(grOptions);
+ GrContextFactory factory(options);
const SkISize size = src.size();
const SkImageInfo info =
SkImageInfo::Make(size.width(), size.height(), kN32_SkColorType, kPremul_SkAlphaType);
SkAutoTUnref<SkSurface> surface(
- NewGpuSurface(&factory, fContextType, fContextOptions, fGpuAPI, info, fSampleCount, fUseDIText));
+ NewGpuSurface(&factory, fContextType, fGpuAPI, info, fSampleCount, fUseDIText));
if (!surface) {
return "Could not create a surface.";
}
diff --git a/dm/DMSrcSink.h b/dm/DMSrcSink.h
index 63d6717..e155508 100644
--- a/dm/DMSrcSink.h
+++ b/dm/DMSrcSink.h
@@ -214,22 +214,18 @@
class GPUSink : public Sink {
public:
- GPUSink(GrContextFactory::GLContextType, GrGLStandard, int samples,
- bool diText, bool threaded);
- GPUSink(GrContextFactory::GLContextType, GrContextFactory::GLContextOptions,
- GrGLStandard, int samples, bool diText, bool threaded);
+ GPUSink(GrContextFactory::GLContextType, GrGLStandard, int samples, bool diText, bool threaded);
Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
int enclave() const override;
const char* fileExtension() const override { return "png"; }
SinkFlags flags() const override { return SinkFlags{ SinkFlags::kGPU, SinkFlags::kDirect }; }
private:
- GrContextFactory::GLContextType fContextType;
- GrContextFactory::GLContextOptions fContextOptions;
- GrGLStandard fGpuAPI;
- int fSampleCount;
- bool fUseDIText;
- bool fThreaded;
+ GrContextFactory::GLContextType fContextType;
+ GrGLStandard fGpuAPI;
+ int fSampleCount;
+ bool fUseDIText;
+ bool fThreaded;
};
class PDFSink : public Sink {
diff --git a/src/gpu/GrContextFactory.cpp b/src/gpu/GrContextFactory.cpp
index 19382ee..424b3fd 100755
--- a/src/gpu/GrContextFactory.cpp
+++ b/src/gpu/GrContextFactory.cpp
@@ -24,21 +24,21 @@
#include "GrCaps.h"
GrContextFactory::ContextInfo* GrContextFactory::getContextInfo(GLContextType type,
- GrGLStandard forcedGpuAPI,
- GLContextOptions options) {
+ GrGLStandard forcedGpuAPI) {
for (int i = 0; i < fContexts.count(); ++i) {
- if (fContexts[i]->fType == type &&
- fContexts[i]->fOptions == options &&
- (forcedGpuAPI == kNone_GrGLStandard ||
- forcedGpuAPI == fContexts[i]->fGLContext->gl()->fStandard)) {
+ if (forcedGpuAPI != kNone_GrGLStandard &&
+ forcedGpuAPI != fContexts[i]->fGLContext->gl()->fStandard)
+ continue;
+
+ if (fContexts[i]->fType == type) {
fContexts[i]->fGLContext->makeCurrent();
return fContexts[i];
}
}
-
SkAutoTUnref<SkGLContext> glCtx;
SkAutoTUnref<GrContext> grCtx;
switch (type) {
+ case kNVPR_GLContextType: // fallthru
case kNative_GLContextType:
glCtx.reset(SkCreatePlatformGLContext(forcedGpuAPI));
break;
@@ -75,7 +75,7 @@
// Block NVPR from non-NVPR types.
SkAutoTUnref<const GrGLInterface> glInterface(SkRef(glCtx->gl()));
- if (!(kEnableNVPR_GLContextOptions & options)) {
+ if (kNVPR_GLContextType != type) {
glInterface.reset(GrGLInterfaceRemoveNVPR(glInterface));
if (!glInterface) {
return nullptr;
@@ -97,7 +97,7 @@
return nullptr;
}
// Warn if path rendering support is not available for the NVPR type.
- if (kEnableNVPR_GLContextOptions & options) {
+ if (kNVPR_GLContextType == type) {
if (!grCtx->caps()->shaderCaps()->pathRenderingSupport()) {
GrGpu* gpu = grCtx->getGpu();
const GrGLContext* ctx = gpu->glContextForTesting();
@@ -119,6 +119,5 @@
ctx->fGLContext = SkRef(glCtx.get());
ctx->fGrContext = SkRef(grCtx.get());
ctx->fType = type;
- ctx->fOptions = options;
return ctx;
}
diff --git a/src/gpu/GrContextFactory.h b/src/gpu/GrContextFactory.h
index 3a71d80..c837e74 100644
--- a/src/gpu/GrContextFactory.h
+++ b/src/gpu/GrContextFactory.h
@@ -23,34 +23,35 @@
*/
class GrContextFactory : SkNoncopyable {
public:
+ /**
+ * Types of GL contexts supported. For historical and testing reasons the native GrContext will
+ * not use "GL_NV_path_rendering" even when the driver supports it. There is a separate context
+ * type that does not remove NVPR support and which will fail when the driver does not support
+ * the extension.
+ */
enum GLContextType {
- kNative_GLContextType,
+ kNative_GLContextType,
#if SK_ANGLE
- kANGLE_GLContextType,
- kANGLE_GL_GLContextType,
+ kANGLE_GLContextType,
+ kANGLE_GL_GLContextType,
#endif
#if SK_COMMAND_BUFFER
- kCommandBuffer_GLContextType,
+ kCommandBuffer_GLContextType,
#endif
#if SK_MESA
- kMESA_GLContextType,
+ kMESA_GLContextType,
#endif
- kNull_GLContextType,
- kDebug_GLContextType,
- kLastGLContextType = kDebug_GLContextType
+ /** Similar to kNative but does not filter NVPR. It will fail if the GL driver does not
+ support NVPR */
+ kNVPR_GLContextType,
+ kNull_GLContextType,
+ kDebug_GLContextType,
+
+ kLastGLContextType = kDebug_GLContextType
};
static const int kGLContextTypeCnt = kLastGLContextType + 1;
- /**
- * Options for GL context creation. For historical and testing reasons the options will default
- * to not using GL_NV_path_rendering extension even when the driver supports it.
- */
- enum GLContextOptions {
- kNone_GLContextOptions = 0,
- kEnableNVPR_GLContextOptions = 0x1,
- };
-
static bool IsRenderingGLContext(GLContextType type) {
switch (type) {
case kNull_GLContextType:
@@ -81,6 +82,8 @@
case kMESA_GLContextType:
return "mesa";
#endif
+ case kNVPR_GLContextType:
+ return "nvpr";
case kDebug_GLContextType:
return "debug";
default:
@@ -116,7 +119,6 @@
struct ContextInfo {
GLContextType fType;
- GLContextOptions fOptions;
SkGLContext* fGLContext;
GrContext* fGrContext;
};
@@ -124,14 +126,13 @@
* Get a context initialized with a type of GL context. It also makes the GL context current.
* Pointer is valid until destroyContexts() is called.
*/
- ContextInfo* getContextInfo(GLContextType type, GrGLStandard forcedGpuAPI = kNone_GrGLStandard, GLContextOptions options = kNone_GLContextOptions);
+ ContextInfo* getContextInfo(GLContextType type, GrGLStandard forcedGpuAPI = kNone_GrGLStandard);
/**
* Get a GrContext initialized with a type of GL context. It also makes the GL context current.
*/
- GrContext* get(GLContextType type, GrGLStandard forcedGpuAPI = kNone_GrGLStandard,
- GLContextOptions options = kNone_GLContextOptions) {
- if (ContextInfo* info = this->getContextInfo(type, forcedGpuAPI, options)) {
+ GrContext* get(GLContextType type, GrGLStandard forcedGpuAPI = kNone_GrGLStandard) {
+ if (ContextInfo* info = this->getContextInfo(type, forcedGpuAPI)) {
return info->fGrContext;
}
return nullptr;
diff --git a/tests/GLInterfaceValidationTest.cpp b/tests/GLInterfaceValidationTest.cpp
index b890b44..5736e2d 100755
--- a/tests/GLInterfaceValidationTest.cpp
+++ b/tests/GLInterfaceValidationTest.cpp
@@ -12,33 +12,28 @@
#include "GrContextFactory.h"
-DEF_GPUTEST(GLInterfaceValidation, reporter, /*factory*/) {
- GrContextFactory testFactory;
+DEF_GPUTEST(GLInterfaceValidation, reporter, factory) {
+ for (int i = 0; i <= GrContextFactory::kLastGLContextType; ++i) {
+ GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType)i;
+ // this forces the factory to make the context if it hasn't yet
+ GrContextFactory::ContextInfo* contextInfo = factory->getContextInfo(glCtxType);
+ SkGLContext* glCtx = contextInfo ? contextInfo->fGLContext : nullptr;
- // Test that if we do not have NV_path_rendering -related GL extensions,
- // GrContextFactory::get(.., kEnableNVPR_GLContextOptions) always returns nullptr.
- for (int i = 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
- GrContextFactory::GLContextType glCtxType = static_cast<GrContextFactory::GLContextType>(i);
- GrContextFactory::ContextInfo* context =
- testFactory.getContextInfo(glCtxType, kNone_GrGLStandard,
- GrContextFactory::kNone_GLContextOptions);
- if (!context) {
+ // We're supposed to fail the NVPR context type when we the native context that does not
+ // support the NVPR extension.
+ if (GrContextFactory::kNVPR_GLContextType == glCtxType &&
+ factory->getContextInfo(GrContextFactory::kNative_GLContextType) &&
+ !factory->getContextInfo(GrContextFactory::kNative_GLContextType)->fGLContext->gl()->hasExtension("GL_NV_path_rendering")) {
+ REPORTER_ASSERT(reporter, nullptr == glCtx);
continue;
}
- SkGLContext* glContext = context->fGLContext;
- REPORTER_ASSERT(reporter, glContext->gl()->validate());
-
- if (!(glContext->gl()->hasExtension("GL_NV_path_rendering") ||
- glContext->gl()->hasExtension("GL_CHROMIUM_path_rendering"))) {
- REPORTER_ASSERT(reporter,
- nullptr == testFactory.getContextInfo(
- glCtxType,
- kNone_GrGLStandard,
- GrContextFactory::kEnableNVPR_GLContextOptions));
+ REPORTER_ASSERT(reporter, glCtx);
+ if (glCtx) {
+ const GrGLInterface* interface = glCtx->gl();
+ REPORTER_ASSERT(reporter, interface->validate());
}
}
-
}
#endif
diff --git a/tests/GrContextFactoryTest.cpp b/tests/GrContextFactoryTest.cpp
index ad83a34..79209c7 100644
--- a/tests/GrContextFactoryTest.cpp
+++ b/tests/GrContextFactoryTest.cpp
@@ -10,24 +10,8 @@
#if SK_SUPPORT_GPU
#include "GrContextFactory.h"
-#include "GrCaps.h"
#include "Test.h"
-DEF_GPUTEST(GrContextFactoryNVPRContextOptions, reporter, /*factory*/) {
- GrContextFactory testFactory;
- // Test that if NVPR is possible, caps are in sync.
- for (int i = 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
- GrContextFactory::GLContextType glCtxType = static_cast<GrContextFactory::GLContextType>(i);
- GrContext* context = testFactory.get(glCtxType,
- kNone_GrGLStandard,
- GrContextFactory::kEnableNVPR_GLContextOptions);
- if (!context) {
- continue;
- }
- REPORTER_ASSERT(
- reporter,
- context->caps()->shaderCaps()->pathRenderingSupport());
- }
-}
+// TODO: test GrContextFactory.
#endif
diff --git a/tools/PictureRenderer.h b/tools/PictureRenderer.h
deleted file mode 100644
index 63043a0..0000000
--- a/tools/PictureRenderer.h
+++ /dev/null
@@ -1,707 +0,0 @@
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef PictureRenderer_DEFINED
-#define PictureRenderer_DEFINED
-
-#include "SkCanvas.h"
-#include "SkDrawFilter.h"
-#include "SkJSONCPP.h"
-#include "SkMath.h"
-#include "SkPaint.h"
-#include "SkPicture.h"
-#include "SkPictureRecorder.h"
-#include "SkRect.h"
-#include "SkRefCnt.h"
-#include "SkString.h"
-#include "SkTDArray.h"
-#include "SkTypes.h"
-
-#if SK_SUPPORT_GPU
-#include "GrContextFactory.h"
-#include "GrContext.h"
-#endif
-
-struct GrContextOptions;
-class SkBitmap;
-class SkCanvas;
-class SkGLContext;
-class SkThread;
-
-namespace sk_tools {
-
-class TiledPictureRenderer;
-
-class PictureRenderer : public SkRefCnt {
-
-public:
- enum SkDeviceTypes {
-#if SK_ANGLE
- kAngle_DeviceType,
-#endif
-#if SK_COMMAND_BUFFER
- kCommandBuffer_DeviceType,
-#endif
-#if SK_MESA
- kMesa_DeviceType,
-#endif
- kBitmap_DeviceType,
-#if SK_SUPPORT_GPU
- kGPU_DeviceType,
- kNVPR_DeviceType,
-#endif
- };
-
- enum BBoxHierarchyType {
- kNone_BBoxHierarchyType = 0,
- kRTree_BBoxHierarchyType,
-
- kLast_BBoxHierarchyType = kRTree_BBoxHierarchyType,
- };
-
- // this uses SkPaint::Flags as a base and adds additional flags
- enum DrawFilterFlags {
- kNone_DrawFilterFlag = 0,
- kHinting_DrawFilterFlag = 0x10000, // toggles between no hinting and normal hinting
- kSlightHinting_DrawFilterFlag = 0x20000, // toggles between slight and normal hinting
- kAAClip_DrawFilterFlag = 0x40000, // toggles between soft and hard clip
- kMaskFilter_DrawFilterFlag = 0x80000, // toggles on/off mask filters (e.g., blurs)
- };
-
- static_assert(!(kMaskFilter_DrawFilterFlag & SkPaint::kAllFlags),
- "maskfilter_flag_must_be_greater");
- static_assert(!(kHinting_DrawFilterFlag & SkPaint::kAllFlags),
- "hinting_flag_must_be_greater");
- static_assert(!(kSlightHinting_DrawFilterFlag & SkPaint::kAllFlags),
- "slight_hinting_flag_must_be_greater");
-
- /**
- * Called with each new SkPicture to render.
- *
- * @param pict The SkPicture to render.
- * @param writePath The output directory within which this renderer should write all images,
- * or nullptr if this renderer should not write all images.
- * @param mismatchPath The output directory within which this renderer should write any images
- * which do not match expectations, or nullptr if this renderer should not write mismatches.
- * @param inputFilename The name of the input file we are rendering.
- * @param useChecksumBasedFilenames Whether to use checksum-based filenames when writing
- * bitmap images to disk.
- * @param useMultiPictureDraw true if MultiPictureDraw should be used for rendering
- */
- virtual void init(const SkPicture* pict,
- const SkString* writePath,
- const SkString* mismatchPath,
- const SkString* inputFilename,
- bool useChecksumBasedFilenames,
- bool useMultiPictureDraw);
-
- /**
- * Set the viewport so that only the portion listed gets drawn.
- */
- void setViewport(SkISize size) { fViewport = size; }
-
- /**
- * Set the scale factor at which draw the picture.
- */
- void setScaleFactor(SkScalar scale) { fScaleFactor = scale; }
-
- /**
- * Perform any setup that should done prior to each iteration of render() which should not be
- * timed.
- */
- virtual void setup() {}
-
- /**
- * Perform the work. If this is being called within the context of bench_pictures,
- * this is the step that will be timed.
- *
- * Typically "the work" is rendering an SkPicture into a bitmap, but in some subclasses
- * it is recording the source SkPicture into another SkPicture.
- *
- * If fWritePath has been specified, the result of the work will be written to that dir.
- * If fMismatchPath has been specified, and the actual image result differs from its
- * expectation, the result of the work will be written to that dir.
- *
- * @param out If non-null, the implementing subclass MAY allocate an SkBitmap, copy the
- * output image into it, and return it here. (Some subclasses ignore this parameter)
- * @return bool True if rendering succeeded and, if fWritePath had been specified, the output
- * was successfully written to a file.
- */
- virtual bool render(SkBitmap** out = nullptr) = 0;
-
- /**
- * Called once finished with a particular SkPicture, before calling init again, and before
- * being done with this Renderer.
- */
- virtual void end();
-
- /**
- * If this PictureRenderer is actually a TiledPictureRender, return a pointer to this as a
- * TiledPictureRender so its methods can be called.
- */
- virtual TiledPictureRenderer* getTiledRenderer() { return nullptr; }
-
- /**
- * Resets the GPU's state. Does nothing if the backing is raster. For a GPU renderer, calls
- * flush, swapBuffers and, if callFinish is true, finish.
- * @param callFinish Whether to call finish.
- */
- void resetState(bool callFinish);
-
- /**
- * Remove all decoded textures from the CPU caches and all uploaded textures
- * from the GPU.
- */
- void purgeTextures();
-
- /**
- * Set the backend type. Returns true on success and false on failure.
- */
-#if SK_SUPPORT_GPU
- bool setDeviceType(SkDeviceTypes deviceType, GrGLStandard gpuAPI = kNone_GrGLStandard) {
-#else
- bool setDeviceType(SkDeviceTypes deviceType) {
-#endif
- fDeviceType = deviceType;
-#if SK_SUPPORT_GPU
- // In case this function is called more than once
- fGrContext.reset();
- fGLContext.reset();
-
- // Set to Native so it will have an initial value.
- GrContextFactory::GLContextType glContextType = GrContextFactory::kNative_GLContextType;
- GrContextFactory::GLContextType glContextOptions = GrContextFactory::kNone_GLContextOptions;
-#endif
- switch(deviceType) {
- case kBitmap_DeviceType:
- return true;
-#if SK_SUPPORT_GPU
- case kGPU_DeviceType:
- // Already set to GrContextFactory::kNative_GLContextType, above.
- break;
- case kNVPR_DeviceType:
- // Already set to GrContextFactory::kNative_GLContextType, above.
- glContextOptions = GrContextFactory::kEnableNVPR_GLContextOptions;
- break;
-#if SK_ANGLE
- case kAngle_DeviceType:
- glContextType = GrContextFactory::kANGLE_GLContextType;
- break;
-#endif
-#if SK_COMMAND_BUFFER
- case kCommandBuffer_DeviceType:
- glContextType = GrContextFactory::kCommandBuffer_GLContextType;
- break;
-#endif
-#if SK_MESA
- case kMesa_DeviceType:
- glContextType = GrContextFactory::kMESA_GLContextType;
- break;
-#endif
-#endif
- default:
- // Invalid device type.
- return false;
- }
-#if SK_SUPPORT_GPU
- GrContextFactory::ContextInfo* contextInfo = fGrContextFactory.getContextInfo(glContextType, gpuAPI, glContextOptions);
- if (contextInfo) {
- fGrContext.reset(SkRef(contextInfo->fGrContext));
- fGLContext.reset(SkRef(contextInfo->fGLContext));
- return true;
- }
- return false;
-#endif
- }
-
-#if SK_SUPPORT_GPU
- void setSampleCount(int sampleCount) {
- fSampleCount = sampleCount;
- }
-
- void setUseDFText(bool useDFText) {
- fUseDFText = useDFText;
- }
-#endif
-
- void setDrawFilters(DrawFilterFlags const * const filters, const SkString& configName) {
- fHasDrawFilters = false;
- fDrawFiltersConfig = configName;
-
- for (size_t i = 0; i < SK_ARRAY_COUNT(fDrawFilters); ++i) {
- fDrawFilters[i] = filters[i];
- fHasDrawFilters |= SkToBool(filters[i]);
- }
- }
-
- void setBBoxHierarchyType(BBoxHierarchyType bbhType) {
- fBBoxHierarchyType = bbhType;
- }
-
- BBoxHierarchyType getBBoxHierarchyType() { return fBBoxHierarchyType; }
-
- bool isUsingBitmapDevice() {
- return kBitmap_DeviceType == fDeviceType;
- }
-
- virtual SkString getPerIterTimeFormat() { return SkString("%.2f"); }
-
- virtual SkString getNormalTimeFormat() { return SkString("%6.2f"); }
-
- /**
- * Reports the configuration of this PictureRenderer.
- */
- SkString getConfigName() {
- SkString config = this->getConfigNameInternal();
- if (!fViewport.isEmpty()) {
- config.appendf("_viewport_%ix%i", fViewport.width(), fViewport.height());
- }
- if (fScaleFactor != SK_Scalar1) {
- config.appendf("_scalar_%f", SkScalarToFloat(fScaleFactor));
- }
- if (kRTree_BBoxHierarchyType == fBBoxHierarchyType) {
- config.append("_rtree");
- }
-#if SK_SUPPORT_GPU
- switch (fDeviceType) {
- case kGPU_DeviceType:
- if (fSampleCount) {
- config.appendf("_msaa%d", fSampleCount);
- } else if (fUseDFText) {
- config.append("_gpudft");
- } else {
- config.append("_gpu");
- }
- break;
- case kNVPR_DeviceType:
- config.appendf("_nvprmsaa%d", fSampleCount);
- break;
-#if SK_ANGLE
- case kAngle_DeviceType:
- config.append("_angle");
- break;
-#endif
-#if SK_COMMAND_BUFFER
- case kCommandBuffer_DeviceType:
- config.append("_commandbuffer");
- break;
-#endif
-#if SK_MESA
- case kMesa_DeviceType:
- config.append("_mesa");
- break;
-#endif
- default:
- // Assume that no extra info means bitmap.
- break;
- }
-#endif
- config.append(fDrawFiltersConfig.c_str());
- return config;
- }
-
- Json::Value getJSONConfig() {
- Json::Value result;
-
- result["mode"] = this->getConfigNameInternal().c_str();
- result["scale"] = 1.0f;
- if (SK_Scalar1 != fScaleFactor) {
- result["scale"] = SkScalarToFloat(fScaleFactor);
- }
- if (kRTree_BBoxHierarchyType == fBBoxHierarchyType) {
- result["bbh"] = "rtree";
- }
-#if SK_SUPPORT_GPU
- SkString tmp;
- switch (fDeviceType) {
- case kGPU_DeviceType:
- if (0 != fSampleCount) {
- tmp = "msaa";
- tmp.appendS32(fSampleCount);
- result["config"] = tmp.c_str();
- } else if (fUseDFText) {
- result["config"] = "gpudft";
- } else {
- result["config"] = "gpu";
- }
- break;
- case kNVPR_DeviceType:
- tmp = "nvprmsaa";
- tmp.appendS32(fSampleCount);
- result["config"] = tmp.c_str();
- break;
-#if SK_ANGLE
- case kAngle_DeviceType:
- result["config"] = "angle";
- break;
-#endif
-#if SK_COMMAND_BUFFER
- case kCommandBuffer_DeviceType:
- result["config"] = "commandbuffer";
- break;
-#endif
-#if SK_MESA
- case kMesa_DeviceType:
- result["config"] = "mesa";
- break;
-#endif
- default:
- // Assume that no extra info means bitmap.
- break;
- }
-#endif
- return result;
- }
-
-#if SK_SUPPORT_GPU
- bool isUsingGpuDevice() {
- switch (fDeviceType) {
- case kGPU_DeviceType:
- case kNVPR_DeviceType:
- // fall through
-#if SK_ANGLE
- case kAngle_DeviceType:
- // fall through
-#endif
-#if SK_COMMAND_BUFFER
- case kCommandBuffer_DeviceType:
- // fall through
-#endif
-#if SK_MESA
- case kMesa_DeviceType:
-#endif
- return true;
- default:
- return false;
- }
- }
-
- SkGLContext* getGLContext() {
- return fGLContext;
- }
-
- GrContext* getGrContext() {
- return fGrContext;
- }
-
- const GrContextOptions& getGrContextOptions() {
- return fGrContextFactory.getGlobalOptions();
- }
-#endif
-
- SkCanvas* getCanvas() {
- return fCanvas;
- }
-
- const SkPicture* getPicture() {
- return fPicture;
- }
-
-#if SK_SUPPORT_GPU
- explicit PictureRenderer(const GrContextOptions &opts)
-#else
- PictureRenderer()
-#endif
- : fDeviceType(kBitmap_DeviceType)
- , fBBoxHierarchyType(kNone_BBoxHierarchyType)
- , fHasDrawFilters(false)
- , fScaleFactor(SK_Scalar1)
-#if SK_SUPPORT_GPU
- , fGrContextFactory(opts)
- , fSampleCount(0)
- , fUseDFText(false)
-#endif
- {
- sk_bzero(fDrawFilters, sizeof(fDrawFilters));
- fViewport.set(0, 0);
- }
-
-protected:
- SkAutoTUnref<SkCanvas> fCanvas;
- SkAutoTUnref<const SkPicture> fPicture;
- bool fUseChecksumBasedFilenames;
- bool fUseMultiPictureDraw;
- SkDeviceTypes fDeviceType;
- BBoxHierarchyType fBBoxHierarchyType;
- bool fHasDrawFilters;
- DrawFilterFlags fDrawFilters[SkDrawFilter::kTypeCount];
- SkString fDrawFiltersConfig;
- SkString fWritePath;
- SkString fMismatchPath;
- SkString fInputFilename;
-
- void buildBBoxHierarchy();
-
- /**
- * Return the total width that should be drawn. If the viewport width has been set greater than
- * 0, this will be the minimum of the current SkPicture's width and the viewport's width.
- */
- int getViewWidth();
-
- /**
- * Return the total height that should be drawn. If the viewport height has been set greater
- * than 0, this will be the minimum of the current SkPicture's height and the viewport's height.
- */
- int getViewHeight();
-
- /**
- * Scales the provided canvas to the scale factor set by setScaleFactor.
- */
- void scaleToScaleFactor(SkCanvas*);
-
- SkBBHFactory* getFactory();
- uint32_t recordFlags() const { return 0; }
- SkCanvas* setupCanvas();
- virtual SkCanvas* setupCanvas(int width, int height);
-
- /**
- * Copy src to dest; if src==nullptr, set dest to empty string.
- */
- static void CopyString(SkString* dest, const SkString* src);
-
-private:
- SkISize fViewport;
- SkScalar fScaleFactor;
-#if SK_SUPPORT_GPU
- GrContextFactory fGrContextFactory;
- SkAutoTUnref<GrContext> fGrContext;
- SkAutoTUnref<SkGLContext> fGLContext;
- int fSampleCount;
- bool fUseDFText;
-#endif
-
- virtual SkString getConfigNameInternal() = 0;
-
- typedef SkRefCnt INHERITED;
-};
-
-/**
- * This class does not do any rendering, but its render function executes recording, which we want
- * to time.
- */
-class RecordPictureRenderer : public PictureRenderer {
-public:
-#if SK_SUPPORT_GPU
- RecordPictureRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
-#endif
-
- bool render(SkBitmap** out = nullptr) override;
-
- SkString getPerIterTimeFormat() override { return SkString("%.4f"); }
-
- SkString getNormalTimeFormat() override { return SkString("%6.4f"); }
-
-protected:
- SkCanvas* setupCanvas(int width, int height) override;
-
-private:
- SkString getConfigNameInternal() override;
-
- typedef PictureRenderer INHERITED;
-};
-
-class PipePictureRenderer : public PictureRenderer {
-public:
-#if SK_SUPPORT_GPU
- PipePictureRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
-#endif
-
- bool render(SkBitmap** out = nullptr) override;
-
-private:
- SkString getConfigNameInternal() override;
-
- typedef PictureRenderer INHERITED;
-};
-
-class SimplePictureRenderer : public PictureRenderer {
-public:
-#if SK_SUPPORT_GPU
- SimplePictureRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
-#endif
-
- virtual void init(const SkPicture* pict,
- const SkString* writePath,
- const SkString* mismatchPath,
- const SkString* inputFilename,
- bool useChecksumBasedFilenames,
- bool useMultiPictureDraw) override;
-
- bool render(SkBitmap** out = nullptr) override;
-
-private:
- SkString getConfigNameInternal() override;
-
- typedef PictureRenderer INHERITED;
-};
-
-class TiledPictureRenderer : public PictureRenderer {
-public:
-#if SK_SUPPORT_GPU
- TiledPictureRenderer(const GrContextOptions &opts);
-#else
- TiledPictureRenderer();
-#endif
-
- virtual void init(const SkPicture* pict,
- const SkString* writePath,
- const SkString* mismatchPath,
- const SkString* inputFilename,
- bool useChecksumBasedFilenames,
- bool useMultiPictureDraw) override;
-
- /**
- * Renders to tiles, rather than a single canvas.
- * If fWritePath was provided, a separate file is
- * created for each tile, named "path0.png", "path1.png", etc.
- */
- bool render(SkBitmap** out = nullptr) override;
-
- void end() override;
-
- void setTileWidth(int width) {
- fTileWidth = width;
- }
-
- int getTileWidth() const {
- return fTileWidth;
- }
-
- void setTileHeight(int height) {
- fTileHeight = height;
- }
-
- int getTileHeight() const {
- return fTileHeight;
- }
-
- void setTileWidthPercentage(double percentage) {
- fTileWidthPercentage = percentage;
- }
-
- double getTileWidthPercentage() const {
- return fTileWidthPercentage;
- }
-
- void setTileHeightPercentage(double percentage) {
- fTileHeightPercentage = percentage;
- }
-
- double getTileHeightPercentage() const {
- return fTileHeightPercentage;
- }
-
- void setTileMinPowerOf2Width(int width) {
- SkASSERT(SkIsPow2(width) && width > 0);
- if (!SkIsPow2(width) || width <= 0) {
- return;
- }
-
- fTileMinPowerOf2Width = width;
- }
-
- int getTileMinPowerOf2Width() const {
- return fTileMinPowerOf2Width;
- }
-
- TiledPictureRenderer* getTiledRenderer() override { return this; }
-
- virtual bool supportsTimingIndividualTiles() { return true; }
-
- /**
- * Report the number of tiles in the x and y directions. Must not be called before init.
- * @param x Output parameter identifying the number of tiles in the x direction.
- * @param y Output parameter identifying the number of tiles in the y direction.
- * @return True if the tiles have been set up, and x and y are meaningful. If false, x and y are
- * unmodified.
- */
- bool tileDimensions(int& x, int&y);
-
- /**
- * Move to the next tile and return its indices. Must be called before calling drawCurrentTile
- * for the first time.
- * @param i Output parameter identifying the column of the next tile to be drawn on the next
- * call to drawNextTile.
- * @param j Output parameter identifying the row of the next tile to be drawn on the next call
- * to drawNextTile.
- * @param True if the tiles have been created and the next tile to be drawn by drawCurrentTile
- * is within the range of tiles. If false, i and j are unmodified.
- */
- bool nextTile(int& i, int& j);
-
- /**
- * Render one tile. This will draw the same tile each time it is called until nextTile is
- * called. The tile rendered will depend on how many calls have been made to nextTile.
- * It is an error to call this without first calling nextTile, or if nextTile returns false.
- */
- void drawCurrentTile();
-
-protected:
- SkTDArray<SkIRect> fTileRects;
-
- SkCanvas* setupCanvas(int width, int height) override;
- SkString getConfigNameInternal() override;
-
-private:
- int fTileWidth;
- int fTileHeight;
- double fTileWidthPercentage;
- double fTileHeightPercentage;
- int fTileMinPowerOf2Width;
-
- // These variables are only used for timing individual tiles.
- // Next tile to draw in fTileRects.
- int fCurrentTileOffset;
- // Number of tiles in the x direction.
- int fTilesX;
- // Number of tiles in the y direction.
- int fTilesY;
-
- void setupTiles();
- void setupPowerOf2Tiles();
- bool postRender(SkCanvas*, const SkIRect& tileRect,
- SkBitmap* tempBM, SkBitmap** out,
- int tileNumber);
-
- typedef PictureRenderer INHERITED;
-};
-
-/**
- * This class does not do any rendering, but its render function executes turning an SkPictureRecord
- * into an SkPicturePlayback, which we want to time.
- */
-class PlaybackCreationRenderer : public PictureRenderer {
-public:
-#if SK_SUPPORT_GPU
- PlaybackCreationRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
-#endif
-
- void setup() override;
-
- bool render(SkBitmap** out = nullptr) override;
-
- SkString getPerIterTimeFormat() override { return SkString("%.4f"); }
-
- SkString getNormalTimeFormat() override { return SkString("%6.4f"); }
-
-private:
- SkAutoTDelete<SkPictureRecorder> fRecorder;
-
- SkString getConfigNameInternal() override;
-
- typedef PictureRenderer INHERITED;
-};
-
-#if SK_SUPPORT_GPU
-extern PictureRenderer* CreateGatherPixelRefsRenderer(const GrContextOptions& opts);
-#else
-extern PictureRenderer* CreateGatherPixelRefsRenderer();
-#endif
-
-}
-
-#endif // PictureRenderer_DEFINED
