blob: addbc152cf69e7f64cf41c9eb16a4918c2004721 [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
Robert Phillips67d52cf2017-06-05 13:38:13 -0400147sk_sp<GrTexture> GrGpu::createTexture(const GrSurfaceDesc& origDesc, SkBudgeted budgeted,
Brian Salomon58389b92018-03-07 13:01:25 -0500148 const GrMipLevel texels[], int mipLevelCount) {
Brian Salomone39526b2019-06-24 16:35:53 -0400149 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Brian Salomonbb8dde82019-06-27 10:52:13 -0400150 if (GrPixelConfigIsCompressed(origDesc.fConfig)) {
151 // Call GrGpu::createCompressedTexture.
152 return nullptr;
153 }
cblume55f2d2d2016-02-26 13:20:48 -0800154 GrSurfaceDesc desc = origDesc;
155
Brian Salomonbdecacf2018-02-02 20:32:49 -0500156 GrMipMapped mipMapped = mipLevelCount > 1 ? GrMipMapped::kYes : GrMipMapped::kNo;
157 if (!this->caps()->validateSurfaceDesc(desc, mipMapped)) {
halcanary96fcdcc2015-08-27 07:41:13 -0700158 return nullptr;
egdaniel8c9b6f12015-05-12 13:36:30 -0700159 }
160
Brian Salomonbdecacf2018-02-02 20:32:49 -0500161 bool isRT = desc.fFlags & kRenderTarget_GrSurfaceFlag;
162 if (isRT) {
163 desc.fSampleCnt = this->caps()->getRenderTargetSampleCount(desc.fSampleCnt, desc.fConfig);
164 }
Brian Salomond17b4a62017-05-23 16:53:47 -0400165 // Attempt to catch un- or wrongly initialized sample counts.
Brian Salomonbdecacf2018-02-02 20:32:49 -0500166 SkASSERT(desc.fSampleCnt > 0 && desc.fSampleCnt <= 64);
egdanielb0e1be22015-04-22 13:27:39 -0700167
Brian Salomona3e29962019-07-16 11:52:08 -0400168 bool mustHaveDataForAllLevels = this->caps()->createTextureMustSpecifyAllLevels();
Brian Salomon1047a492019-07-02 12:25:21 -0400169 if (mipLevelCount) {
Brian Salomon1047a492019-07-02 12:25:21 -0400170 int bpp = GrBytesPerPixel(desc.fConfig);
Brian Salomona3e29962019-07-16 11:52:08 -0400171 if (!validate_levels(desc.fWidth, desc.fHeight, texels, mipLevelCount, bpp, this->caps(),
172 mustHaveDataForAllLevels)) {
Brian Salomon1047a492019-07-02 12:25:21 -0400173 return nullptr;
174 }
Brian Salomona3e29962019-07-16 11:52:08 -0400175 } else if (mustHaveDataForAllLevels) {
176 return nullptr;
Brian Salomond17b4a62017-05-23 16:53:47 -0400177 }
178
Robert Phillips92de6312017-05-23 07:43:48 -0400179 this->handleDirtyContext();
Brian Salomon58389b92018-03-07 13:01:25 -0500180 sk_sp<GrTexture> tex = this->onCreateTexture(desc, budgeted, texels, mipLevelCount);
bsalomonb12ea412015-02-02 21:19:50 -0800181 if (tex) {
Brian Salomonbdecacf2018-02-02 20:32:49 -0500182 if (!this->caps()->reuseScratchTextures() && !isRT) {
cblume55f2d2d2016-02-26 13:20:48 -0800183 tex->resourcePriv().removeScratchKey();
184 }
bsalomonb12ea412015-02-02 21:19:50 -0800185 fStats.incTextureCreates();
Robert Phillips590533f2017-07-11 14:22:35 -0400186 if (mipLevelCount) {
cblume55f2d2d2016-02-26 13:20:48 -0800187 if (texels[0].fPixels) {
188 fStats.incTextureUploads();
189 }
bsalomonb12ea412015-02-02 21:19:50 -0800190 }
191 }
bsalomon@google.com81c3f8d2011-08-03 15:18:33 +0000192 return tex;
193}
194
Robert Phillips646e4292017-06-13 12:44:56 -0400195sk_sp<GrTexture> GrGpu::createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted) {
Brian Salomon58389b92018-03-07 13:01:25 -0500196 return this->createTexture(desc, budgeted, nullptr, 0);
Robert Phillips646e4292017-06-13 12:44:56 -0400197}
198
Brian Salomonbb8dde82019-06-27 10:52:13 -0400199sk_sp<GrTexture> GrGpu::createCompressedTexture(int width, int height,
200 SkImage::CompressionType compressionType,
201 SkBudgeted budgeted, const void* data,
202 size_t dataSize) {
203 this->handleDirtyContext();
204 if (width < 1 || width > this->caps()->maxTextureSize() ||
205 height < 1 || height > this->caps()->maxTextureSize()) {
206 return nullptr;
207 }
Brian Salomona3e29962019-07-16 11:52:08 -0400208 // Note if we relax the requirement that data must be provided then we must check
209 // caps()->shouldInitializeTextures() here.
Brian Salomonbb8dde82019-06-27 10:52:13 -0400210 if (!data) {
211 return nullptr;
212 }
213 if (!this->caps()->isConfigTexturable(GrCompressionTypePixelConfig(compressionType))) {
214 return nullptr;
215 }
216 if (dataSize < GrCompressedDataSize(compressionType, width, height)) {
217 return nullptr;
218 }
219 return this->onCreateCompressedTexture(width, height, compressionType, budgeted, data);
220}
221
Greg Daniel7ef28f32017-04-20 16:41:55 +0000222sk_sp<GrTexture> GrGpu::wrapBackendTexture(const GrBackendTexture& backendTex,
Brian Salomonfa2ebea2019-01-24 15:58:58 -0500223 GrWrapOwnership ownership, GrWrapCacheable cacheable,
224 GrIOType ioType) {
Brian Salomonc67c31c2018-12-06 10:00:03 -0500225 SkASSERT(ioType != kWrite_GrIOType);
bsalomon@google.come269f212011-11-07 13:29:52 +0000226 this->handleDirtyContext();
Jim Van Verth1676cb92019-01-15 13:24:45 -0500227 SkASSERT(this->caps());
Greg Daniel7ef28f32017-04-20 16:41:55 +0000228 if (!this->caps()->isConfigTexturable(backendTex.config())) {
bsalomon5b30c6f2015-12-17 14:17:34 -0800229 return nullptr;
230 }
Brian Salomond17f6582017-07-19 18:28:58 -0400231 if (backendTex.width() > this->caps()->maxTextureSize() ||
232 backendTex.height() > this->caps()->maxTextureSize()) {
bsalomon5b30c6f2015-12-17 14:17:34 -0800233 return nullptr;
234 }
Brian Salomonfa2ebea2019-01-24 15:58:58 -0500235 return this->onWrapBackendTexture(backendTex, ownership, cacheable, ioType);
Brian Salomond17f6582017-07-19 18:28:58 -0400236}
Eric Karl5c779752017-05-08 12:02:07 -0700237
Brian Salomond17f6582017-07-19 18:28:58 -0400238sk_sp<GrTexture> GrGpu::wrapRenderableBackendTexture(const GrBackendTexture& backendTex,
Robert Phillips0902c982019-07-16 07:47:56 -0400239 int sampleCnt, GrColorType colorType,
240 GrWrapOwnership ownership,
Brian Salomonaa6ca0a2019-01-24 16:03:07 -0500241 GrWrapCacheable cacheable) {
Brian Salomond17f6582017-07-19 18:28:58 -0400242 this->handleDirtyContext();
Brian Salomonbdecacf2018-02-02 20:32:49 -0500243 if (sampleCnt < 1) {
244 return nullptr;
245 }
Robert Phillips0902c982019-07-16 07:47:56 -0400246
247 const GrCaps* caps = this->caps();
248
249 SkASSERT(GrCaps::AreConfigsCompatible(backendTex.config(),
250 caps->getConfigFromBackendFormat(
251 backendTex.getBackendFormat(),
252 colorType)));
253
254 if (!caps->isFormatTexturable(colorType, backendTex.getBackendFormat()) ||
255 !caps->getRenderTargetSampleCount(sampleCnt, colorType, backendTex.getBackendFormat())) {
Brian Salomond17f6582017-07-19 18:28:58 -0400256 return nullptr;
257 }
258
Robert Phillips0902c982019-07-16 07:47:56 -0400259 if (backendTex.width() > caps->maxRenderTargetSize() ||
260 backendTex.height() > caps->maxRenderTargetSize()) {
Brian Salomond17f6582017-07-19 18:28:58 -0400261 return nullptr;
262 }
Robert Phillips0902c982019-07-16 07:47:56 -0400263 sk_sp<GrTexture> tex = this->onWrapRenderableBackendTexture(backendTex, sampleCnt, colorType,
264 ownership, cacheable);
Greg Daniele3204862018-04-16 11:24:10 -0400265 SkASSERT(!tex || tex->asRenderTarget());
bungeman6bd52842016-10-27 09:30:08 -0700266 return tex;
bsalomon@google.come269f212011-11-07 13:29:52 +0000267}
268
Robert Phillipsb0e93a22017-08-29 08:26:54 -0400269sk_sp<GrRenderTarget> GrGpu::wrapBackendRenderTarget(const GrBackendRenderTarget& backendRT) {
Brian Salomonbdecacf2018-02-02 20:32:49 -0500270 if (0 == this->caps()->getRenderTargetSampleCount(backendRT.sampleCnt(), backendRT.config())) {
bsalomon5b30c6f2015-12-17 14:17:34 -0800271 return nullptr;
272 }
bsalomon@google.come269f212011-11-07 13:29:52 +0000273 this->handleDirtyContext();
Robert Phillipsb0e93a22017-08-29 08:26:54 -0400274 return this->onWrapBackendRenderTarget(backendRT);
bsalomon@google.come269f212011-11-07 13:29:52 +0000275}
276
Greg Daniel7ef28f32017-04-20 16:41:55 +0000277sk_sp<GrRenderTarget> GrGpu::wrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
Greg Daniel7ef28f32017-04-20 16:41:55 +0000278 int sampleCnt) {
Brian Salomonbdecacf2018-02-02 20:32:49 -0500279 if (0 == this->caps()->getRenderTargetSampleCount(sampleCnt, tex.config())) {
ericrkf7b8b8a2016-02-24 14:49:51 -0800280 return nullptr;
281 }
282 int maxSize = this->caps()->maxTextureSize();
Greg Daniel7ef28f32017-04-20 16:41:55 +0000283 if (tex.width() > maxSize || tex.height() > maxSize) {
ericrkf7b8b8a2016-02-24 14:49:51 -0800284 return nullptr;
285 }
Brian Salomonbdecacf2018-02-02 20:32:49 -0500286 this->handleDirtyContext();
Robert Phillipsb0e93a22017-08-29 08:26:54 -0400287 return this->onWrapBackendTextureAsRenderTarget(tex, sampleCnt);
ericrkf7b8b8a2016-02-24 14:49:51 -0800288}
289
Greg Danielb46add82019-01-02 14:51:29 -0500290sk_sp<GrRenderTarget> GrGpu::wrapVulkanSecondaryCBAsRenderTarget(const SkImageInfo& imageInfo,
291 const GrVkDrawableInfo& vkInfo) {
292 return this->onWrapVulkanSecondaryCBAsRenderTarget(imageInfo, vkInfo);
293}
294
295sk_sp<GrRenderTarget> GrGpu::onWrapVulkanSecondaryCBAsRenderTarget(const SkImageInfo& imageInfo,
296 const GrVkDrawableInfo& vkInfo) {
297 // This is only supported on Vulkan so we default to returning nullptr here
298 return nullptr;
299}
300
Brian Salomondbf70722019-02-07 11:31:24 -0500301sk_sp<GrGpuBuffer> GrGpu::createBuffer(size_t size, GrGpuBufferType intendedType,
302 GrAccessPattern accessPattern, const void* data) {
Brian Salomone39526b2019-06-24 16:35:53 -0400303 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000304 this->handleDirtyContext();
Brian Salomondbf70722019-02-07 11:31:24 -0500305 sk_sp<GrGpuBuffer> buffer = this->onCreateBuffer(size, intendedType, accessPattern, data);
robertphillips1b8e1b52015-06-24 06:54:10 -0700306 if (!this->caps()->reuseScratchBuffers()) {
cdalton397536c2016-03-25 12:15:03 -0700307 buffer->resourcePriv().removeScratchKey();
robertphillips1b8e1b52015-06-24 06:54:10 -0700308 }
cdalton397536c2016-03-25 12:15:03 -0700309 return buffer;
jvanverth73063dc2015-12-03 09:15:47 -0800310}
311
Greg Daniel46cfbc62019-06-07 11:43:30 -0400312bool GrGpu::copySurface(GrSurface* dst, GrSurface* src, const SkIRect& srcRect,
313 const SkIPoint& dstPoint, bool canDiscardOutsideDstRect) {
Brian Salomone39526b2019-06-24 16:35:53 -0400314 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
joshualitt1cbdcde2015-08-21 11:53:29 -0700315 SkASSERT(dst && src);
Brian Salomonc67c31c2018-12-06 10:00:03 -0500316
317 if (dst->readOnly()) {
318 return false;
319 }
320
joshualitt1cbdcde2015-08-21 11:53:29 -0700321 this->handleDirtyContext();
Brian Salomonc67c31c2018-12-06 10:00:03 -0500322
Greg Daniel46cfbc62019-06-07 11:43:30 -0400323 return this->onCopySurface(dst, src, srcRect, dstPoint, canDiscardOutsideDstRect);
joshualitt1cbdcde2015-08-21 11:53:29 -0700324}
325
Brian Salomona6948702018-06-01 15:33:20 -0400326bool GrGpu::readPixels(GrSurface* surface, int left, int top, int width, int height,
327 GrColorType dstColorType, void* buffer, size_t rowBytes) {
Brian Salomone39526b2019-06-24 16:35:53 -0400328 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Brian Salomonbf7b6202016-11-11 16:08:03 -0500329 SkASSERT(surface);
330
Brian Salomon1d435302019-07-01 13:05:28 -0400331 auto subRect = SkIRect::MakeXYWH(left, top, width, height);
332 auto bounds = SkIRect::MakeWH(surface->width(), surface->height());
333 if (!bounds.contains(subRect)) {
egdaniel6d901da2015-07-30 12:02:15 -0700334 return false;
335 }
336
Brian Salomon1047a492019-07-02 12:25:21 -0400337 size_t minRowBytes = SkToSizeT(GrColorTypeBytesPerPixel(dstColorType) * width);
338 if (!this->caps()->readPixelsRowBytesSupport()) {
339 if (rowBytes != minRowBytes) {
340 return false;
341 }
342 } else {
343 if (rowBytes < minRowBytes) {
344 return false;
345 }
346 if (rowBytes % GrColorTypeBytesPerPixel(dstColorType)) {
347 return false;
348 }
349 }
350
Jim Van Verth1676cb92019-01-15 13:24:45 -0500351 if (GrPixelConfigIsCompressed(surface->config())) {
352 return false;
353 }
354
Brian Salomonbf7b6202016-11-11 16:08:03 -0500355 this->handleDirtyContext();
356
Brian Salomona6948702018-06-01 15:33:20 -0400357 return this->onReadPixels(surface, left, top, width, height, dstColorType, buffer, rowBytes);
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000358}
359
Brian Salomona9b04b92018-06-01 15:04:28 -0400360bool GrGpu::writePixels(GrSurface* surface, int left, int top, int width, int height,
361 GrColorType srcColorType, const GrMipLevel texels[], int mipLevelCount) {
Brian Salomone39526b2019-06-24 16:35:53 -0400362 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Brian Salomonbf7b6202016-11-11 16:08:03 -0500363 SkASSERT(surface);
Brian Salomonc67c31c2018-12-06 10:00:03 -0500364
365 if (surface->readOnly()) {
366 return false;
367 }
368
Brian Salomon1047a492019-07-02 12:25:21 -0400369 if (mipLevelCount == 0) {
370 return false;
371 } else if (mipLevelCount == 1) {
Greg Daniel660cc992017-06-26 14:55:05 -0400372 // We require that if we are not mipped, then the write region is contained in the surface
Brian Salomon1d435302019-07-01 13:05:28 -0400373 auto subRect = SkIRect::MakeXYWH(left, top, width, height);
374 auto bounds = SkIRect::MakeWH(surface->width(), surface->height());
Greg Daniel660cc992017-06-26 14:55:05 -0400375 if (!bounds.contains(subRect)) {
376 return false;
377 }
378 } else if (0 != left || 0 != top || width != surface->width() || height != surface->height()) {
379 // We require that if the texels are mipped, than the write region is the entire surface
380 return false;
381 }
Robert Phillipsb7b7e5f2017-05-22 13:23:19 -0400382
Brian Salomon1047a492019-07-02 12:25:21 -0400383 int bpp = GrColorTypeBytesPerPixel(srcColorType);
384 if (!validate_levels(width, height, texels, mipLevelCount, bpp, this->caps())) {
385 return false;
cblume55f2d2d2016-02-26 13:20:48 -0800386 }
jvanverth2dc29942015-09-01 07:16:46 -0700387
bsalomon@google.com6f379512011-11-16 20:36:03 +0000388 this->handleDirtyContext();
Brian Salomona9b04b92018-06-01 15:04:28 -0400389 if (this->onWritePixels(surface, left, top, width, height, srcColorType, texels,
Brian Salomonc320b152018-02-20 14:05:36 -0500390 mipLevelCount)) {
jvanverth900bd4a2016-04-29 13:53:12 -0700391 SkIRect rect = SkIRect::MakeXYWH(left, top, width, height);
Brian Salomona9b04b92018-06-01 15:04:28 -0400392 this->didWriteToSurface(surface, kTopLeft_GrSurfaceOrigin, &rect, mipLevelCount);
bsalomonb12ea412015-02-02 21:19:50 -0800393 fStats.incTextureUploads();
394 return true;
395 }
396 return false;
bsalomon@google.com6f379512011-11-16 20:36:03 +0000397}
398
Brian Salomone05ba5a2019-04-08 11:59:07 -0400399bool GrGpu::transferPixelsTo(GrTexture* texture, int left, int top, int width, int height,
400 GrColorType bufferColorType, GrGpuBuffer* transferBuffer,
401 size_t offset, size_t rowBytes) {
Brian Salomone39526b2019-06-24 16:35:53 -0400402 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Brian Salomonc67c31c2018-12-06 10:00:03 -0500403 SkASSERT(texture);
cdalton397536c2016-03-25 12:15:03 -0700404 SkASSERT(transferBuffer);
jvanverth17aa0472016-01-05 10:41:27 -0800405
Brian Salomonc67c31c2018-12-06 10:00:03 -0500406 if (texture->readOnly()) {
407 return false;
408 }
409
Greg Daniel660cc992017-06-26 14:55:05 -0400410 // We require that the write region is contained in the texture
411 SkIRect subRect = SkIRect::MakeXYWH(left, top, width, height);
412 SkIRect bounds = SkIRect::MakeWH(texture->width(), texture->height());
413 if (!bounds.contains(subRect)) {
414 return false;
415 }
416
Brian Salomon1047a492019-07-02 12:25:21 -0400417 int bpp = GrColorTypeBytesPerPixel(bufferColorType);
418 if (this->caps()->writePixelsRowBytesSupport()) {
419 if (rowBytes < SkToSizeT(bpp * width)) {
420 return false;
421 }
422 if (rowBytes % bpp) {
423 return false;
424 }
425 } else {
426 if (rowBytes != SkToSizeT(bpp * width)) {
427 return false;
428 }
429 }
430
jvanverth17aa0472016-01-05 10:41:27 -0800431 this->handleDirtyContext();
Brian Salomone05ba5a2019-04-08 11:59:07 -0400432 if (this->onTransferPixelsTo(texture, left, top, width, height, bufferColorType, transferBuffer,
433 offset, rowBytes)) {
jvanverth900bd4a2016-04-29 13:53:12 -0700434 SkIRect rect = SkIRect::MakeXYWH(left, top, width, height);
Brian Salomon1fabd512018-02-09 09:54:25 -0500435 this->didWriteToSurface(texture, kTopLeft_GrSurfaceOrigin, &rect);
jvanverth17aa0472016-01-05 10:41:27 -0800436 fStats.incTransfersToTexture();
jvanverth84741b32016-09-30 08:39:02 -0700437
jvanverth17aa0472016-01-05 10:41:27 -0800438 return true;
439 }
440 return false;
441}
442
Brian Salomon26de56e2019-04-10 12:14:26 -0400443bool GrGpu::transferPixelsFrom(GrSurface* surface, int left, int top, int width, int height,
444 GrColorType bufferColorType, GrGpuBuffer* transferBuffer,
445 size_t offset) {
Brian Salomone39526b2019-06-24 16:35:53 -0400446 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Brian Salomone05ba5a2019-04-08 11:59:07 -0400447 SkASSERT(surface);
448 SkASSERT(transferBuffer);
Brian Salomon26de56e2019-04-10 12:14:26 -0400449 SkASSERT(this->caps()->transferFromOffsetAlignment(bufferColorType));
450 SkASSERT(offset % this->caps()->transferFromOffsetAlignment(bufferColorType) == 0);
Brian Salomone05ba5a2019-04-08 11:59:07 -0400451
452 // We require that the write region is contained in the texture
453 SkIRect subRect = SkIRect::MakeXYWH(left, top, width, height);
454 SkIRect bounds = SkIRect::MakeWH(surface->width(), surface->height());
455 if (!bounds.contains(subRect)) {
456 return false;
457 }
458
459 this->handleDirtyContext();
Brian Salomon26de56e2019-04-10 12:14:26 -0400460 if (this->onTransferPixelsFrom(surface, left, top, width, height, bufferColorType,
461 transferBuffer, offset)) {
Brian Salomone05ba5a2019-04-08 11:59:07 -0400462 fStats.incTransfersFromSurface();
Brian Salomon26de56e2019-04-10 12:14:26 -0400463 return true;
Brian Salomone05ba5a2019-04-08 11:59:07 -0400464 }
Brian Salomon26de56e2019-04-10 12:14:26 -0400465 return false;
Brian Salomone05ba5a2019-04-08 11:59:07 -0400466}
467
Brian Salomon930f9392018-06-20 16:25:26 -0400468bool GrGpu::regenerateMipMapLevels(GrTexture* texture) {
Brian Salomone39526b2019-06-24 16:35:53 -0400469 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Brian Salomon930f9392018-06-20 16:25:26 -0400470 SkASSERT(texture);
471 SkASSERT(this->caps()->mipMapSupport());
472 SkASSERT(texture->texturePriv().mipMapped() == GrMipMapped::kYes);
473 SkASSERT(texture->texturePriv().mipMapsAreDirty());
474 SkASSERT(!texture->asRenderTarget() || !texture->asRenderTarget()->needsResolve());
Brian Salomonc67c31c2018-12-06 10:00:03 -0500475 if (texture->readOnly()) {
476 return false;
477 }
Brian Salomon930f9392018-06-20 16:25:26 -0400478 if (this->onRegenerateMipMapLevels(texture)) {
479 texture->texturePriv().markMipMapsClean();
480 return true;
481 }
482 return false;
483}
484
Brian Salomon1f05d452019-02-08 12:33:08 -0500485void GrGpu::resetTextureBindings() {
486 this->handleDirtyContext();
487 this->onResetTextureBindings();
488}
489
Brian Salomon1fabd512018-02-09 09:54:25 -0500490void GrGpu::resolveRenderTarget(GrRenderTarget* target) {
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000491 SkASSERT(target);
bsalomon@google.com75f9f252012-01-31 13:35:56 +0000492 this->handleDirtyContext();
Brian Salomon1fabd512018-02-09 09:54:25 -0500493 this->onResolveRenderTarget(target);
bsalomon@google.com75f9f252012-01-31 13:35:56 +0000494}
495
Brian Salomon1fabd512018-02-09 09:54:25 -0500496void GrGpu::didWriteToSurface(GrSurface* surface, GrSurfaceOrigin origin, const SkIRect* bounds,
497 uint32_t mipLevels) const {
jvanverth900bd4a2016-04-29 13:53:12 -0700498 SkASSERT(surface);
Brian Salomonc67c31c2018-12-06 10:00:03 -0500499 SkASSERT(!surface->readOnly());
jvanverth900bd4a2016-04-29 13:53:12 -0700500 // Mark any MIP chain and resolve buffer as dirty if and only if there is a non-empty bounds.
501 if (nullptr == bounds || !bounds->isEmpty()) {
502 if (GrRenderTarget* target = surface->asRenderTarget()) {
Brian Salomon1fabd512018-02-09 09:54:25 -0500503 SkIRect flippedBounds;
504 if (kBottomLeft_GrSurfaceOrigin == origin && bounds) {
505 flippedBounds = {bounds->fLeft, surface->height() - bounds->fBottom,
506 bounds->fRight, surface->height() - bounds->fTop};
507 bounds = &flippedBounds;
508 }
jvanverth900bd4a2016-04-29 13:53:12 -0700509 target->flagAsNeedingResolve(bounds);
510 }
511 GrTexture* texture = surface->asTexture();
512 if (texture && 1 == mipLevels) {
Greg Daniel0fc4d2d2017-10-12 11:23:36 -0400513 texture->texturePriv().markMipMapsDirty();
jvanverth900bd4a2016-04-29 13:53:12 -0700514 }
515 }
516}
517
Chris Dalton8c4cafd2019-04-15 19:14:36 -0600518int GrGpu::findOrAssignSamplePatternKey(GrRenderTarget* renderTarget) {
Chris Daltond7291ba2019-03-07 14:17:03 -0700519 SkASSERT(this->caps()->sampleLocationsSupport());
Chris Daltoneffee202019-07-01 22:28:03 -0600520 SkASSERT(renderTarget->numSamples() > 1 ||
521 (renderTarget->renderTargetPriv().getStencilAttachment() &&
522 renderTarget->renderTargetPriv().getStencilAttachment()->numSamples() > 1));
Chris Daltond7291ba2019-03-07 14:17:03 -0700523
524 SkSTArray<16, SkPoint> sampleLocations;
Chris Dalton8c4cafd2019-04-15 19:14:36 -0600525 this->querySampleLocations(renderTarget, &sampleLocations);
Chris Daltond7291ba2019-03-07 14:17:03 -0700526 return fSamplePatternDictionary.findOrAssignSamplePatternKey(sampleLocations);
527}
528
Brian Salomonf9a1fdf2019-05-09 10:30:12 -0400529GrSemaphoresSubmitted GrGpu::finishFlush(GrSurfaceProxy* proxies[],
530 int n,
Greg Danielbae71212019-03-01 15:24:35 -0500531 SkSurface::BackendSurfaceAccess access,
Greg Daniel797efca2019-05-09 14:04:20 -0400532 const GrFlushInfo& info,
533 const GrPrepareForExternalIORequests& externalRequests) {
Brian Salomone39526b2019-06-24 16:35:53 -0400534 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
Greg Danield2073452018-12-07 11:20:33 -0500535 this->stats()->incNumFinishFlushes();
Robert Phillips9da87e02019-02-04 13:26:26 -0500536 GrResourceProvider* resourceProvider = fContext->priv().resourceProvider();
Robert Phillips6be756b2018-01-16 15:07:54 -0500537
Brian Salomon9ff5acb2019-05-08 09:04:47 -0400538 if (this->caps()->semaphoreSupport()) {
Greg Daniele6bfb7d2019-04-17 15:26:11 -0400539 for (int i = 0; i < info.fNumSemaphores; ++i) {
Greg Daniel51316782017-08-02 15:10:09 +0000540 sk_sp<GrSemaphore> semaphore;
Greg Daniele6bfb7d2019-04-17 15:26:11 -0400541 if (info.fSignalSemaphores[i].isInitialized()) {
Robert Phillips6be756b2018-01-16 15:07:54 -0500542 semaphore = resourceProvider->wrapBackendSemaphore(
Greg Daniele6bfb7d2019-04-17 15:26:11 -0400543 info.fSignalSemaphores[i],
544 GrResourceProvider::SemaphoreWrapType::kWillSignal,
Greg Daniel17b7c052018-01-09 13:55:33 -0500545 kBorrow_GrWrapOwnership);
Greg Daniel51316782017-08-02 15:10:09 +0000546 } else {
Robert Phillips6be756b2018-01-16 15:07:54 -0500547 semaphore = resourceProvider->makeSemaphore(false);
Greg Daniel51316782017-08-02 15:10:09 +0000548 }
Greg Daniel858e12c2018-12-06 11:11:37 -0500549 this->insertSemaphore(semaphore);
Greg Daniel51316782017-08-02 15:10:09 +0000550
Greg Daniele6bfb7d2019-04-17 15:26:11 -0400551 if (!info.fSignalSemaphores[i].isInitialized()) {
552 info.fSignalSemaphores[i] = semaphore->backendSemaphore();
Greg Daniel51316782017-08-02 15:10:09 +0000553 }
554 }
555 }
Greg Daniel797efca2019-05-09 14:04:20 -0400556 this->onFinishFlush(proxies, n, access, info, externalRequests);
Brian Salomon9ff5acb2019-05-08 09:04:47 -0400557 return this->caps()->semaphoreSupport() ? GrSemaphoresSubmitted::kYes
Greg Daniel51316782017-08-02 15:10:09 +0000558 : GrSemaphoresSubmitted::kNo;
559}
Brian Osman71a18892017-08-10 10:23:25 -0400560
Kevin Lubickf4def342018-10-04 12:52:50 -0400561#ifdef SK_ENABLE_DUMP_GPU
Brian Osman71a18892017-08-10 10:23:25 -0400562void GrGpu::dumpJSON(SkJSONWriter* writer) const {
563 writer->beginObject();
564
565 // TODO: Is there anything useful in the base class to dump here?
566
567 this->onDumpJSON(writer);
568
569 writer->endObject();
570}
Kevin Lubickf4def342018-10-04 12:52:50 -0400571#else
572void GrGpu::dumpJSON(SkJSONWriter* writer) const { }
573#endif
Robert Phillips646f6372018-09-25 09:31:10 -0400574
Robert Phillipsf0ced622019-05-16 09:06:25 -0400575#if GR_TEST_UTILS
576
Robert Phillipsdbaf3172019-02-06 15:12:53 -0500577#if GR_GPU_STATS
578void GrGpu::Stats::dump(SkString* out) {
579 out->appendf("Render Target Binds: %d\n", fRenderTargetBinds);
580 out->appendf("Shader Compilations: %d\n", fShaderCompilations);
581 out->appendf("Textures Created: %d\n", fTextureCreates);
582 out->appendf("Texture Uploads: %d\n", fTextureUploads);
583 out->appendf("Transfers to Texture: %d\n", fTransfersToTexture);
Brian Salomone05ba5a2019-04-08 11:59:07 -0400584 out->appendf("Transfers from Surface: %d\n", fTransfersFromSurface);
Robert Phillipsdbaf3172019-02-06 15:12:53 -0500585 out->appendf("Stencil Buffer Creates: %d\n", fStencilAttachmentCreates);
586 out->appendf("Number of draws: %d\n", fNumDraws);
Robert Phillipsf9fcf7f2019-07-11 09:03:27 -0400587 out->appendf("Number of Scratch Textures reused %d\n", fNumScratchTexturesReused);
Robert Phillipsdbaf3172019-02-06 15:12:53 -0500588}
589
590void GrGpu::Stats::dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values) {
591 keys->push_back(SkString("render_target_binds")); values->push_back(fRenderTargetBinds);
592 keys->push_back(SkString("shader_compilations")); values->push_back(fShaderCompilations);
Robert Phillipsdbaf3172019-02-06 15:12:53 -0500593}
594
595#endif
596
Robert Phillips646f6372018-09-25 09:31:10 -0400597#endif