blob: 8932a484568412a62d0eb2034fb8ac532e148dc1 [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 fDiscardRenderTargetSupport = false;
23 fReuseScratchTextures = true;
robertphillips1b8e1b52015-06-24 06:54:10 -070024 fReuseScratchBuffers = true;
bsalomondc47ff72015-05-26 12:16:59 -070025 fGpuTracingSupport = false;
bsalomondc47ff72015-05-26 12:16:59 -070026 fOversizedStencilSupport = false;
27 fTextureBarrierSupport = false;
Robert Phillips7f861922018-01-30 13:13:42 +000028 fSampleLocationsSupport = false;
csmartdalton2b5f2cb2016-06-10 14:06:32 -070029 fMultisampleDisableSupport = false;
Chris Dalton1d616352017-05-31 12:51:23 -060030 fInstanceAttribSupport = false;
egdanieleed519e2016-01-15 11:36:18 -080031 fUsesMixedSamples = false;
Chris Dalton27059d32018-01-23 14:06:50 -070032 fUsePrimitiveRestart = false;
csmartdalton485a1202016-07-13 10:16:32 -070033 fPreferClientSideDynamicBuffers = false;
Chris Dalton344e9032017-12-11 15:42:09 -070034 fPreferFullscreenClears = false;
bsalomon7dea7b72015-08-19 08:26:51 -070035 fMustClearUploadedBufferData = false;
Kevin Lubick61a5f0a2019-03-28 09:47:15 -040036 fShouldInitializeTextures = false;
Greg Danielb2acf0a2018-09-12 09:17:11 -040037 fSupportsAHardwareBufferImages = false;
jvanverth84741b32016-09-30 08:39:02 -070038 fFenceSyncSupport = false;
Brian Salomon9ff5acb2019-05-08 09:04:47 -040039 fSemaphoreSupport = false;
Brian Osman2c2bc112017-02-28 10:02:49 -050040 fCrossContextTextureSupport = false;
Brian Osman499bf1a2018-09-17 11:32:42 -040041 fHalfFloatVertexAttributeSupport = false;
Brian Salomonf7232642018-09-19 08:58:08 -040042 fDynamicStateArrayGeometryProcessorTextureSupport = false;
Michael Ludwiga21d1962019-01-11 15:26:22 -050043 fPerformPartialClearsAsDraws = false;
44 fPerformColorClearsAsDraws = false;
45 fPerformStencilClearsAsDraws = false;
Chris Daltona8fbeba2019-03-30 00:31:23 -060046 fAllowCoverageCounting = false;
Brian Salomone05ba5a2019-04-08 11:59:07 -040047 fTransferBufferSupport = false;
Chris Daltona8fbeba2019-03-30 00:31:23 -060048 fDriverBlacklistCCPR = false;
bsalomondc47ff72015-05-26 12:16:59 -070049
bsalomondc47ff72015-05-26 12:16:59 -070050 fBlendEquationSupport = kBasic_BlendEquationSupport;
cdalton1dd05422015-06-12 09:01:18 -070051 fAdvBlendEqBlacklist = 0;
52
bsalomondc47ff72015-05-26 12:16:59 -070053 fMapBufferFlags = kNone_MapFlags;
54
bsalomon7dbd45d2016-03-23 10:40:53 -070055 fMaxVertexAttributes = 0;
egdanielff1d5472015-09-10 08:37:20 -070056 fMaxRenderTargetSize = 1;
Chris Dalton2612bae2018-02-22 13:41:37 -070057 fMaxPreferredRenderTargetSize = 1;
egdanielff1d5472015-09-10 08:37:20 -070058 fMaxTextureSize = 1;
csmartdalton9bc11872016-08-09 12:42:47 -070059 fMaxWindowRectangles = 0;
Chris Dalton1e6c5b82019-06-17 14:16:49 -060060 fPreferredInternalSampleCount = 0;
bsalomondc47ff72015-05-26 12:16:59 -070061
robertphillipscaef3452015-11-11 13:18:11 -080062 fSuppressPrints = options.fSuppressPrints;
Brian Osman195c05b2017-08-30 15:14:04 -040063#if GR_TEST_UTILS
Jim Van Verthfbdc0802017-05-02 16:15:53 -040064 fWireframeMode = options.fWireframeMode;
Brian Osman195c05b2017-08-30 15:14:04 -040065#else
66 fWireframeMode = false;
67#endif
cdalton397536c2016-03-25 12:15:03 -070068 fBufferMapThreshold = options.fBufferMapThreshold;
Eric Karl5c779752017-05-08 12:02:07 -070069 fAvoidStencilBuffers = false;
Greg Daniel4374e962018-09-28 15:09:47 -040070 fAvoidWritePixelsFastPath = false;
robertphillips63926682015-08-20 09:39:02 -070071
72 fPreferVRAMUseOverFlushes = true;
Adrienne Walkerab7181d2018-05-14 14:02:03 -070073
Chris Dalton0dffbab2019-03-27 13:08:50 -060074 fPreferTrianglesOverSampleMask = false;
75
Michael Ludwigf23a1522018-12-10 11:36:13 -050076 // Default to true, allow older versions of OpenGL to disable explicitly
77 fClampToBorderSupport = true;
78
Adrienne Walkerab7181d2018-05-14 14:02:03 -070079 fDriverBugWorkarounds = options.fDriverBugWorkarounds;
bsalomondc47ff72015-05-26 12:16:59 -070080}
81
bsalomon4ee6bd82015-05-27 13:23:23 -070082void GrCaps::applyOptionsOverrides(const GrContextOptions& options) {
csmartdalton28341fa2016-08-17 10:00:21 -070083 this->onApplyOptionsOverrides(options);
Brian Salomon01b476a2018-01-23 11:06:41 -050084 if (options.fDisableDriverCorrectnessWorkarounds) {
Chris Daltona8fbeba2019-03-30 00:31:23 -060085 SkASSERT(!fDriverBlacklistCCPR);
Brian Salomon01b476a2018-01-23 11:06:41 -050086 SkASSERT(!fAvoidStencilBuffers);
87 SkASSERT(!fAdvBlendEqBlacklist);
Michael Ludwiga21d1962019-01-11 15:26:22 -050088 SkASSERT(!fPerformColorClearsAsDraws);
89 SkASSERT(!fPerformStencilClearsAsDraws);
90 // Don't check the partial-clear workaround, since that is a backend limitation, not a
91 // driver workaround (it just so happens the fallbacks are the same).
92 }
93 if (GrContextOptions::Enable::kNo == options.fUseDrawInsteadOfClear) {
94 fPerformColorClearsAsDraws = false;
95 fPerformStencilClearsAsDraws = false;
96 } else if (GrContextOptions::Enable::kYes == options.fUseDrawInsteadOfClear) {
97 fPerformColorClearsAsDraws = true;
98 fPerformStencilClearsAsDraws = true;
Brian Salomon01b476a2018-01-23 11:06:41 -050099 }
100
Chris Daltona8fbeba2019-03-30 00:31:23 -0600101 fAllowCoverageCounting = !options.fDisableCoverageCountingPaths;
102
bsalomon4ee6bd82015-05-27 13:23:23 -0700103 fMaxTextureSize = SkTMin(fMaxTextureSize, options.fMaxTextureSizeOverride);
Brian Osman195c05b2017-08-30 15:14:04 -0400104 fMaxTileSize = fMaxTextureSize;
105#if GR_TEST_UTILS
bsalomon8c07b7a2015-11-02 11:36:52 -0800106 // If the max tile override is zero, it means we should use the max texture size.
Brian Osman195c05b2017-08-30 15:14:04 -0400107 if (options.fMaxTileSizeOverride && options.fMaxTileSizeOverride < fMaxTextureSize) {
bsalomon8c07b7a2015-11-02 11:36:52 -0800108 fMaxTileSize = options.fMaxTileSizeOverride;
109 }
Chris Dalton040238b2017-12-18 14:22:34 -0700110 if (options.fSuppressGeometryShaders) {
111 fShaderCaps->fGeometryShaderSupport = false;
112 }
Brian Osman195c05b2017-08-30 15:14:04 -0400113#endif
Chris Dalton1e6c5b82019-06-17 14:16:49 -0600114
csmartdalton28341fa2016-08-17 10:00:21 -0700115 if (fMaxWindowRectangles > GrWindowRectangles::kMaxWindows) {
csmartdalton7535f412016-08-23 06:51:00 -0700116 SkDebugf("WARNING: capping window rectangles at %i. HW advertises support for %i.\n",
117 GrWindowRectangles::kMaxWindows, fMaxWindowRectangles);
csmartdalton28341fa2016-08-17 10:00:21 -0700118 fMaxWindowRectangles = GrWindowRectangles::kMaxWindows;
119 }
Chris Dalton1e6c5b82019-06-17 14:16:49 -0600120
121 fPreferredInternalSampleCount = options.fPreferredInternalSampleCount;
122
Eric Karl5c779752017-05-08 12:02:07 -0700123 fAvoidStencilBuffers = options.fAvoidStencilBuffers;
Adrienne Walkerab7181d2018-05-14 14:02:03 -0700124
125 fDriverBugWorkarounds.applyOverrides(options.fDriverBugWorkarounds);
bsalomon4ee6bd82015-05-27 13:23:23 -0700126}
127
Kevin Lubickf4def342018-10-04 12:52:50 -0400128
129#ifdef SK_ENABLE_DUMP_GPU
130static const char* pixel_config_name(GrPixelConfig config) {
131 switch (config) {
132 case kUnknown_GrPixelConfig: return "Unknown";
133 case kAlpha_8_GrPixelConfig: return "Alpha8";
134 case kAlpha_8_as_Alpha_GrPixelConfig: return "Alpha8_asAlpha";
135 case kAlpha_8_as_Red_GrPixelConfig: return "Alpha8_asRed";
136 case kGray_8_GrPixelConfig: return "Gray8";
137 case kGray_8_as_Lum_GrPixelConfig: return "Gray8_asLum";
138 case kGray_8_as_Red_GrPixelConfig: return "Gray8_asRed";
139 case kRGB_565_GrPixelConfig: return "RGB565";
140 case kRGBA_4444_GrPixelConfig: return "RGBA444";
141 case kRGBA_8888_GrPixelConfig: return "RGBA8888";
142 case kRGB_888_GrPixelConfig: return "RGB888";
Greg Danielf259b8b2019-02-14 09:03:43 -0500143 case kRGB_888X_GrPixelConfig: return "RGB888X";
Jim Van Verth69e57852018-12-05 13:38:59 -0500144 case kRG_88_GrPixelConfig: return "RG88";
Kevin Lubickf4def342018-10-04 12:52:50 -0400145 case kBGRA_8888_GrPixelConfig: return "BGRA8888";
146 case kSRGBA_8888_GrPixelConfig: return "SRGBA8888";
147 case kSBGRA_8888_GrPixelConfig: return "SBGRA8888";
148 case kRGBA_1010102_GrPixelConfig: return "RGBA1010102";
149 case kRGBA_float_GrPixelConfig: return "RGBAFloat";
150 case kRG_float_GrPixelConfig: return "RGFloat";
151 case kAlpha_half_GrPixelConfig: return "AlphaHalf";
152 case kAlpha_half_as_Red_GrPixelConfig: return "AlphaHalf_asRed";
153 case kRGBA_half_GrPixelConfig: return "RGBAHalf";
Brian Osmand0626aa2019-03-11 15:28:06 -0400154 case kRGBA_half_Clamped_GrPixelConfig: return "RGBAHalfClamped";
Jim Van Verth1676cb92019-01-15 13:24:45 -0500155 case kRGB_ETC1_GrPixelConfig: return "RGBETC1";
Robert Phillipsf83c4682019-06-13 16:49:21 +0000156 // Experimental (for P016 and P010)
Robert Phillipsfe18de52019-06-06 17:21:50 -0400157 case kR_16_GrPixelConfig: return "R16";
158 case kRG_1616_GrPixelConfig: return "RG1616";
Kevin Lubickf4def342018-10-04 12:52:50 -0400159 }
160 SK_ABORT("Invalid pixel config");
161 return "<invalid>";
162}
163
bsalomondc47ff72015-05-26 12:16:59 -0700164static SkString map_flags_to_string(uint32_t flags) {
165 SkString str;
166 if (GrCaps::kNone_MapFlags == flags) {
167 str = "none";
168 } else {
169 SkASSERT(GrCaps::kCanMap_MapFlag & flags);
170 SkDEBUGCODE(flags &= ~GrCaps::kCanMap_MapFlag);
171 str = "can_map";
172
173 if (GrCaps::kSubset_MapFlag & flags) {
174 str.append(" partial");
175 } else {
176 str.append(" full");
177 }
178 SkDEBUGCODE(flags &= ~GrCaps::kSubset_MapFlag);
Brian Salomon105d7c22019-04-16 13:46:14 -0400179 if (GrCaps::kAsyncRead_MapFlag & flags) {
180 str.append(" async_read");
181 } else {
182 str.append(" sync_read");
183 }
184 SkDEBUGCODE(flags &= ~GrCaps::kAsyncRead_MapFlag);
bsalomondc47ff72015-05-26 12:16:59 -0700185 }
186 SkASSERT(0 == flags); // Make sure we handled all the flags.
187 return str;
188}
189
Brian Osman71a18892017-08-10 10:23:25 -0400190void GrCaps::dumpJSON(SkJSONWriter* writer) const {
191 writer->beginObject();
jvanverth84741b32016-09-30 08:39:02 -0700192
Brian Osman71a18892017-08-10 10:23:25 -0400193 writer->appendBool("MIP Map Support", fMipMapSupport);
194 writer->appendBool("NPOT Texture Tile Support", fNPOTTextureTileSupport);
195 writer->appendBool("sRGB Support", fSRGBSupport);
196 writer->appendBool("sRGB Write Control", fSRGBWriteControl);
Brian Osman71a18892017-08-10 10:23:25 -0400197 writer->appendBool("Discard Render Target Support", fDiscardRenderTargetSupport);
198 writer->appendBool("Reuse Scratch Textures", fReuseScratchTextures);
199 writer->appendBool("Reuse Scratch Buffers", fReuseScratchBuffers);
200 writer->appendBool("Gpu Tracing Support", fGpuTracingSupport);
201 writer->appendBool("Oversized Stencil Support", fOversizedStencilSupport);
202 writer->appendBool("Texture Barrier Support", fTextureBarrierSupport);
Robert Phillips7f861922018-01-30 13:13:42 +0000203 writer->appendBool("Sample Locations Support", fSampleLocationsSupport);
Brian Osman71a18892017-08-10 10:23:25 -0400204 writer->appendBool("Multisample disable support", fMultisampleDisableSupport);
205 writer->appendBool("Instance Attrib Support", fInstanceAttribSupport);
206 writer->appendBool("Uses Mixed Samples", fUsesMixedSamples);
Chris Dalton27059d32018-01-23 14:06:50 -0700207 writer->appendBool("Use primitive restart", fUsePrimitiveRestart);
Brian Osman71a18892017-08-10 10:23:25 -0400208 writer->appendBool("Prefer client-side dynamic buffers", fPreferClientSideDynamicBuffers);
Chris Dalton344e9032017-12-11 15:42:09 -0700209 writer->appendBool("Prefer fullscreen clears", fPreferFullscreenClears);
Brian Osman71a18892017-08-10 10:23:25 -0400210 writer->appendBool("Must clear buffer memory", fMustClearUploadedBufferData);
Kevin Lubick61a5f0a2019-03-28 09:47:15 -0400211 writer->appendBool("Should initialize textures", fShouldInitializeTextures);
Greg Danielb2acf0a2018-09-12 09:17:11 -0400212 writer->appendBool("Supports importing AHardwareBuffers", fSupportsAHardwareBufferImages);
Brian Osman71a18892017-08-10 10:23:25 -0400213 writer->appendBool("Fence sync support", fFenceSyncSupport);
Brian Salomon9ff5acb2019-05-08 09:04:47 -0400214 writer->appendBool("Semaphore support", fSemaphoreSupport);
Brian Osman71a18892017-08-10 10:23:25 -0400215 writer->appendBool("Cross context texture support", fCrossContextTextureSupport);
Brian Osman499bf1a2018-09-17 11:32:42 -0400216 writer->appendBool("Half float vertex attribute support", fHalfFloatVertexAttributeSupport);
Brian Salomonf7232642018-09-19 08:58:08 -0400217 writer->appendBool("Specify GeometryProcessor textures as a dynamic state array",
218 fDynamicStateArrayGeometryProcessorTextureSupport);
Michael Ludwiga21d1962019-01-11 15:26:22 -0500219 writer->appendBool("Use draws for partial clears", fPerformPartialClearsAsDraws);
220 writer->appendBool("Use draws for color clears", fPerformColorClearsAsDraws);
221 writer->appendBool("Use draws for stencil clip clears", fPerformStencilClearsAsDraws);
Chris Daltona8fbeba2019-03-30 00:31:23 -0600222 writer->appendBool("Allow coverage counting shortcuts", fAllowCoverageCounting);
Brian Salomone05ba5a2019-04-08 11:59:07 -0400223 writer->appendBool("Supports transfer buffers", fTransferBufferSupport);
Chris Daltona8fbeba2019-03-30 00:31:23 -0600224 writer->appendBool("Blacklist CCPR on current driver [workaround]", fDriverBlacklistCCPR);
Michael Ludwiga21d1962019-01-11 15:26:22 -0500225 writer->appendBool("Clamp-to-border", fClampToBorderSupport);
Brian Osman71a18892017-08-10 10:23:25 -0400226
Brian Osman71a18892017-08-10 10:23:25 -0400227 writer->appendBool("Prefer VRAM Use over flushes [workaround]", fPreferVRAMUseOverFlushes);
Chris Dalton0dffbab2019-03-27 13:08:50 -0600228 writer->appendBool("Prefer more triangles over sample mask [MSAA only]",
229 fPreferTrianglesOverSampleMask);
Robert Phillipsf2ec0242018-03-01 16:51:25 -0500230 writer->appendBool("Avoid stencil buffers [workaround]", fAvoidStencilBuffers);
robertphillips63926682015-08-20 09:39:02 -0700231
cdalton1dd05422015-06-12 09:01:18 -0700232 if (this->advancedBlendEquationSupport()) {
Brian Osman71a18892017-08-10 10:23:25 -0400233 writer->appendHexU32("Advanced Blend Equation Blacklist", fAdvBlendEqBlacklist);
cdalton1dd05422015-06-12 09:01:18 -0700234 }
bsalomondc47ff72015-05-26 12:16:59 -0700235
Brian Osman71a18892017-08-10 10:23:25 -0400236 writer->appendS32("Max Vertex Attributes", fMaxVertexAttributes);
237 writer->appendS32("Max Texture Size", fMaxTextureSize);
238 writer->appendS32("Max Render Target Size", fMaxRenderTargetSize);
Chris Dalton2612bae2018-02-22 13:41:37 -0700239 writer->appendS32("Max Preferred Render Target Size", fMaxPreferredRenderTargetSize);
Brian Osman71a18892017-08-10 10:23:25 -0400240 writer->appendS32("Max Window Rectangles", fMaxWindowRectangles);
Chris Dalton1e6c5b82019-06-17 14:16:49 -0600241 writer->appendS32("Preferred Sample Count for Internal MSAA and Mixed Samples",
242 fPreferredInternalSampleCount);
bsalomondc47ff72015-05-26 12:16:59 -0700243
244 static const char* kBlendEquationSupportNames[] = {
245 "Basic",
246 "Advanced",
247 "Advanced Coherent",
248 };
249 GR_STATIC_ASSERT(0 == kBasic_BlendEquationSupport);
250 GR_STATIC_ASSERT(1 == kAdvanced_BlendEquationSupport);
251 GR_STATIC_ASSERT(2 == kAdvancedCoherent_BlendEquationSupport);
252 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kBlendEquationSupportNames) == kLast_BlendEquationSupport + 1);
253
Brian Osman71a18892017-08-10 10:23:25 -0400254 writer->appendString("Blend Equation Support",
255 kBlendEquationSupportNames[fBlendEquationSupport]);
256 writer->appendString("Map Buffer Support", map_flags_to_string(fMapBufferFlags).c_str());
bsalomondc47ff72015-05-26 12:16:59 -0700257
Brian Salomonbdecacf2018-02-02 20:32:49 -0500258 SkASSERT(!this->isConfigRenderable(kUnknown_GrPixelConfig));
Brian Osman0f450ac2017-08-09 20:45:52 +0000259 SkASSERT(!this->isConfigTexturable(kUnknown_GrPixelConfig));
Brian Osman175af0d2017-08-09 14:29:36 -0400260
Brian Osman71a18892017-08-10 10:23:25 -0400261 writer->beginArray("configs");
262
263 for (size_t i = 1; i < kGrPixelConfigCnt; ++i) {
Brian Osman0f450ac2017-08-09 20:45:52 +0000264 GrPixelConfig config = static_cast<GrPixelConfig>(i);
Brian Osman80488222017-08-10 13:29:30 -0400265 writer->beginObject(nullptr, false);
Brian Osman71a18892017-08-10 10:23:25 -0400266 writer->appendString("name", pixel_config_name(config));
Brian Salomonbdecacf2018-02-02 20:32:49 -0500267 writer->appendS32("max sample count", this->maxRenderTargetSampleCount(config));
Brian Osman71a18892017-08-10 10:23:25 -0400268 writer->appendBool("texturable", this->isConfigTexturable(config));
269 writer->endObject();
Brian Osman0f450ac2017-08-09 20:45:52 +0000270 }
Brian Osman175af0d2017-08-09 14:29:36 -0400271
Brian Osman71a18892017-08-10 10:23:25 -0400272 writer->endArray();
273
274 this->onDumpJSON(writer);
275
276 writer->appendName("shaderCaps");
277 this->shaderCaps()->dumpJSON(writer);
278
279 writer->endObject();
bsalomondc47ff72015-05-26 12:16:59 -0700280}
Kevin Lubickf4def342018-10-04 12:52:50 -0400281#else
282void GrCaps::dumpJSON(SkJSONWriter* writer) const { }
283#endif
Greg Danielf5d87582017-12-18 14:48:15 -0500284
Brian Salomonc67c31c2018-12-06 10:00:03 -0500285bool GrCaps::surfaceSupportsWritePixels(const GrSurface* surface) const {
286 return surface->readOnly() ? false : this->onSurfaceSupportsWritePixels(surface);
287}
288
Brian Salomon26de56e2019-04-10 12:14:26 -0400289size_t GrCaps::transferFromOffsetAlignment(GrColorType bufferColorType) const {
Brian Salomone05ba5a2019-04-08 11:59:07 -0400290 if (!this->transferBufferSupport()) {
Brian Salomon26de56e2019-04-10 12:14:26 -0400291 return 0;
Brian Salomone05ba5a2019-04-08 11:59:07 -0400292 }
Brian Salomon26de56e2019-04-10 12:14:26 -0400293 size_t result = this->onTransferFromOffsetAlignment(bufferColorType);
294 if (!result) {
295 return 0;
296 }
297 // It's very convenient to access 1 byte-per-channel 32 bitvRGB/RGBA color types as uint32_t.
298 // Make those aligned reads out of the buffer even if the underlying API doesn't require it.
299 auto componentFlags = GrColorTypeComponentFlags(bufferColorType);
300 if ((componentFlags == kRGBA_SkColorTypeComponentFlags ||
301 componentFlags == kRGB_SkColorTypeComponentFlags) &&
302 GrColorTypeBytesPerPixel(bufferColorType) == 4) {
303 switch (result & 0b11) {
304 // offset alignment already a multiple of 4
305 case 0: return result;
306 // offset alignment is a multiple of 2 but not 4.
307 case 2: return 2 * result;
308 // offset alignment is not a multiple of 2.
309 default: return 4 * result;
310 }
311 }
312 return result;
Brian Salomone05ba5a2019-04-08 11:59:07 -0400313}
314
Brian Salomonc67c31c2018-12-06 10:00:03 -0500315bool GrCaps::canCopySurface(const GrSurfaceProxy* dst, const GrSurfaceProxy* src,
316 const SkIRect& srcRect, const SkIPoint& dstPoint) const {
317 return dst->readOnly() ? false : this->onCanCopySurface(dst, src, srcRect, dstPoint);
318}
319
Brian Salomonbdecacf2018-02-02 20:32:49 -0500320bool GrCaps::validateSurfaceDesc(const GrSurfaceDesc& desc, GrMipMapped mipped) const {
321 if (!this->isConfigTexturable(desc.fConfig)) {
322 return false;
323 }
324
Brian Salomon57111332018-02-05 15:55:54 -0500325 if (GrMipMapped::kYes == mipped && !this->mipMapSupport()) {
326 return false;
Brian Salomonbdecacf2018-02-02 20:32:49 -0500327 }
328
329 if (desc.fWidth < 1 || desc.fHeight < 1) {
330 return false;
331 }
332
333 if (SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag)) {
334 if (0 == this->getRenderTargetSampleCount(desc.fSampleCnt, desc.fConfig)) {
335 return false;
336 }
337 int maxRTSize = this->maxRenderTargetSize();
338 if (desc.fWidth > maxRTSize || desc.fHeight > maxRTSize) {
339 return false;
340 }
341 } else {
342 // We currently do not support multisampled textures
343 if (desc.fSampleCnt > 1) {
344 return false;
345 }
346 int maxSize = this->maxTextureSize();
347 if (desc.fWidth > maxSize || desc.fHeight > maxSize) {
348 return false;
349 }
350 }
351
352 return true;
353}
Timothy Liang036fdfe2018-06-28 15:50:36 -0400354
Greg Daniel4065d452018-11-16 15:43:41 -0500355GrBackendFormat GrCaps::getBackendFormatFromColorType(SkColorType ct) const {
356 return this->getBackendFormatFromGrColorType(SkColorTypeToGrColorType(ct), GrSRGBEncoded::kNo);
357}