blob: 32714b81f30e6b6336c7a92fe789f81fd1feb755 [file] [log] [blame]
bsalomondc47ff72015-05-26 12:16:59 -07001/*
2 * Copyright 2015 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
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "include/gpu/GrBackendSurface.h"
9#include "include/gpu/GrContextOptions.h"
10#include "include/gpu/GrSurface.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050011#include "include/private/GrTypesPriv.h"
12#include "src/gpu/GrCaps.h"
Greg Danielf91aeb22019-06-18 09:58:02 -040013#include "src/gpu/GrSurfaceProxy.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050014#include "src/gpu/GrWindowRectangles.h"
15#include "src/utils/SkJSONWriter.h"
bsalomondc47ff72015-05-26 12:16:59 -070016
bsalomondc47ff72015-05-26 12:16:59 -070017GrCaps::GrCaps(const GrContextOptions& options) {
18 fMipMapSupport = false;
19 fNPOTTextureTileSupport = false;
brianosmana6359362016-03-21 06:55:37 -070020 fSRGBSupport = false;
brianosman35b784d2016-05-05 11:52:53 -070021 fSRGBWriteControl = false;
bsalomondc47ff72015-05-26 12:16:59 -070022 fReuseScratchTextures = true;
robertphillips1b8e1b52015-06-24 06:54:10 -070023 fReuseScratchBuffers = true;
bsalomondc47ff72015-05-26 12:16:59 -070024 fGpuTracingSupport = false;
bsalomondc47ff72015-05-26 12:16:59 -070025 fOversizedStencilSupport = false;
26 fTextureBarrierSupport = false;
Robert Phillips7f861922018-01-30 13:13:42 +000027 fSampleLocationsSupport = false;
csmartdalton2b5f2cb2016-06-10 14:06:32 -070028 fMultisampleDisableSupport = false;
Chris Dalton1d616352017-05-31 12:51:23 -060029 fInstanceAttribSupport = false;
Chris Dalton6ce447a2019-06-23 18:07:38 -060030 fMixedSamplesSupport = false;
Chris Dalton27059d32018-01-23 14:06:50 -070031 fUsePrimitiveRestart = false;
csmartdalton485a1202016-07-13 10:16:32 -070032 fPreferClientSideDynamicBuffers = false;
Chris Dalton344e9032017-12-11 15:42:09 -070033 fPreferFullscreenClears = false;
bsalomon7dea7b72015-08-19 08:26:51 -070034 fMustClearUploadedBufferData = false;
Kevin Lubick61a5f0a2019-03-28 09:47:15 -040035 fShouldInitializeTextures = false;
Greg Danielb2acf0a2018-09-12 09:17:11 -040036 fSupportsAHardwareBufferImages = false;
jvanverth84741b32016-09-30 08:39:02 -070037 fFenceSyncSupport = false;
Brian Salomon9ff5acb2019-05-08 09:04:47 -040038 fSemaphoreSupport = false;
Brian Osman2c2bc112017-02-28 10:02:49 -050039 fCrossContextTextureSupport = false;
Brian Osman499bf1a2018-09-17 11:32:42 -040040 fHalfFloatVertexAttributeSupport = false;
Brian Salomonf7232642018-09-19 08:58:08 -040041 fDynamicStateArrayGeometryProcessorTextureSupport = false;
Michael Ludwiga21d1962019-01-11 15:26:22 -050042 fPerformPartialClearsAsDraws = false;
43 fPerformColorClearsAsDraws = false;
44 fPerformStencilClearsAsDraws = false;
Chris Daltona8fbeba2019-03-30 00:31:23 -060045 fAllowCoverageCounting = false;
Brian Salomone05ba5a2019-04-08 11:59:07 -040046 fTransferBufferSupport = false;
Brian Salomon1047a492019-07-02 12:25:21 -040047 fWritePixelsRowBytesSupport = false;
48 fReadPixelsRowBytesSupport = false;
Chris Daltona8fbeba2019-03-30 00:31:23 -060049 fDriverBlacklistCCPR = false;
Chris Dalton7c012082019-07-22 00:45:52 -040050 fDriverBlacklistMSAACCPR = false;
bsalomondc47ff72015-05-26 12:16:59 -070051
bsalomondc47ff72015-05-26 12:16:59 -070052 fBlendEquationSupport = kBasic_BlendEquationSupport;
cdalton1dd05422015-06-12 09:01:18 -070053 fAdvBlendEqBlacklist = 0;
54
bsalomondc47ff72015-05-26 12:16:59 -070055 fMapBufferFlags = kNone_MapFlags;
56
bsalomon7dbd45d2016-03-23 10:40:53 -070057 fMaxVertexAttributes = 0;
egdanielff1d5472015-09-10 08:37:20 -070058 fMaxRenderTargetSize = 1;
Chris Dalton2612bae2018-02-22 13:41:37 -070059 fMaxPreferredRenderTargetSize = 1;
egdanielff1d5472015-09-10 08:37:20 -070060 fMaxTextureSize = 1;
csmartdalton9bc11872016-08-09 12:42:47 -070061 fMaxWindowRectangles = 0;
Chris Daltona1638a52019-06-24 11:54:24 -060062 fInternalMultisampleCount = 0;
bsalomondc47ff72015-05-26 12:16:59 -070063
robertphillipscaef3452015-11-11 13:18:11 -080064 fSuppressPrints = options.fSuppressPrints;
Brian Osman195c05b2017-08-30 15:14:04 -040065#if GR_TEST_UTILS
Jim Van Verthfbdc0802017-05-02 16:15:53 -040066 fWireframeMode = options.fWireframeMode;
Brian Osman195c05b2017-08-30 15:14:04 -040067#else
68 fWireframeMode = false;
69#endif
cdalton397536c2016-03-25 12:15:03 -070070 fBufferMapThreshold = options.fBufferMapThreshold;
Eric Karl5c779752017-05-08 12:02:07 -070071 fAvoidStencilBuffers = false;
Greg Daniel4374e962018-09-28 15:09:47 -040072 fAvoidWritePixelsFastPath = false;
robertphillips63926682015-08-20 09:39:02 -070073
74 fPreferVRAMUseOverFlushes = true;
Adrienne Walkerab7181d2018-05-14 14:02:03 -070075
Chris Dalton0dffbab2019-03-27 13:08:50 -060076 fPreferTrianglesOverSampleMask = false;
77
Michael Ludwigf23a1522018-12-10 11:36:13 -050078 // Default to true, allow older versions of OpenGL to disable explicitly
79 fClampToBorderSupport = true;
80
Adrienne Walkerab7181d2018-05-14 14:02:03 -070081 fDriverBugWorkarounds = options.fDriverBugWorkarounds;
bsalomondc47ff72015-05-26 12:16:59 -070082}
83
bsalomon4ee6bd82015-05-27 13:23:23 -070084void GrCaps::applyOptionsOverrides(const GrContextOptions& options) {
csmartdalton28341fa2016-08-17 10:00:21 -070085 this->onApplyOptionsOverrides(options);
Brian Salomon01b476a2018-01-23 11:06:41 -050086 if (options.fDisableDriverCorrectnessWorkarounds) {
Chris Daltona8fbeba2019-03-30 00:31:23 -060087 SkASSERT(!fDriverBlacklistCCPR);
Chris Dalton7c012082019-07-22 00:45:52 -040088 SkASSERT(!fDriverBlacklistMSAACCPR);
Brian Salomon01b476a2018-01-23 11:06:41 -050089 SkASSERT(!fAvoidStencilBuffers);
90 SkASSERT(!fAdvBlendEqBlacklist);
Michael Ludwiga21d1962019-01-11 15:26:22 -050091 SkASSERT(!fPerformColorClearsAsDraws);
92 SkASSERT(!fPerformStencilClearsAsDraws);
93 // Don't check the partial-clear workaround, since that is a backend limitation, not a
94 // driver workaround (it just so happens the fallbacks are the same).
95 }
96 if (GrContextOptions::Enable::kNo == options.fUseDrawInsteadOfClear) {
97 fPerformColorClearsAsDraws = false;
98 fPerformStencilClearsAsDraws = false;
99 } else if (GrContextOptions::Enable::kYes == options.fUseDrawInsteadOfClear) {
100 fPerformColorClearsAsDraws = true;
101 fPerformStencilClearsAsDraws = true;
Brian Salomon01b476a2018-01-23 11:06:41 -0500102 }
103
Chris Daltona8fbeba2019-03-30 00:31:23 -0600104 fAllowCoverageCounting = !options.fDisableCoverageCountingPaths;
105
bsalomon4ee6bd82015-05-27 13:23:23 -0700106 fMaxTextureSize = SkTMin(fMaxTextureSize, options.fMaxTextureSizeOverride);
Brian Osman195c05b2017-08-30 15:14:04 -0400107 fMaxTileSize = fMaxTextureSize;
108#if GR_TEST_UTILS
bsalomon8c07b7a2015-11-02 11:36:52 -0800109 // If the max tile override is zero, it means we should use the max texture size.
Brian Osman195c05b2017-08-30 15:14:04 -0400110 if (options.fMaxTileSizeOverride && options.fMaxTileSizeOverride < fMaxTextureSize) {
bsalomon8c07b7a2015-11-02 11:36:52 -0800111 fMaxTileSize = options.fMaxTileSizeOverride;
112 }
Chris Dalton040238b2017-12-18 14:22:34 -0700113 if (options.fSuppressGeometryShaders) {
114 fShaderCaps->fGeometryShaderSupport = false;
115 }
Brian Salomona3e29962019-07-16 11:52:08 -0400116 if (options.fClearAllTextures) {
117 fShouldInitializeTextures = true;
118 }
Brian Osman195c05b2017-08-30 15:14:04 -0400119#endif
Chris Dalton1e6c5b82019-06-17 14:16:49 -0600120
csmartdalton28341fa2016-08-17 10:00:21 -0700121 if (fMaxWindowRectangles > GrWindowRectangles::kMaxWindows) {
csmartdalton7535f412016-08-23 06:51:00 -0700122 SkDebugf("WARNING: capping window rectangles at %i. HW advertises support for %i.\n",
123 GrWindowRectangles::kMaxWindows, fMaxWindowRectangles);
csmartdalton28341fa2016-08-17 10:00:21 -0700124 fMaxWindowRectangles = GrWindowRectangles::kMaxWindows;
125 }
Chris Dalton1e6c5b82019-06-17 14:16:49 -0600126
Chris Daltona1638a52019-06-24 11:54:24 -0600127 fInternalMultisampleCount = options.fInternalMultisampleCount;
Chris Dalton1e6c5b82019-06-17 14:16:49 -0600128
Eric Karl5c779752017-05-08 12:02:07 -0700129 fAvoidStencilBuffers = options.fAvoidStencilBuffers;
Adrienne Walkerab7181d2018-05-14 14:02:03 -0700130
131 fDriverBugWorkarounds.applyOverrides(options.fDriverBugWorkarounds);
bsalomon4ee6bd82015-05-27 13:23:23 -0700132}
133
Kevin Lubickf4def342018-10-04 12:52:50 -0400134
135#ifdef SK_ENABLE_DUMP_GPU
136static const char* pixel_config_name(GrPixelConfig config) {
137 switch (config) {
138 case kUnknown_GrPixelConfig: return "Unknown";
139 case kAlpha_8_GrPixelConfig: return "Alpha8";
140 case kAlpha_8_as_Alpha_GrPixelConfig: return "Alpha8_asAlpha";
141 case kAlpha_8_as_Red_GrPixelConfig: return "Alpha8_asRed";
142 case kGray_8_GrPixelConfig: return "Gray8";
143 case kGray_8_as_Lum_GrPixelConfig: return "Gray8_asLum";
144 case kGray_8_as_Red_GrPixelConfig: return "Gray8_asRed";
145 case kRGB_565_GrPixelConfig: return "RGB565";
146 case kRGBA_4444_GrPixelConfig: return "RGBA444";
147 case kRGBA_8888_GrPixelConfig: return "RGBA8888";
148 case kRGB_888_GrPixelConfig: return "RGB888";
Greg Danielf259b8b2019-02-14 09:03:43 -0500149 case kRGB_888X_GrPixelConfig: return "RGB888X";
Jim Van Verth69e57852018-12-05 13:38:59 -0500150 case kRG_88_GrPixelConfig: return "RG88";
Kevin Lubickf4def342018-10-04 12:52:50 -0400151 case kBGRA_8888_GrPixelConfig: return "BGRA8888";
152 case kSRGBA_8888_GrPixelConfig: return "SRGBA8888";
Kevin Lubickf4def342018-10-04 12:52:50 -0400153 case kRGBA_1010102_GrPixelConfig: return "RGBA1010102";
154 case kRGBA_float_GrPixelConfig: return "RGBAFloat";
Kevin Lubickf4def342018-10-04 12:52:50 -0400155 case kAlpha_half_GrPixelConfig: return "AlphaHalf";
Robert Phillipsebab03f2019-07-22 08:48:18 -0400156 case kAlpha_half_as_Lum_GrPixelConfig: return "AlphaHalf_asLum";
Kevin Lubickf4def342018-10-04 12:52:50 -0400157 case kAlpha_half_as_Red_GrPixelConfig: return "AlphaHalf_asRed";
158 case kRGBA_half_GrPixelConfig: return "RGBAHalf";
Brian Osmand0626aa2019-03-11 15:28:06 -0400159 case kRGBA_half_Clamped_GrPixelConfig: return "RGBAHalfClamped";
Jim Van Verth1676cb92019-01-15 13:24:45 -0500160 case kRGB_ETC1_GrPixelConfig: return "RGBETC1";
Robert Phillipsfe18de52019-06-06 17:21:50 -0400161 case kR_16_GrPixelConfig: return "R16";
162 case kRG_1616_GrPixelConfig: return "RG1616";
Robert Phillips66a46032019-06-18 08:00:42 -0400163 // Experimental (for Y416 and mutant P016/P010)
164 case kRGBA_16161616_GrPixelConfig: return "RGBA16161616";
165 case kRG_half_GrPixelConfig: return "RGHalf";
Kevin Lubickf4def342018-10-04 12:52:50 -0400166 }
167 SK_ABORT("Invalid pixel config");
168 return "<invalid>";
169}
170
bsalomondc47ff72015-05-26 12:16:59 -0700171static SkString map_flags_to_string(uint32_t flags) {
172 SkString str;
173 if (GrCaps::kNone_MapFlags == flags) {
174 str = "none";
175 } else {
176 SkASSERT(GrCaps::kCanMap_MapFlag & flags);
177 SkDEBUGCODE(flags &= ~GrCaps::kCanMap_MapFlag);
178 str = "can_map";
179
180 if (GrCaps::kSubset_MapFlag & flags) {
181 str.append(" partial");
182 } else {
183 str.append(" full");
184 }
185 SkDEBUGCODE(flags &= ~GrCaps::kSubset_MapFlag);
Brian Salomon105d7c22019-04-16 13:46:14 -0400186 if (GrCaps::kAsyncRead_MapFlag & flags) {
187 str.append(" async_read");
188 } else {
189 str.append(" sync_read");
190 }
191 SkDEBUGCODE(flags &= ~GrCaps::kAsyncRead_MapFlag);
bsalomondc47ff72015-05-26 12:16:59 -0700192 }
193 SkASSERT(0 == flags); // Make sure we handled all the flags.
194 return str;
195}
196
Brian Osman71a18892017-08-10 10:23:25 -0400197void GrCaps::dumpJSON(SkJSONWriter* writer) const {
198 writer->beginObject();
jvanverth84741b32016-09-30 08:39:02 -0700199
Brian Osman71a18892017-08-10 10:23:25 -0400200 writer->appendBool("MIP Map Support", fMipMapSupport);
201 writer->appendBool("NPOT Texture Tile Support", fNPOTTextureTileSupport);
202 writer->appendBool("sRGB Support", fSRGBSupport);
203 writer->appendBool("sRGB Write Control", fSRGBWriteControl);
Brian Osman71a18892017-08-10 10:23:25 -0400204 writer->appendBool("Reuse Scratch Textures", fReuseScratchTextures);
205 writer->appendBool("Reuse Scratch Buffers", fReuseScratchBuffers);
206 writer->appendBool("Gpu Tracing Support", fGpuTracingSupport);
207 writer->appendBool("Oversized Stencil Support", fOversizedStencilSupport);
208 writer->appendBool("Texture Barrier Support", fTextureBarrierSupport);
Robert Phillips7f861922018-01-30 13:13:42 +0000209 writer->appendBool("Sample Locations Support", fSampleLocationsSupport);
Brian Osman71a18892017-08-10 10:23:25 -0400210 writer->appendBool("Multisample disable support", fMultisampleDisableSupport);
211 writer->appendBool("Instance Attrib Support", fInstanceAttribSupport);
Chris Dalton6ce447a2019-06-23 18:07:38 -0600212 writer->appendBool("Mixed Samples Support", fMixedSamplesSupport);
Chris Dalton27059d32018-01-23 14:06:50 -0700213 writer->appendBool("Use primitive restart", fUsePrimitiveRestart);
Brian Osman71a18892017-08-10 10:23:25 -0400214 writer->appendBool("Prefer client-side dynamic buffers", fPreferClientSideDynamicBuffers);
Chris Dalton344e9032017-12-11 15:42:09 -0700215 writer->appendBool("Prefer fullscreen clears", fPreferFullscreenClears);
Brian Osman71a18892017-08-10 10:23:25 -0400216 writer->appendBool("Must clear buffer memory", fMustClearUploadedBufferData);
Kevin Lubick61a5f0a2019-03-28 09:47:15 -0400217 writer->appendBool("Should initialize textures", fShouldInitializeTextures);
Greg Danielb2acf0a2018-09-12 09:17:11 -0400218 writer->appendBool("Supports importing AHardwareBuffers", fSupportsAHardwareBufferImages);
Brian Osman71a18892017-08-10 10:23:25 -0400219 writer->appendBool("Fence sync support", fFenceSyncSupport);
Brian Salomon9ff5acb2019-05-08 09:04:47 -0400220 writer->appendBool("Semaphore support", fSemaphoreSupport);
Brian Osman71a18892017-08-10 10:23:25 -0400221 writer->appendBool("Cross context texture support", fCrossContextTextureSupport);
Brian Osman499bf1a2018-09-17 11:32:42 -0400222 writer->appendBool("Half float vertex attribute support", fHalfFloatVertexAttributeSupport);
Brian Salomonf7232642018-09-19 08:58:08 -0400223 writer->appendBool("Specify GeometryProcessor textures as a dynamic state array",
224 fDynamicStateArrayGeometryProcessorTextureSupport);
Michael Ludwiga21d1962019-01-11 15:26:22 -0500225 writer->appendBool("Use draws for partial clears", fPerformPartialClearsAsDraws);
226 writer->appendBool("Use draws for color clears", fPerformColorClearsAsDraws);
227 writer->appendBool("Use draws for stencil clip clears", fPerformStencilClearsAsDraws);
Chris Daltona8fbeba2019-03-30 00:31:23 -0600228 writer->appendBool("Allow coverage counting shortcuts", fAllowCoverageCounting);
Brian Salomone05ba5a2019-04-08 11:59:07 -0400229 writer->appendBool("Supports transfer buffers", fTransferBufferSupport);
Brian Salomon1047a492019-07-02 12:25:21 -0400230 writer->appendBool("Write pixels row bytes support", fWritePixelsRowBytesSupport);
231 writer->appendBool("Read pixels row bytes support", fReadPixelsRowBytesSupport);
Chris Daltona8fbeba2019-03-30 00:31:23 -0600232 writer->appendBool("Blacklist CCPR on current driver [workaround]", fDriverBlacklistCCPR);
Chris Dalton7c012082019-07-22 00:45:52 -0400233 writer->appendBool("Blacklist MSAA version of CCPR on current driver [workaround]",
234 fDriverBlacklistMSAACCPR);
Michael Ludwiga21d1962019-01-11 15:26:22 -0500235 writer->appendBool("Clamp-to-border", fClampToBorderSupport);
Brian Osman71a18892017-08-10 10:23:25 -0400236
Brian Osman71a18892017-08-10 10:23:25 -0400237 writer->appendBool("Prefer VRAM Use over flushes [workaround]", fPreferVRAMUseOverFlushes);
Chris Dalton0dffbab2019-03-27 13:08:50 -0600238 writer->appendBool("Prefer more triangles over sample mask [MSAA only]",
239 fPreferTrianglesOverSampleMask);
Robert Phillipsf2ec0242018-03-01 16:51:25 -0500240 writer->appendBool("Avoid stencil buffers [workaround]", fAvoidStencilBuffers);
robertphillips63926682015-08-20 09:39:02 -0700241
cdalton1dd05422015-06-12 09:01:18 -0700242 if (this->advancedBlendEquationSupport()) {
Brian Osman71a18892017-08-10 10:23:25 -0400243 writer->appendHexU32("Advanced Blend Equation Blacklist", fAdvBlendEqBlacklist);
cdalton1dd05422015-06-12 09:01:18 -0700244 }
bsalomondc47ff72015-05-26 12:16:59 -0700245
Brian Osman71a18892017-08-10 10:23:25 -0400246 writer->appendS32("Max Vertex Attributes", fMaxVertexAttributes);
247 writer->appendS32("Max Texture Size", fMaxTextureSize);
248 writer->appendS32("Max Render Target Size", fMaxRenderTargetSize);
Chris Dalton2612bae2018-02-22 13:41:37 -0700249 writer->appendS32("Max Preferred Render Target Size", fMaxPreferredRenderTargetSize);
Brian Osman71a18892017-08-10 10:23:25 -0400250 writer->appendS32("Max Window Rectangles", fMaxWindowRectangles);
Chris Dalton1e6c5b82019-06-17 14:16:49 -0600251 writer->appendS32("Preferred Sample Count for Internal MSAA and Mixed Samples",
Chris Daltona1638a52019-06-24 11:54:24 -0600252 fInternalMultisampleCount);
bsalomondc47ff72015-05-26 12:16:59 -0700253
254 static const char* kBlendEquationSupportNames[] = {
255 "Basic",
256 "Advanced",
257 "Advanced Coherent",
258 };
259 GR_STATIC_ASSERT(0 == kBasic_BlendEquationSupport);
260 GR_STATIC_ASSERT(1 == kAdvanced_BlendEquationSupport);
261 GR_STATIC_ASSERT(2 == kAdvancedCoherent_BlendEquationSupport);
262 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kBlendEquationSupportNames) == kLast_BlendEquationSupport + 1);
263
Brian Osman71a18892017-08-10 10:23:25 -0400264 writer->appendString("Blend Equation Support",
265 kBlendEquationSupportNames[fBlendEquationSupport]);
266 writer->appendString("Map Buffer Support", map_flags_to_string(fMapBufferFlags).c_str());
bsalomondc47ff72015-05-26 12:16:59 -0700267
Brian Salomonbdecacf2018-02-02 20:32:49 -0500268 SkASSERT(!this->isConfigRenderable(kUnknown_GrPixelConfig));
Brian Osman0f450ac2017-08-09 20:45:52 +0000269 SkASSERT(!this->isConfigTexturable(kUnknown_GrPixelConfig));
Brian Osman175af0d2017-08-09 14:29:36 -0400270
Brian Osman71a18892017-08-10 10:23:25 -0400271 writer->beginArray("configs");
272
273 for (size_t i = 1; i < kGrPixelConfigCnt; ++i) {
Brian Osman0f450ac2017-08-09 20:45:52 +0000274 GrPixelConfig config = static_cast<GrPixelConfig>(i);
Brian Osman80488222017-08-10 13:29:30 -0400275 writer->beginObject(nullptr, false);
Brian Osman71a18892017-08-10 10:23:25 -0400276 writer->appendString("name", pixel_config_name(config));
Brian Salomonbdecacf2018-02-02 20:32:49 -0500277 writer->appendS32("max sample count", this->maxRenderTargetSampleCount(config));
Brian Osman71a18892017-08-10 10:23:25 -0400278 writer->appendBool("texturable", this->isConfigTexturable(config));
279 writer->endObject();
Brian Osman0f450ac2017-08-09 20:45:52 +0000280 }
Brian Osman175af0d2017-08-09 14:29:36 -0400281
Brian Osman71a18892017-08-10 10:23:25 -0400282 writer->endArray();
283
284 this->onDumpJSON(writer);
285
286 writer->appendName("shaderCaps");
287 this->shaderCaps()->dumpJSON(writer);
288
289 writer->endObject();
bsalomondc47ff72015-05-26 12:16:59 -0700290}
Kevin Lubickf4def342018-10-04 12:52:50 -0400291#else
292void GrCaps::dumpJSON(SkJSONWriter* writer) const { }
293#endif
Greg Danielf5d87582017-12-18 14:48:15 -0500294
Brian Salomonc67c31c2018-12-06 10:00:03 -0500295bool GrCaps::surfaceSupportsWritePixels(const GrSurface* surface) const {
296 return surface->readOnly() ? false : this->onSurfaceSupportsWritePixels(surface);
297}
298
299bool GrCaps::canCopySurface(const GrSurfaceProxy* dst, const GrSurfaceProxy* src,
300 const SkIRect& srcRect, const SkIPoint& dstPoint) const {
Greg Daniel2c3398d2019-06-19 11:58:01 -0400301 if (dst->readOnly()) {
302 return false;
303 }
304 // Currently we only ever do copies where the configs are the same. This check really should be
305 // checking if the backend formats, color types, and swizzle are compatible. Our copy always
306 // copies exact byte to byte from src to dst so when need to check the if we do this, the dst
307 // has the expected values stored in the right places taking the swizzle into account. For now
308 // we can be more restrictive and just make sure the configs are the same and if we generalize
309 // copies and swizzles more in the future this can be updated.
Brian Salomon947efe22019-07-16 15:36:11 -0400310 if (this->makeConfigSpecific(dst->config(), dst->backendFormat()) !=
311 this->makeConfigSpecific(src->config(), src->backendFormat())) {
Greg Daniel2c3398d2019-06-19 11:58:01 -0400312 return false;
313 }
314 return this->onCanCopySurface(dst, src, srcRect, dstPoint);
Brian Salomonc67c31c2018-12-06 10:00:03 -0500315}
316
Brian Salomonf2c2ba92019-07-17 09:59:59 -0400317bool GrCaps::validateSurfaceDesc(const GrSurfaceDesc& desc, GrRenderable renderable,
Brian Salomon27b4d8d2019-07-22 14:23:45 -0400318 int renderTargetSampleCnt, GrMipMapped mipped) const {
Brian Salomonbdecacf2018-02-02 20:32:49 -0500319 if (!this->isConfigTexturable(desc.fConfig)) {
320 return false;
321 }
322
Brian Salomon57111332018-02-05 15:55:54 -0500323 if (GrMipMapped::kYes == mipped && !this->mipMapSupport()) {
324 return false;
Brian Salomonbdecacf2018-02-02 20:32:49 -0500325 }
326
327 if (desc.fWidth < 1 || desc.fHeight < 1) {
328 return false;
329 }
330
Brian Salomonf2c2ba92019-07-17 09:59:59 -0400331 if (renderable == GrRenderable::kYes) {
Brian Salomon27b4d8d2019-07-22 14:23:45 -0400332 if (0 == this->getRenderTargetSampleCount(renderTargetSampleCnt, desc.fConfig)) {
Brian Salomonbdecacf2018-02-02 20:32:49 -0500333 return false;
334 }
335 int maxRTSize = this->maxRenderTargetSize();
336 if (desc.fWidth > maxRTSize || desc.fHeight > maxRTSize) {
337 return false;
338 }
339 } else {
340 // We currently do not support multisampled textures
Brian Salomon27b4d8d2019-07-22 14:23:45 -0400341 if (renderTargetSampleCnt != 1) {
Brian Salomonbdecacf2018-02-02 20:32:49 -0500342 return false;
343 }
344 int maxSize = this->maxTextureSize();
345 if (desc.fWidth > maxSize || desc.fHeight > maxSize) {
346 return false;
347 }
348 }
349
350 return true;
351}
Timothy Liang036fdfe2018-06-28 15:50:36 -0400352
Greg Danielc6dc5cf2019-07-17 16:02:00 -0400353GrCaps::SupportedRead GrCaps::supportedReadPixelsColorType(GrColorType srcColorType,
Greg Danielba88ab62019-07-26 09:14:01 -0400354 const GrBackendFormat& srcFormat,
Brian Salomonf30b1c12019-06-20 12:25:02 -0400355 GrColorType dstColorType) const {
Greg Danielba88ab62019-07-26 09:14:01 -0400356 SupportedRead read = this->onSupportedReadPixelsColorType(srcColorType, srcFormat,
357 dstColorType);
358
359 // There are known problems with 24 vs 32 bit BPP with this color type. Just fail for now if
360 // using a transfer buffer.
361 if (GrColorType::kRGB_888x == read.fColorType) {
362 read.fOffsetAlignmentForTransferBuffer = 0;
363 }
364 // It's very convenient to access 1 byte-per-channel 32 bitvRGB/RGBA color types as uint32_t.
365 // Make those aligned reads out of the buffer even if the underlying API doesn't require it.
366 auto componentFlags = GrColorTypeComponentFlags(read.fColorType);
367 if ((componentFlags == kRGBA_SkColorTypeComponentFlags ||
368 componentFlags == kRGB_SkColorTypeComponentFlags) &&
369 GrColorTypeBytesPerPixel(read.fColorType) == 4) {
370 switch (read.fOffsetAlignmentForTransferBuffer & 0b11) {
371 // offset alignment already a multiple of 4
372 case 0:
373 break;
374 // offset alignment is a multiple of 2 but not 4.
375 case 2:
376 read.fOffsetAlignmentForTransferBuffer *= 2;
377 // offset alignment is not a multiple of 2.
378 default:
379 read.fOffsetAlignmentForTransferBuffer *= 4;
380 }
381 }
382 return read;
Brian Salomonf30b1c12019-06-20 12:25:02 -0400383}
Robert Phillips0902c982019-07-16 07:47:56 -0400384
385#ifdef SK_DEBUG
386bool GrCaps::AreConfigsCompatible(GrPixelConfig genericConfig, GrPixelConfig specificConfig) {
387 bool compatible = false;
388
389 switch (genericConfig) {
390 case kAlpha_8_GrPixelConfig:
391 compatible = kAlpha_8_GrPixelConfig == specificConfig || // here bc of the mock context
392 kAlpha_8_as_Alpha_GrPixelConfig == specificConfig ||
393 kAlpha_8_as_Red_GrPixelConfig == specificConfig;
394 break;
395 case kGray_8_GrPixelConfig:
396 compatible = kGray_8_GrPixelConfig == specificConfig || // here bc of the mock context
397 kGray_8_as_Lum_GrPixelConfig == specificConfig ||
398 kGray_8_as_Red_GrPixelConfig == specificConfig;
399 break;
400 case kAlpha_half_GrPixelConfig:
401 compatible = kAlpha_half_GrPixelConfig == specificConfig || // bc of the mock context
Robert Phillipsebab03f2019-07-22 08:48:18 -0400402 kAlpha_half_as_Red_GrPixelConfig == specificConfig ||
403 kAlpha_half_as_Lum_GrPixelConfig == specificConfig;
Robert Phillips0902c982019-07-16 07:47:56 -0400404 break;
405 case kRGB_888_GrPixelConfig:
406 compatible = kRGB_888_GrPixelConfig == specificConfig ||
407 kRGB_888X_GrPixelConfig == specificConfig;
408 break;
409 case kRGBA_8888_GrPixelConfig:
410 compatible = kRGBA_8888_GrPixelConfig == specificConfig ||
411 kBGRA_8888_GrPixelConfig == specificConfig;
412 break;
413 default:
414 compatible = genericConfig == specificConfig;
415 break;
416 }
417
418 if (!compatible) {
419 SkDebugf("Configs are not compatible: %d %d\n", genericConfig, specificConfig);
420 }
421
422 return compatible;
423}
424#endif
Robert Phillips0a15cc62019-07-30 12:49:10 -0400425
426GrBackendFormat GrCaps::getDefaultBackendFormat(GrColorType grColorType,
427 GrRenderable renderable) const {
428 GrBackendFormat format = this->onGetDefaultBackendFormat(grColorType, renderable);
429 if (!this->isFormatTexturable(grColorType, format)) {
430 return {};
431 }
432
433 if (renderable == GrRenderable::kYes) {
434 if (!this->isFormatRenderable(grColorType, format)) {
435 return {};
436 }
437 }
438
439 return format;
440}