blob: 91c7e41f5abb1f651700a77c64fda1c666d4b161 [file] [log] [blame]
reed@google.comac10a2d2010-12-22 21:39:39 +00001/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00002 * Copyright 2010 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.
reed@google.comac10a2d2010-12-22 21:39:39 +00006 */
7
epoger@google.comec3ed6a2011-07-28 14:26:00 +00008
Mike Kleinc0bd9f92019-04-23 12:05:21 -05009#include "src/gpu/GrGpu.h"
bsalomon@google.com558a75b2011-08-08 17:01:14 +000010
Mike Kleinc0bd9f92019-04-23 12:05:21 -050011#include "include/gpu/GrBackendSemaphore.h"
12#include "include/gpu/GrBackendSurface.h"
13#include "include/gpu/GrContext.h"
14#include "src/core/SkMathPriv.h"
Greg Danielf91aeb22019-06-18 09:58:02 -040015#include "src/gpu/GrAuditTrail.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050016#include "src/gpu/GrCaps.h"
17#include "src/gpu/GrContextPriv.h"
Brian Salomonbb8dde82019-06-27 10:52:13 -040018#include "src/gpu/GrDataUtils.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050019#include "src/gpu/GrGpuResourcePriv.h"
20#include "src/gpu/GrMesh.h"
21#include "src/gpu/GrPathRendering.h"
22#include "src/gpu/GrPipeline.h"
23#include "src/gpu/GrRenderTargetPriv.h"
24#include "src/gpu/GrResourceCache.h"
25#include "src/gpu/GrResourceProvider.h"
26#include "src/gpu/GrSemaphore.h"
27#include "src/gpu/GrStencilAttachment.h"
28#include "src/gpu/GrStencilSettings.h"
29#include "src/gpu/GrSurfacePriv.h"
30#include "src/gpu/GrTexturePriv.h"
31#include "src/gpu/GrTextureProxyPriv.h"
32#include "src/gpu/GrTracing.h"
33#include "src/utils/SkJSONWriter.h"
bsalomoncb8979d2015-05-05 09:51:38 -070034
bsalomon@google.comd302f142011-03-03 13:54:13 +000035////////////////////////////////////////////////////////////////////////////////
reed@google.comac10a2d2010-12-22 21:39:39 +000036
Brian Salomone2826ab2019-06-04 15:58:31 -040037GrGpu::GrGpu(GrContext* context) : fResetBits(kAll_GrBackendState), fContext(context) {}
reed@google.comac10a2d2010-12-22 21:39:39 +000038
bsalomoned0bcad2015-05-04 10:36:42 -070039GrGpu::~GrGpu() {}
bsalomon1d89ddc2014-08-19 14:20:58 -070040
bsalomon6e2aad42016-04-01 11:54:31 -070041void GrGpu::disconnect(DisconnectType) {}
reed@google.comac10a2d2010-12-22 21:39:39 +000042
bsalomon@google.comd302f142011-03-03 13:54:13 +000043////////////////////////////////////////////////////////////////////////////////
reed@google.comac10a2d2010-12-22 21:39:39 +000044
Greg Daniel8f5bbda2018-06-08 17:22:23 -040045bool GrGpu::IsACopyNeededForRepeatWrapMode(const GrCaps* caps, GrTextureProxy* texProxy,
46 int width, int height,
47 GrSamplerState::Filter filter,
48 GrTextureProducer::CopyParams* copyParams,
49 SkScalar scaleAdjust[2]) {
50 if (!caps->npotTextureTileSupport() &&
Greg Daniel09c94002018-06-08 22:11:51 +000051 (!SkIsPow2(width) || !SkIsPow2(height))) {
52 SkASSERT(scaleAdjust);
53 copyParams->fWidth = GrNextPow2(width);
54 copyParams->fHeight = GrNextPow2(height);
55 SkASSERT(scaleAdjust);
56 scaleAdjust[0] = ((SkScalar)copyParams->fWidth) / width;
57 scaleAdjust[1] = ((SkScalar)copyParams->fHeight) / height;
Greg Daniel8f5bbda2018-06-08 17:22:23 -040058 switch (filter) {
Greg Daniel09c94002018-06-08 22:11:51 +000059 case GrSamplerState::Filter::kNearest:
60 copyParams->fFilter = GrSamplerState::Filter::kNearest;
61 break;
62 case GrSamplerState::Filter::kBilerp:
63 case GrSamplerState::Filter::kMipMap:
64 // We are only ever scaling up so no reason to ever indicate kMipMap.
65 copyParams->fFilter = GrSamplerState::Filter::kBilerp;
66 break;
67 }
68 return true;
69 }
Robert Phillipsabf7b762018-03-21 12:13:37 -040070
71 if (texProxy) {
72 // If the texture format itself doesn't support repeat wrap mode or mipmapping (and
73 // those capabilities are required) force a copy.
Brian Salomonfd98c2c2018-07-31 17:25:29 -040074 if (texProxy->hasRestrictedSampling()) {
Robert Phillipsabf7b762018-03-21 12:13:37 -040075 copyParams->fFilter = GrSamplerState::Filter::kNearest;
76 copyParams->fWidth = texProxy->width();
77 copyParams->fHeight = texProxy->height();
78 return true;
79 }
80 }
81
bsalomon100b8f82015-10-28 08:37:44 -070082 return false;
bsalomon045802d2015-10-20 07:58:01 -070083}
84
Greg Daniel8f5bbda2018-06-08 17:22:23 -040085bool GrGpu::IsACopyNeededForMips(const GrCaps* caps, const GrTextureProxy* texProxy,
86 GrSamplerState::Filter filter,
87 GrTextureProducer::CopyParams* copyParams) {
88 SkASSERT(texProxy);
89 bool willNeedMips = GrSamplerState::Filter::kMipMap == filter && caps->mipMapSupport();
90 // If the texture format itself doesn't support mipmapping (and those capabilities are required)
91 // force a copy.
92 if (willNeedMips && texProxy->mipMapped() == GrMipMapped::kNo) {
93 copyParams->fFilter = GrSamplerState::Filter::kNearest;
94 copyParams->fWidth = texProxy->width();
95 copyParams->fHeight = texProxy->height();
96 return true;
97 }
98
99 return false;
100}
101
Brian Salomon1047a492019-07-02 12:25:21 -0400102static bool validate_levels(int w, int h, const GrMipLevel texels[], int mipLevelCount, int bpp,
Brian Salomona3e29962019-07-16 11:52:08 -0400103 const GrCaps* caps, bool mustHaveDataForAllLevels = false) {
Brian Salomon1047a492019-07-02 12:25:21 -0400104 SkASSERT(mipLevelCount > 0);
105 bool hasBasePixels = texels[0].fPixels;
106 int levelsWithPixelsCnt = 0;
107 for (int currentMipLevel = 0; currentMipLevel < mipLevelCount; ++currentMipLevel) {
108 if (texels[currentMipLevel].fPixels) {
109 const size_t minRowBytes = w * bpp;
110 if (caps->writePixelsRowBytesSupport()) {
111 if (texels[currentMipLevel].fRowBytes < minRowBytes) {
112 return false;
113 }
114 if (texels[currentMipLevel].fRowBytes % bpp) {
115 return false;
116 }
117 } else {
118 if (texels[currentMipLevel].fRowBytes != minRowBytes) {
119 return false;
120 }
121 }
122 ++levelsWithPixelsCnt;
123 }
124 if (w == 1 && h == 1) {
125 if (currentMipLevel != mipLevelCount - 1) {
126 return false;
127 }
128 } else {
129 w = std::max(w / 2, 1);
130 h = std::max(h / 2, 1);
131 }
132 }
133 // Either just a base layer or a full stack is required.
134 if (mipLevelCount != 1 && (w != 1 || h != 1)) {
135 return false;
136 }
137 // Can specify just the base, all levels, or no levels.
138 if (!hasBasePixels) {
139 return levelsWithPixelsCnt == 0;
140 }
Brian Salomona3e29962019-07-16 11:52:08 -0400141 if (levelsWithPixelsCnt == 1 && !mustHaveDataForAllLevels) {
142 return true;
143 }
144 return levelsWithPixelsCnt == mipLevelCount;
Brian Salomon1047a492019-07-02 12:25:21 -0400145}
146
Brian Salomon81536f22019-08-08 16:30:49 -0400147sk_sp<GrTexture> GrGpu::createTexture(const GrSurfaceDesc& desc,
148 const GrBackendFormat& format,
149 GrRenderable renderable,
150 int renderTargetSampleCnt,
151 SkBudgeted budgeted,
152 GrProtected isProtected,
153 const GrMipLevel texels[],
154 int mipLevelCount) {
Brian Salomone39526b2019-06-24 16:35:53 -0400155 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Brian Salomon81536f22019-08-08 16:30:49 -0400156 if (this->caps()->isFormatCompressed(format)) {
Brian Salomonbb8dde82019-06-27 10:52:13 -0400157 // Call GrGpu::createCompressedTexture.
158 return nullptr;
159 }
cblume55f2d2d2016-02-26 13:20:48 -0800160
Brian Salomonbdecacf2018-02-02 20:32:49 -0500161 GrMipMapped mipMapped = mipLevelCount > 1 ? GrMipMapped::kYes : GrMipMapped::kNo;
Greg Daniel6fa62e22019-08-07 15:52:37 -0400162 if (!this->caps()->validateSurfaceParams({desc.fWidth, desc.fHeight}, format, desc.fConfig,
163 renderable, renderTargetSampleCnt, mipMapped)) {
halcanary96fcdcc2015-08-27 07:41:13 -0700164 return nullptr;
egdaniel8c9b6f12015-05-12 13:36:30 -0700165 }
166
Brian Salomonf2c2ba92019-07-17 09:59:59 -0400167 if (renderable == GrRenderable::kYes) {
Brian Salomon27b4d8d2019-07-22 14:23:45 -0400168 renderTargetSampleCnt =
Greg Daniel6fa62e22019-08-07 15:52:37 -0400169 this->caps()->getRenderTargetSampleCount(renderTargetSampleCnt, format);
Brian Salomonbdecacf2018-02-02 20:32:49 -0500170 }
Brian Salomond17b4a62017-05-23 16:53:47 -0400171 // Attempt to catch un- or wrongly initialized sample counts.
Brian Salomon27b4d8d2019-07-22 14:23:45 -0400172 SkASSERT(renderTargetSampleCnt > 0 && renderTargetSampleCnt <= 64);
egdanielb0e1be22015-04-22 13:27:39 -0700173
Brian Salomona3e29962019-07-16 11:52:08 -0400174 bool mustHaveDataForAllLevels = this->caps()->createTextureMustSpecifyAllLevels();
Brian Salomon1047a492019-07-02 12:25:21 -0400175 if (mipLevelCount) {
Brian Salomon1047a492019-07-02 12:25:21 -0400176 int bpp = GrBytesPerPixel(desc.fConfig);
Brian Salomona3e29962019-07-16 11:52:08 -0400177 if (!validate_levels(desc.fWidth, desc.fHeight, texels, mipLevelCount, bpp, this->caps(),
178 mustHaveDataForAllLevels)) {
Brian Salomon1047a492019-07-02 12:25:21 -0400179 return nullptr;
180 }
Brian Salomona3e29962019-07-16 11:52:08 -0400181 } else if (mustHaveDataForAllLevels) {
182 return nullptr;
Brian Salomond17b4a62017-05-23 16:53:47 -0400183 }
184
Robert Phillips92de6312017-05-23 07:43:48 -0400185 this->handleDirtyContext();
Brian Salomon81536f22019-08-08 16:30:49 -0400186 sk_sp<GrTexture> tex = this->onCreateTexture(desc,
187 format,
188 renderable,
189 renderTargetSampleCnt,
190 budgeted,
191 isProtected,
192 texels,
193 mipLevelCount);
bsalomonb12ea412015-02-02 21:19:50 -0800194 if (tex) {
Brian Salomonf2c2ba92019-07-17 09:59:59 -0400195 if (!this->caps()->reuseScratchTextures() && renderable == GrRenderable::kNo) {
cblume55f2d2d2016-02-26 13:20:48 -0800196 tex->resourcePriv().removeScratchKey();
197 }
bsalomonb12ea412015-02-02 21:19:50 -0800198 fStats.incTextureCreates();
Robert Phillips590533f2017-07-11 14:22:35 -0400199 if (mipLevelCount) {
cblume55f2d2d2016-02-26 13:20:48 -0800200 if (texels[0].fPixels) {
201 fStats.incTextureUploads();
202 }
bsalomonb12ea412015-02-02 21:19:50 -0800203 }
Brian Salomon81536f22019-08-08 16:30:49 -0400204 SkASSERT(tex->backendFormat() == format);
Chris Dalton3f7932e2019-08-19 00:39:13 -0600205 SkASSERT(!tex || GrRenderable::kNo == renderable || tex->asRenderTarget());
206 if (renderTargetSampleCnt > 1 && !this->caps()->msaaResolvesAutomatically()) {
207 SkASSERT(GrRenderable::kYes == renderable);
208 tex->asRenderTarget()->setRequiresManualMSAAResolve();
209 }
bsalomonb12ea412015-02-02 21:19:50 -0800210 }
bsalomon@google.com81c3f8d2011-08-03 15:18:33 +0000211 return tex;
212}
213
Brian Salomon4eb38b72019-08-05 12:58:39 -0400214sk_sp<GrTexture> GrGpu::createTexture(const GrSurfaceDesc& desc, const GrBackendFormat& format,
215 GrRenderable renderable, int renderTargetSampleCnt,
216 SkBudgeted budgeted, GrProtected isProtected) {
217 return this->createTexture(desc, format, renderable, renderTargetSampleCnt, budgeted,
218 isProtected, nullptr, 0);
Brian Salomonc7dced52019-07-18 15:02:01 +0000219}
220
Brian Salomonbb8dde82019-06-27 10:52:13 -0400221sk_sp<GrTexture> GrGpu::createCompressedTexture(int width, int height,
Greg Daniel7bfc9132019-08-14 14:23:53 -0400222 const GrBackendFormat& format,
Brian Salomonbb8dde82019-06-27 10:52:13 -0400223 SkImage::CompressionType compressionType,
224 SkBudgeted budgeted, const void* data,
225 size_t dataSize) {
Greg Daniel7bfc9132019-08-14 14:23:53 -0400226 // If we ever add a new CompressionType, we should add a check here to make sure the
227 // GrBackendFormat and CompressionType are compatible with eachother.
228 SkASSERT(compressionType == SkImage::kETC1_CompressionType);
229
Brian Salomonbb8dde82019-06-27 10:52:13 -0400230 this->handleDirtyContext();
231 if (width < 1 || width > this->caps()->maxTextureSize() ||
232 height < 1 || height > this->caps()->maxTextureSize()) {
233 return nullptr;
234 }
Brian Salomona3e29962019-07-16 11:52:08 -0400235 // Note if we relax the requirement that data must be provided then we must check
236 // caps()->shouldInitializeTextures() here.
Brian Salomonbb8dde82019-06-27 10:52:13 -0400237 if (!data) {
238 return nullptr;
239 }
Greg Daniel7bfc9132019-08-14 14:23:53 -0400240 if (!this->caps()->isFormatTexturable(format)) {
Brian Salomonbb8dde82019-06-27 10:52:13 -0400241 return nullptr;
242 }
243 if (dataSize < GrCompressedDataSize(compressionType, width, height)) {
244 return nullptr;
245 }
Greg Daniel7bfc9132019-08-14 14:23:53 -0400246 return this->onCreateCompressedTexture(width, height, format, compressionType, budgeted, data);
Brian Salomonbb8dde82019-06-27 10:52:13 -0400247}
248
Greg Daniel7ef28f32017-04-20 16:41:55 +0000249sk_sp<GrTexture> GrGpu::wrapBackendTexture(const GrBackendTexture& backendTex,
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400250 GrColorType colorType,
Brian Salomonfa2ebea2019-01-24 15:58:58 -0500251 GrWrapOwnership ownership, GrWrapCacheable cacheable,
252 GrIOType ioType) {
Brian Salomonc67c31c2018-12-06 10:00:03 -0500253 SkASSERT(ioType != kWrite_GrIOType);
bsalomon@google.come269f212011-11-07 13:29:52 +0000254 this->handleDirtyContext();
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400255
256 const GrCaps* caps = this->caps();
257 SkASSERT(caps);
258
Greg Daniel7bfc9132019-08-14 14:23:53 -0400259 if (!caps->isFormatTexturable(backendTex.getBackendFormat())) {
bsalomon5b30c6f2015-12-17 14:17:34 -0800260 return nullptr;
261 }
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400262 if (backendTex.width() > caps->maxTextureSize() ||
263 backendTex.height() > caps->maxTextureSize()) {
bsalomon5b30c6f2015-12-17 14:17:34 -0800264 return nullptr;
265 }
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400266
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400267 return this->onWrapBackendTexture(backendTex, colorType, ownership, cacheable, ioType);
Brian Salomond17f6582017-07-19 18:28:58 -0400268}
Eric Karl5c779752017-05-08 12:02:07 -0700269
Brian Salomond17f6582017-07-19 18:28:58 -0400270sk_sp<GrTexture> GrGpu::wrapRenderableBackendTexture(const GrBackendTexture& backendTex,
Robert Phillips0902c982019-07-16 07:47:56 -0400271 int sampleCnt, GrColorType colorType,
272 GrWrapOwnership ownership,
Brian Salomonaa6ca0a2019-01-24 16:03:07 -0500273 GrWrapCacheable cacheable) {
Brian Salomond17f6582017-07-19 18:28:58 -0400274 this->handleDirtyContext();
Brian Salomonbdecacf2018-02-02 20:32:49 -0500275 if (sampleCnt < 1) {
276 return nullptr;
277 }
Robert Phillips0902c982019-07-16 07:47:56 -0400278
279 const GrCaps* caps = this->caps();
280
Greg Daniel7bfc9132019-08-14 14:23:53 -0400281 if (!caps->isFormatTexturable(backendTex.getBackendFormat()) ||
Greg Daniel6fa62e22019-08-07 15:52:37 -0400282 !caps->isFormatRenderable(backendTex.getBackendFormat(), sampleCnt)) {
Brian Salomond17f6582017-07-19 18:28:58 -0400283 return nullptr;
284 }
285
Robert Phillips0902c982019-07-16 07:47:56 -0400286 if (backendTex.width() > caps->maxRenderTargetSize() ||
287 backendTex.height() > caps->maxRenderTargetSize()) {
Brian Salomond17f6582017-07-19 18:28:58 -0400288 return nullptr;
289 }
Robert Phillips0902c982019-07-16 07:47:56 -0400290 sk_sp<GrTexture> tex = this->onWrapRenderableBackendTexture(backendTex, sampleCnt, colorType,
291 ownership, cacheable);
Greg Daniele3204862018-04-16 11:24:10 -0400292 SkASSERT(!tex || tex->asRenderTarget());
Chris Dalton3f7932e2019-08-19 00:39:13 -0600293 if (tex && sampleCnt > 1 && !caps->msaaResolvesAutomatically()) {
294 tex->asRenderTarget()->setRequiresManualMSAAResolve();
295 }
bungeman6bd52842016-10-27 09:30:08 -0700296 return tex;
bsalomon@google.come269f212011-11-07 13:29:52 +0000297}
298
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400299sk_sp<GrRenderTarget> GrGpu::wrapBackendRenderTarget(const GrBackendRenderTarget& backendRT,
300 GrColorType colorType) {
301 this->handleDirtyContext();
302
303 const GrCaps* caps = this->caps();
304
Greg Daniel6fa62e22019-08-07 15:52:37 -0400305 if (!caps->isFormatRenderable(backendRT.getBackendFormat(), backendRT.sampleCnt())) {
bsalomon5b30c6f2015-12-17 14:17:34 -0800306 return nullptr;
307 }
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400308
309 return this->onWrapBackendRenderTarget(backendRT, colorType);
bsalomon@google.come269f212011-11-07 13:29:52 +0000310}
311
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400312sk_sp<GrRenderTarget> GrGpu::wrapBackendTextureAsRenderTarget(const GrBackendTexture& backendTex,
313 int sampleCnt,
314 GrColorType colorType) {
Brian Salomonbdecacf2018-02-02 20:32:49 -0500315 this->handleDirtyContext();
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400316
317 const GrCaps* caps = this->caps();
318
319 int maxSize = caps->maxTextureSize();
320 if (backendTex.width() > maxSize || backendTex.height() > maxSize) {
321 return nullptr;
322 }
323
Greg Daniel6fa62e22019-08-07 15:52:37 -0400324 if (!caps->isFormatRenderable(backendTex.getBackendFormat(), sampleCnt)) {
Robert Phillipsc80b0e92019-07-23 10:27:09 -0400325 return nullptr;
326 }
Robert Phillips1cd1ed82019-07-23 13:21:01 -0400327
Chris Dalton3f7932e2019-08-19 00:39:13 -0600328 auto rt = this->onWrapBackendTextureAsRenderTarget(backendTex, sampleCnt, colorType);
329 if (rt && sampleCnt > 1 && !this->caps()->msaaResolvesAutomatically()) {
330 rt->setRequiresManualMSAAResolve();
331 }
332 return rt;
ericrkf7b8b8a2016-02-24 14:49:51 -0800333}
334
Greg Danielb46add82019-01-02 14:51:29 -0500335sk_sp<GrRenderTarget> GrGpu::wrapVulkanSecondaryCBAsRenderTarget(const SkImageInfo& imageInfo,
336 const GrVkDrawableInfo& vkInfo) {
337 return this->onWrapVulkanSecondaryCBAsRenderTarget(imageInfo, vkInfo);
338}
339
340sk_sp<GrRenderTarget> GrGpu::onWrapVulkanSecondaryCBAsRenderTarget(const SkImageInfo& imageInfo,
341 const GrVkDrawableInfo& vkInfo) {
342 // This is only supported on Vulkan so we default to returning nullptr here
343 return nullptr;
344}
345
Brian Salomondbf70722019-02-07 11:31:24 -0500346sk_sp<GrGpuBuffer> GrGpu::createBuffer(size_t size, GrGpuBufferType intendedType,
347 GrAccessPattern accessPattern, const void* data) {
Brian Salomone39526b2019-06-24 16:35:53 -0400348 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000349 this->handleDirtyContext();
Brian Salomondbf70722019-02-07 11:31:24 -0500350 sk_sp<GrGpuBuffer> buffer = this->onCreateBuffer(size, intendedType, accessPattern, data);
robertphillips1b8e1b52015-06-24 06:54:10 -0700351 if (!this->caps()->reuseScratchBuffers()) {
cdalton397536c2016-03-25 12:15:03 -0700352 buffer->resourcePriv().removeScratchKey();
robertphillips1b8e1b52015-06-24 06:54:10 -0700353 }
cdalton397536c2016-03-25 12:15:03 -0700354 return buffer;
jvanverth73063dc2015-12-03 09:15:47 -0800355}
356
Greg Daniel46cfbc62019-06-07 11:43:30 -0400357bool GrGpu::copySurface(GrSurface* dst, GrSurface* src, const SkIRect& srcRect,
358 const SkIPoint& dstPoint, bool canDiscardOutsideDstRect) {
Brian Salomone39526b2019-06-24 16:35:53 -0400359 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
joshualitt1cbdcde2015-08-21 11:53:29 -0700360 SkASSERT(dst && src);
Brian Salomonc67c31c2018-12-06 10:00:03 -0500361
362 if (dst->readOnly()) {
363 return false;
364 }
365
joshualitt1cbdcde2015-08-21 11:53:29 -0700366 this->handleDirtyContext();
Brian Salomonc67c31c2018-12-06 10:00:03 -0500367
Greg Daniel46cfbc62019-06-07 11:43:30 -0400368 return this->onCopySurface(dst, src, srcRect, dstPoint, canDiscardOutsideDstRect);
joshualitt1cbdcde2015-08-21 11:53:29 -0700369}
370
Brian Salomona6948702018-06-01 15:33:20 -0400371bool GrGpu::readPixels(GrSurface* surface, int left, int top, int width, int height,
Brian Salomonf77c1462019-08-01 15:19:29 -0400372 GrColorType surfaceColorType, GrColorType dstColorType, void* buffer,
373 size_t rowBytes) {
Brian Salomone39526b2019-06-24 16:35:53 -0400374 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Brian Salomonbf7b6202016-11-11 16:08:03 -0500375 SkASSERT(surface);
Greg Daniel7bfc9132019-08-14 14:23:53 -0400376 SkASSERT(this->caps()->isFormatTexturable(surface->backendFormat()));
Brian Salomonbf7b6202016-11-11 16:08:03 -0500377
Brian Salomon1d435302019-07-01 13:05:28 -0400378 auto subRect = SkIRect::MakeXYWH(left, top, width, height);
379 auto bounds = SkIRect::MakeWH(surface->width(), surface->height());
380 if (!bounds.contains(subRect)) {
egdaniel6d901da2015-07-30 12:02:15 -0700381 return false;
382 }
383
Brian Salomon1047a492019-07-02 12:25:21 -0400384 size_t minRowBytes = SkToSizeT(GrColorTypeBytesPerPixel(dstColorType) * width);
385 if (!this->caps()->readPixelsRowBytesSupport()) {
386 if (rowBytes != minRowBytes) {
387 return false;
388 }
389 } else {
390 if (rowBytes < minRowBytes) {
391 return false;
392 }
393 if (rowBytes % GrColorTypeBytesPerPixel(dstColorType)) {
394 return false;
395 }
396 }
397
Brian Salomon1c53a9f2019-08-12 14:10:12 -0400398 if (this->caps()->isFormatCompressed(surface->backendFormat())) {
Jim Van Verth1676cb92019-01-15 13:24:45 -0500399 return false;
400 }
401
Brian Salomonbf7b6202016-11-11 16:08:03 -0500402 this->handleDirtyContext();
403
Brian Salomonf77c1462019-08-01 15:19:29 -0400404 return this->onReadPixels(surface, left, top, width, height, surfaceColorType, dstColorType,
405 buffer, rowBytes);
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000406}
407
Brian Salomona9b04b92018-06-01 15:04:28 -0400408bool GrGpu::writePixels(GrSurface* surface, int left, int top, int width, int height,
Brian Salomonf77c1462019-08-01 15:19:29 -0400409 GrColorType surfaceColorType, GrColorType srcColorType,
410 const GrMipLevel texels[], int mipLevelCount) {
Brian Salomone39526b2019-06-24 16:35:53 -0400411 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Brian Salomonbf7b6202016-11-11 16:08:03 -0500412 SkASSERT(surface);
Greg Daniel7bfc9132019-08-14 14:23:53 -0400413 SkASSERT(this->caps()->isFormatTexturableAndUploadable(surfaceColorType,
414 surface->backendFormat()));
Brian Salomonc67c31c2018-12-06 10:00:03 -0500415
416 if (surface->readOnly()) {
417 return false;
418 }
419
Brian Salomon1047a492019-07-02 12:25:21 -0400420 if (mipLevelCount == 0) {
421 return false;
422 } else if (mipLevelCount == 1) {
Greg Daniel660cc992017-06-26 14:55:05 -0400423 // We require that if we are not mipped, then the write region is contained in the surface
Brian Salomon1d435302019-07-01 13:05:28 -0400424 auto subRect = SkIRect::MakeXYWH(left, top, width, height);
425 auto bounds = SkIRect::MakeWH(surface->width(), surface->height());
Greg Daniel660cc992017-06-26 14:55:05 -0400426 if (!bounds.contains(subRect)) {
427 return false;
428 }
429 } else if (0 != left || 0 != top || width != surface->width() || height != surface->height()) {
430 // We require that if the texels are mipped, than the write region is the entire surface
431 return false;
432 }
Robert Phillipsb7b7e5f2017-05-22 13:23:19 -0400433
Brian Salomonb28cb682019-07-26 12:48:47 -0400434 size_t bpp = GrColorTypeBytesPerPixel(srcColorType);
Brian Salomon1047a492019-07-02 12:25:21 -0400435 if (!validate_levels(width, height, texels, mipLevelCount, bpp, this->caps())) {
436 return false;
cblume55f2d2d2016-02-26 13:20:48 -0800437 }
jvanverth2dc29942015-09-01 07:16:46 -0700438
bsalomon@google.com6f379512011-11-16 20:36:03 +0000439 this->handleDirtyContext();
Brian Salomonf77c1462019-08-01 15:19:29 -0400440 if (this->onWritePixels(surface, left, top, width, height, surfaceColorType, srcColorType,
441 texels, mipLevelCount)) {
jvanverth900bd4a2016-04-29 13:53:12 -0700442 SkIRect rect = SkIRect::MakeXYWH(left, top, width, height);
Brian Salomona9b04b92018-06-01 15:04:28 -0400443 this->didWriteToSurface(surface, kTopLeft_GrSurfaceOrigin, &rect, mipLevelCount);
bsalomonb12ea412015-02-02 21:19:50 -0800444 fStats.incTextureUploads();
445 return true;
446 }
447 return false;
bsalomon@google.com6f379512011-11-16 20:36:03 +0000448}
449
Brian Salomone05ba5a2019-04-08 11:59:07 -0400450bool GrGpu::transferPixelsTo(GrTexture* texture, int left, int top, int width, int height,
Brian Salomonf77c1462019-08-01 15:19:29 -0400451 GrColorType textureColorType, GrColorType bufferColorType,
452 GrGpuBuffer* transferBuffer, size_t offset, size_t rowBytes) {
Brian Salomone39526b2019-06-24 16:35:53 -0400453 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Brian Salomonc67c31c2018-12-06 10:00:03 -0500454 SkASSERT(texture);
cdalton397536c2016-03-25 12:15:03 -0700455 SkASSERT(transferBuffer);
Greg Daniel7bfc9132019-08-14 14:23:53 -0400456 SkASSERT(this->caps()->isFormatTexturableAndUploadable(textureColorType,
457 texture->backendFormat()));
jvanverth17aa0472016-01-05 10:41:27 -0800458
Brian Salomonc67c31c2018-12-06 10:00:03 -0500459 if (texture->readOnly()) {
460 return false;
461 }
462
Greg Daniel660cc992017-06-26 14:55:05 -0400463 // We require that the write region is contained in the texture
464 SkIRect subRect = SkIRect::MakeXYWH(left, top, width, height);
465 SkIRect bounds = SkIRect::MakeWH(texture->width(), texture->height());
466 if (!bounds.contains(subRect)) {
467 return false;
468 }
469
Brian Salomonb28cb682019-07-26 12:48:47 -0400470 size_t bpp = GrColorTypeBytesPerPixel(bufferColorType);
Brian Salomon1047a492019-07-02 12:25:21 -0400471 if (this->caps()->writePixelsRowBytesSupport()) {
472 if (rowBytes < SkToSizeT(bpp * width)) {
473 return false;
474 }
475 if (rowBytes % bpp) {
476 return false;
477 }
478 } else {
479 if (rowBytes != SkToSizeT(bpp * width)) {
480 return false;
481 }
482 }
483
jvanverth17aa0472016-01-05 10:41:27 -0800484 this->handleDirtyContext();
Brian Salomonf77c1462019-08-01 15:19:29 -0400485 if (this->onTransferPixelsTo(texture, left, top, width, height, textureColorType,
486 bufferColorType, transferBuffer, offset, rowBytes)) {
jvanverth900bd4a2016-04-29 13:53:12 -0700487 SkIRect rect = SkIRect::MakeXYWH(left, top, width, height);
Brian Salomon1fabd512018-02-09 09:54:25 -0500488 this->didWriteToSurface(texture, kTopLeft_GrSurfaceOrigin, &rect);
jvanverth17aa0472016-01-05 10:41:27 -0800489 fStats.incTransfersToTexture();
jvanverth84741b32016-09-30 08:39:02 -0700490
jvanverth17aa0472016-01-05 10:41:27 -0800491 return true;
492 }
493 return false;
494}
495
Brian Salomon26de56e2019-04-10 12:14:26 -0400496bool GrGpu::transferPixelsFrom(GrSurface* surface, int left, int top, int width, int height,
Brian Salomonf77c1462019-08-01 15:19:29 -0400497 GrColorType surfaceColorType, GrColorType bufferColorType,
498 GrGpuBuffer* transferBuffer, size_t offset) {
Brian Salomone39526b2019-06-24 16:35:53 -0400499 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Brian Salomone05ba5a2019-04-08 11:59:07 -0400500 SkASSERT(surface);
501 SkASSERT(transferBuffer);
Greg Daniel7bfc9132019-08-14 14:23:53 -0400502 SkASSERT(this->caps()->isFormatTexturable(surface->backendFormat()));
Brian Salomonf77c1462019-08-01 15:19:29 -0400503
Greg Danielba88ab62019-07-26 09:14:01 -0400504#ifdef SK_DEBUG
Brian Salomon1c53a9f2019-08-12 14:10:12 -0400505 auto supportedRead = this->caps()->supportedReadPixelsColorType(
506 surfaceColorType, surface->backendFormat(), bufferColorType);
Greg Danielba88ab62019-07-26 09:14:01 -0400507 SkASSERT(supportedRead.fOffsetAlignmentForTransferBuffer);
508 SkASSERT(offset % supportedRead.fOffsetAlignmentForTransferBuffer == 0);
509#endif
Brian Salomone05ba5a2019-04-08 11:59:07 -0400510
511 // We require that the write region is contained in the texture
512 SkIRect subRect = SkIRect::MakeXYWH(left, top, width, height);
513 SkIRect bounds = SkIRect::MakeWH(surface->width(), surface->height());
514 if (!bounds.contains(subRect)) {
515 return false;
516 }
517
518 this->handleDirtyContext();
Brian Salomonf77c1462019-08-01 15:19:29 -0400519 if (this->onTransferPixelsFrom(surface, left, top, width, height, surfaceColorType,
520 bufferColorType, transferBuffer, offset)) {
Brian Salomone05ba5a2019-04-08 11:59:07 -0400521 fStats.incTransfersFromSurface();
Brian Salomon26de56e2019-04-10 12:14:26 -0400522 return true;
Brian Salomone05ba5a2019-04-08 11:59:07 -0400523 }
Brian Salomon26de56e2019-04-10 12:14:26 -0400524 return false;
Brian Salomone05ba5a2019-04-08 11:59:07 -0400525}
526
Brian Salomon930f9392018-06-20 16:25:26 -0400527bool GrGpu::regenerateMipMapLevels(GrTexture* texture) {
Brian Salomone39526b2019-06-24 16:35:53 -0400528 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Brian Salomon930f9392018-06-20 16:25:26 -0400529 SkASSERT(texture);
530 SkASSERT(this->caps()->mipMapSupport());
531 SkASSERT(texture->texturePriv().mipMapped() == GrMipMapped::kYes);
532 SkASSERT(texture->texturePriv().mipMapsAreDirty());
533 SkASSERT(!texture->asRenderTarget() || !texture->asRenderTarget()->needsResolve());
Brian Salomonc67c31c2018-12-06 10:00:03 -0500534 if (texture->readOnly()) {
535 return false;
536 }
Brian Salomon930f9392018-06-20 16:25:26 -0400537 if (this->onRegenerateMipMapLevels(texture)) {
538 texture->texturePriv().markMipMapsClean();
539 return true;
540 }
541 return false;
542}
543
Brian Salomon1f05d452019-02-08 12:33:08 -0500544void GrGpu::resetTextureBindings() {
545 this->handleDirtyContext();
546 this->onResetTextureBindings();
547}
548
Brian Salomon1fabd512018-02-09 09:54:25 -0500549void GrGpu::resolveRenderTarget(GrRenderTarget* target) {
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000550 SkASSERT(target);
bsalomon@google.com75f9f252012-01-31 13:35:56 +0000551 this->handleDirtyContext();
Brian Salomon1fabd512018-02-09 09:54:25 -0500552 this->onResolveRenderTarget(target);
bsalomon@google.com75f9f252012-01-31 13:35:56 +0000553}
554
Brian Salomon1fabd512018-02-09 09:54:25 -0500555void GrGpu::didWriteToSurface(GrSurface* surface, GrSurfaceOrigin origin, const SkIRect* bounds,
556 uint32_t mipLevels) const {
jvanverth900bd4a2016-04-29 13:53:12 -0700557 SkASSERT(surface);
Brian Salomonc67c31c2018-12-06 10:00:03 -0500558 SkASSERT(!surface->readOnly());
jvanverth900bd4a2016-04-29 13:53:12 -0700559 // Mark any MIP chain and resolve buffer as dirty if and only if there is a non-empty bounds.
560 if (nullptr == bounds || !bounds->isEmpty()) {
561 if (GrRenderTarget* target = surface->asRenderTarget()) {
Brian Salomon1fabd512018-02-09 09:54:25 -0500562 SkIRect flippedBounds;
563 if (kBottomLeft_GrSurfaceOrigin == origin && bounds) {
564 flippedBounds = {bounds->fLeft, surface->height() - bounds->fBottom,
565 bounds->fRight, surface->height() - bounds->fTop};
566 bounds = &flippedBounds;
567 }
jvanverth900bd4a2016-04-29 13:53:12 -0700568 target->flagAsNeedingResolve(bounds);
569 }
570 GrTexture* texture = surface->asTexture();
571 if (texture && 1 == mipLevels) {
Greg Daniel0fc4d2d2017-10-12 11:23:36 -0400572 texture->texturePriv().markMipMapsDirty();
jvanverth900bd4a2016-04-29 13:53:12 -0700573 }
574 }
575}
576
Chris Dalton8c4cafd2019-04-15 19:14:36 -0600577int GrGpu::findOrAssignSamplePatternKey(GrRenderTarget* renderTarget) {
Chris Daltond7291ba2019-03-07 14:17:03 -0700578 SkASSERT(this->caps()->sampleLocationsSupport());
Chris Daltoneffee202019-07-01 22:28:03 -0600579 SkASSERT(renderTarget->numSamples() > 1 ||
580 (renderTarget->renderTargetPriv().getStencilAttachment() &&
581 renderTarget->renderTargetPriv().getStencilAttachment()->numSamples() > 1));
Chris Daltond7291ba2019-03-07 14:17:03 -0700582
583 SkSTArray<16, SkPoint> sampleLocations;
Chris Dalton8c4cafd2019-04-15 19:14:36 -0600584 this->querySampleLocations(renderTarget, &sampleLocations);
Chris Daltond7291ba2019-03-07 14:17:03 -0700585 return fSamplePatternDictionary.findOrAssignSamplePatternKey(sampleLocations);
586}
587
Brian Salomonf9a1fdf2019-05-09 10:30:12 -0400588GrSemaphoresSubmitted GrGpu::finishFlush(GrSurfaceProxy* proxies[],
589 int n,
Greg Danielbae71212019-03-01 15:24:35 -0500590 SkSurface::BackendSurfaceAccess access,
Greg Daniel797efca2019-05-09 14:04:20 -0400591 const GrFlushInfo& info,
592 const GrPrepareForExternalIORequests& externalRequests) {
Brian Salomone39526b2019-06-24 16:35:53 -0400593 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Greg Danield2073452018-12-07 11:20:33 -0500594 this->stats()->incNumFinishFlushes();
Robert Phillips9da87e02019-02-04 13:26:26 -0500595 GrResourceProvider* resourceProvider = fContext->priv().resourceProvider();
Robert Phillips6be756b2018-01-16 15:07:54 -0500596
Brian Salomon9ff5acb2019-05-08 09:04:47 -0400597 if (this->caps()->semaphoreSupport()) {
Greg Daniele6bfb7d2019-04-17 15:26:11 -0400598 for (int i = 0; i < info.fNumSemaphores; ++i) {
Greg Daniel51316782017-08-02 15:10:09 +0000599 sk_sp<GrSemaphore> semaphore;
Greg Daniele6bfb7d2019-04-17 15:26:11 -0400600 if (info.fSignalSemaphores[i].isInitialized()) {
Robert Phillips6be756b2018-01-16 15:07:54 -0500601 semaphore = resourceProvider->wrapBackendSemaphore(
Greg Daniele6bfb7d2019-04-17 15:26:11 -0400602 info.fSignalSemaphores[i],
603 GrResourceProvider::SemaphoreWrapType::kWillSignal,
Greg Daniel17b7c052018-01-09 13:55:33 -0500604 kBorrow_GrWrapOwnership);
Greg Daniel51316782017-08-02 15:10:09 +0000605 } else {
Robert Phillips6be756b2018-01-16 15:07:54 -0500606 semaphore = resourceProvider->makeSemaphore(false);
Greg Daniel51316782017-08-02 15:10:09 +0000607 }
Greg Daniel858e12c2018-12-06 11:11:37 -0500608 this->insertSemaphore(semaphore);
Greg Daniel51316782017-08-02 15:10:09 +0000609
Greg Daniele6bfb7d2019-04-17 15:26:11 -0400610 if (!info.fSignalSemaphores[i].isInitialized()) {
611 info.fSignalSemaphores[i] = semaphore->backendSemaphore();
Greg Daniel51316782017-08-02 15:10:09 +0000612 }
613 }
614 }
Greg Daniel797efca2019-05-09 14:04:20 -0400615 this->onFinishFlush(proxies, n, access, info, externalRequests);
Brian Salomon9ff5acb2019-05-08 09:04:47 -0400616 return this->caps()->semaphoreSupport() ? GrSemaphoresSubmitted::kYes
Greg Daniel51316782017-08-02 15:10:09 +0000617 : GrSemaphoresSubmitted::kNo;
618}
Brian Osman71a18892017-08-10 10:23:25 -0400619
Kevin Lubickf4def342018-10-04 12:52:50 -0400620#ifdef SK_ENABLE_DUMP_GPU
Brian Osman71a18892017-08-10 10:23:25 -0400621void GrGpu::dumpJSON(SkJSONWriter* writer) const {
622 writer->beginObject();
623
624 // TODO: Is there anything useful in the base class to dump here?
625
626 this->onDumpJSON(writer);
627
628 writer->endObject();
629}
Kevin Lubickf4def342018-10-04 12:52:50 -0400630#else
631void GrGpu::dumpJSON(SkJSONWriter* writer) const { }
632#endif
Robert Phillips646f6372018-09-25 09:31:10 -0400633
Robert Phillipsf0ced622019-05-16 09:06:25 -0400634#if GR_TEST_UTILS
635
Robert Phillipsdbaf3172019-02-06 15:12:53 -0500636#if GR_GPU_STATS
637void GrGpu::Stats::dump(SkString* out) {
638 out->appendf("Render Target Binds: %d\n", fRenderTargetBinds);
639 out->appendf("Shader Compilations: %d\n", fShaderCompilations);
640 out->appendf("Textures Created: %d\n", fTextureCreates);
641 out->appendf("Texture Uploads: %d\n", fTextureUploads);
642 out->appendf("Transfers to Texture: %d\n", fTransfersToTexture);
Brian Salomone05ba5a2019-04-08 11:59:07 -0400643 out->appendf("Transfers from Surface: %d\n", fTransfersFromSurface);
Robert Phillipsdbaf3172019-02-06 15:12:53 -0500644 out->appendf("Stencil Buffer Creates: %d\n", fStencilAttachmentCreates);
645 out->appendf("Number of draws: %d\n", fNumDraws);
Robert Phillipsf9fcf7f2019-07-11 09:03:27 -0400646 out->appendf("Number of Scratch Textures reused %d\n", fNumScratchTexturesReused);
Robert Phillipsdbaf3172019-02-06 15:12:53 -0500647}
648
649void GrGpu::Stats::dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values) {
650 keys->push_back(SkString("render_target_binds")); values->push_back(fRenderTargetBinds);
651 keys->push_back(SkString("shader_compilations")); values->push_back(fShaderCompilations);
Robert Phillipsdbaf3172019-02-06 15:12:53 -0500652}
653
654#endif
655
Robert Phillips646f6372018-09-25 09:31:10 -0400656#endif