blob: 9cf02d785120dfc44db611cbc7e75bf5647d3d36 [file] [log] [blame]
bsalomon@google.com27847de2011-02-22 20:59:41 +00001/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00002 * Copyright 2011 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.
bsalomon@google.com27847de2011-02-22 20:59:41 +00006 */
7
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "include/core/SkTraceMemoryDump.h"
9#include "include/gpu/GrBackendSemaphore.h"
10#include "include/gpu/GrContext.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050011#include "include/private/SkDeferredDisplayList.h"
12#include "include/private/SkImageInfoPriv.h"
13#include "src/core/SkMakeUnique.h"
14#include "src/core/SkTaskGroup.h"
15#include "src/gpu/GrDrawingManager.h"
16#include "src/gpu/GrGpu.h"
17#include "src/gpu/GrMemoryPool.h"
18#include "src/gpu/GrPathRendererChain.h"
19#include "src/gpu/GrProxyProvider.h"
Greg Danielf91aeb22019-06-18 09:58:02 -040020#include "src/gpu/GrRenderTargetProxy.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050021#include "src/gpu/GrResourceCache.h"
22#include "src/gpu/GrResourceProvider.h"
23#include "src/gpu/GrSemaphore.h"
Brian Osman5e7fbfd2019-05-03 13:13:35 -040024#include "src/gpu/GrShaderUtils.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050025#include "src/gpu/GrSoftwarePathRenderer.h"
26#include "src/gpu/GrTracing.h"
27#include "src/gpu/SkGr.h"
28#include "src/gpu/ccpr/GrCoverageCountingPathRenderer.h"
29#include "src/gpu/effects/GrSkSLFP.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050030#include "src/gpu/text/GrTextBlobCache.h"
31#include "src/gpu/text/GrTextContext.h"
32#include "src/image/SkSurface_Gpu.h"
Mike Klein0ec1c572018-12-04 11:52:51 -050033#include <atomic>
34#include <unordered_map>
Greg Danielb76a72a2017-07-13 15:07:54 -040035
Robert Phillipse78b7252017-04-06 07:59:41 -040036#define ASSERT_OWNED_PROXY(P) \
Brian Salomonfd98c2c2018-07-31 17:25:29 -040037 SkASSERT(!(P) || !((P)->peekTexture()) || (P)->peekTexture()->getContext() == this)
Robert Phillips7ee385e2017-03-30 08:02:11 -040038
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +000039#define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
joshualitt1de610a2016-01-06 08:26:09 -080040#define ASSERT_SINGLE_OWNER \
Robert Phillipsa41c6852019-02-07 10:44:10 -050041 SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(this->singleOwner());)
Robert Phillipsa9162df2019-02-11 14:12:03 -050042#define RETURN_IF_ABANDONED if (this->abandoned()) { return; }
43#define RETURN_FALSE_IF_ABANDONED if (this->abandoned()) { return false; }
44#define RETURN_NULL_IF_ABANDONED if (this->abandoned()) { return nullptr; }
bsalomon@google.combc4b6542011-11-19 13:56:11 +000045
robertphillipsea461502015-05-26 11:38:03 -070046////////////////////////////////////////////////////////////////////////////////
47
Robert Phillipsa41c6852019-02-07 10:44:10 -050048GrContext::GrContext(GrBackendApi backend, const GrContextOptions& options, int32_t contextID)
49 : INHERITED(backend, options, contextID) {
halcanary96fcdcc2015-08-27 07:41:13 -070050 fResourceCache = nullptr;
51 fResourceProvider = nullptr;
bsalomon@google.com6e4e6502013-02-25 20:12:45 +000052}
53
Robert Phillips292a6b22019-02-14 14:49:02 -050054GrContext::~GrContext() {
55 ASSERT_SINGLE_OWNER
56
Robert Phillips6a6de562019-02-15 15:19:15 -050057 if (this->drawingManager()) {
58 this->drawingManager()->cleanup();
Robert Phillips292a6b22019-02-14 14:49:02 -050059 }
60 delete fResourceProvider;
61 delete fResourceCache;
Robert Phillips292a6b22019-02-14 14:49:02 -050062}
63
Robert Phillipsbb606772019-02-04 17:50:57 -050064bool GrContext::init(sk_sp<const GrCaps> caps, sk_sp<GrSkSLFPFactoryCache> FPFactoryCache) {
Greg Danielb76a72a2017-07-13 15:07:54 -040065 ASSERT_SINGLE_OWNER
Robert Phillipsfde6fa02018-03-02 08:53:14 -050066 SkASSERT(fThreadSafeProxy); // needs to have been initialized by derived classes
Robert Phillipsa41c6852019-02-07 10:44:10 -050067 SkASSERT(this->proxyProvider());
Robert Phillips88260b52018-01-19 12:56:09 -050068
Robert Phillipsbb606772019-02-04 17:50:57 -050069 if (!INHERITED::init(std::move(caps), std::move(FPFactoryCache))) {
70 return false;
71 }
72
73 SkASSERT(this->caps());
Herb Derbya00da612019-03-04 17:10:01 -050074 SkASSERT(this->getGrStrikeCache());
Robert Phillips2184fb72019-02-21 16:11:41 -050075 SkASSERT(this->getTextBlobCache());
Robert Phillipsbb606772019-02-04 17:50:57 -050076
Robert Phillips88260b52018-01-19 12:56:09 -050077 if (fGpu) {
Robert Phillipsa41c6852019-02-07 10:44:10 -050078 fResourceCache = new GrResourceCache(this->caps(), this->singleOwner(), this->contextID());
Robert Phillips12c46292019-04-23 07:36:17 -040079 fResourceProvider = new GrResourceProvider(fGpu.get(), fResourceCache, this->singleOwner());
Robert Phillips88260b52018-01-19 12:56:09 -050080 }
81
Robert Phillips88260b52018-01-19 12:56:09 -050082 if (fResourceCache) {
Robert Phillipsa41c6852019-02-07 10:44:10 -050083 fResourceCache->setProxyProvider(this->proxyProvider());
Robert Phillips88260b52018-01-19 12:56:09 -050084 }
Robert Phillips1afd4cd2018-01-08 13:40:32 -050085
bsalomon@google.com6e4e6502013-02-25 20:12:45 +000086 fDidTestPMConversions = false;
87
Robert Phillipsfde6fa02018-03-02 08:53:14 -050088 // DDL TODO: we need to think through how the task group & persistent cache
89 // get passed on to/shared between all the DDLRecorders created with this context.
Robert Phillipsc1541ae2019-02-04 12:05:37 -050090 if (this->options().fExecutor) {
91 fTaskGroup = skstd::make_unique<SkTaskGroup>(*this->options().fExecutor);
Brian Osman51279982017-08-23 10:12:00 -040092 }
93
Robert Phillipsc1541ae2019-02-04 12:05:37 -050094 fPersistentCache = this->options().fPersistentCache;
Brian Osman5e7fbfd2019-05-03 13:13:35 -040095 fShaderErrorHandler = this->options().fShaderErrorHandler;
96 if (!fShaderErrorHandler) {
97 fShaderErrorHandler = GrShaderUtils::DefaultShaderErrorHandler();
98 }
Ethan Nicholasd1b2eec2017-11-01 15:45:43 -040099
Brian Salomon91a3e522017-06-23 10:58:19 -0400100 return true;
bsalomon@google.comc0af3172012-06-15 14:10:09 +0000101}
102
Robert Phillips4217ea72019-01-30 13:08:28 -0500103sk_sp<GrContextThreadSafeProxy> GrContext::threadSafeProxy() {
104 return fThreadSafeProxy;
105}
106
Brian Salomonc7fe0f72018-05-11 10:14:21 -0400107//////////////////////////////////////////////////////////////////////////////
108
bsalomon2354f842014-07-28 13:48:36 -0700109void GrContext::abandonContext() {
Robert Phillipsa9162df2019-02-11 14:12:03 -0500110 if (this->abandoned()) {
111 return;
112 }
joshualitt1de610a2016-01-06 08:26:09 -0800113
Robert Phillipsa9162df2019-02-11 14:12:03 -0500114 INHERITED::abandonContext();
115
bsalomond309e7a2015-04-30 14:18:54 -0700116 fResourceProvider->abandon();
robertphillips0dfa62c2015-11-16 06:23:31 -0800117
Robert Phillipsa9162df2019-02-11 14:12:03 -0500118 // Need to cleanup the drawing manager first so all the render targets
robertphillips0dfa62c2015-11-16 06:23:31 -0800119 // will be released/forgotten before they too are abandoned.
Robert Phillips6a6de562019-02-15 15:19:15 -0500120 this->drawingManager()->cleanup();
robertphillips0dfa62c2015-11-16 06:23:31 -0800121
bsalomon@google.com205d4602011-04-25 12:43:45 +0000122 // abandon first to so destructors
123 // don't try to free the resources in the API.
bsalomon0ea80f42015-02-11 10:49:59 -0800124 fResourceCache->abandonAll();
bsalomonc8dc1f72014-08-21 13:02:13 -0700125
bsalomon6e2aad42016-04-01 11:54:31 -0700126 fGpu->disconnect(GrGpu::DisconnectType::kAbandon);
Khushalc421ca12018-06-26 14:38:34 -0700127}
128
bsalomon6e2aad42016-04-01 11:54:31 -0700129void GrContext::releaseResourcesAndAbandonContext() {
Brian Salomon614c1a82018-12-19 15:42:06 -0500130 if (this->abandoned()) {
131 return;
132 }
Robert Phillipsa9162df2019-02-11 14:12:03 -0500133
134 INHERITED::abandonContext();
135
bsalomon6e2aad42016-04-01 11:54:31 -0700136 fResourceProvider->abandon();
137
Robert Phillipsa9162df2019-02-11 14:12:03 -0500138 // Need to cleanup the drawing manager first so all the render targets
bsalomon6e2aad42016-04-01 11:54:31 -0700139 // will be released/forgotten before they too are abandoned.
Robert Phillips6a6de562019-02-15 15:19:15 -0500140 this->drawingManager()->cleanup();
bsalomon6e2aad42016-04-01 11:54:31 -0700141
142 // Release all resources in the backend 3D API.
143 fResourceCache->releaseAll();
144
145 fGpu->disconnect(GrGpu::DisconnectType::kCleanup);
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000146}
147
Brian Salomon1f05d452019-02-08 12:33:08 -0500148void GrContext::resetGLTextureBindings() {
149 if (this->abandoned() || this->backend() != GrBackendApi::kOpenGL) {
150 return;
151 }
152 fGpu->resetTextureBindings();
153}
154
bsalomon@google.com0a208a12013-06-28 18:57:35 +0000155void GrContext::resetContext(uint32_t state) {
joshualitt1de610a2016-01-06 08:26:09 -0800156 ASSERT_SINGLE_OWNER
bsalomon@google.com0a208a12013-06-28 18:57:35 +0000157 fGpu->markContextDirty(state);
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000158}
159
160void GrContext::freeGpuResources() {
joshualitt1de610a2016-01-06 08:26:09 -0800161 ASSERT_SINGLE_OWNER
162
Robert Phillips2184fb72019-02-21 16:11:41 -0500163 // TODO: the glyph cache doesn't hold any GpuResources so this call should not be needed here.
164 // Some slack in the GrTextBlob's implementation requires it though. That could be fixed.
Herb Derbya00da612019-03-04 17:10:01 -0500165 this->getGrStrikeCache()->freeAll();
robertphillips68737822015-10-29 12:12:21 -0700166
Robert Phillips6a6de562019-02-15 15:19:15 -0500167 this->drawingManager()->freeGpuResources();
bsalomon3033b9f2015-04-13 11:09:56 -0700168
169 fResourceCache->purgeAllUnlocked();
bsalomon@google.com27847de2011-02-22 20:59:41 +0000170}
171
Robert Phillips6eba0632018-03-28 12:25:42 -0400172void GrContext::purgeUnlockedResources(bool scratchResourcesOnly) {
173 ASSERT_SINGLE_OWNER
174 fResourceCache->purgeUnlockedResources(scratchResourcesOnly);
175 fResourceCache->purgeAsNeeded();
Robert Phillips2184fb72019-02-21 16:11:41 -0500176
177 // The textBlob Cache doesn't actually hold any GPU resource but this is a convenient
178 // place to purge stale blobs
179 this->getTextBlobCache()->purgeStaleBlobs();
Robert Phillips6eba0632018-03-28 12:25:42 -0400180}
181
Jim Van Verth76d917c2017-12-13 09:26:37 -0500182void GrContext::performDeferredCleanup(std::chrono::milliseconds msNotUsed) {
Brian Salomon5e150852017-03-22 14:53:13 -0400183 ASSERT_SINGLE_OWNER
Chris Dalton6c3879d2018-11-01 11:13:19 -0600184
185 auto purgeTime = GrStdSteadyClock::now() - msNotUsed;
186
Jim Van Verth76d917c2017-12-13 09:26:37 -0500187 fResourceCache->purgeAsNeeded();
Chris Dalton6c3879d2018-11-01 11:13:19 -0600188 fResourceCache->purgeResourcesNotUsedSince(purgeTime);
189
Robert Phillips6a6de562019-02-15 15:19:15 -0500190 if (auto ccpr = this->drawingManager()->getCoverageCountingPathRenderer()) {
Robert Phillipsa41c6852019-02-07 10:44:10 -0500191 ccpr->purgeCacheEntriesOlderThan(this->proxyProvider(), purgeTime);
Chris Dalton6c3879d2018-11-01 11:13:19 -0600192 }
Jim Van Verth76d917c2017-12-13 09:26:37 -0500193
Robert Phillips2184fb72019-02-21 16:11:41 -0500194 // The textBlob Cache doesn't actually hold any GPU resource but this is a convenient
195 // place to purge stale blobs
196 this->getTextBlobCache()->purgeStaleBlobs();
Brian Salomon5e150852017-03-22 14:53:13 -0400197}
198
Derek Sollenberger5480a182017-05-25 16:43:59 -0400199void GrContext::purgeUnlockedResources(size_t bytesToPurge, bool preferScratchResources) {
200 ASSERT_SINGLE_OWNER
201 fResourceCache->purgeUnlockedResources(bytesToPurge, preferScratchResources);
202}
203
commit-bot@chromium.org95c20032014-05-09 14:29:32 +0000204void GrContext::getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const {
joshualitt1de610a2016-01-06 08:26:09 -0800205 ASSERT_SINGLE_OWNER
206
bsalomon71cb0c22014-11-14 12:10:14 -0800207 if (resourceCount) {
bsalomon0ea80f42015-02-11 10:49:59 -0800208 *resourceCount = fResourceCache->getBudgetedResourceCount();
bsalomon71cb0c22014-11-14 12:10:14 -0800209 }
210 if (resourceBytes) {
bsalomon0ea80f42015-02-11 10:49:59 -0800211 *resourceBytes = fResourceCache->getBudgetedResourceBytes();
bsalomon71cb0c22014-11-14 12:10:14 -0800212 }
commit-bot@chromium.orgd8a57af2014-03-19 21:19:16 +0000213}
214
Derek Sollenbergeree479142017-05-24 11:41:33 -0400215size_t GrContext::getResourceCachePurgeableBytes() const {
216 ASSERT_SINGLE_OWNER
217 return fResourceCache->getPurgeableBytes();
218}
219
Adrienne Walker0f827972019-03-26 13:46:14 -0700220size_t GrContext::ComputeTextureSize(SkColorType type, int width, int height, GrMipMapped mipMapped,
221 bool useNextPow2) {
222 int colorSamplesPerPixel = 1;
223 return GrSurface::ComputeSize(SkColorType2GrPixelConfig(type), width, height,
224 colorSamplesPerPixel, mipMapped, useNextPow2);
225}
226
bsalomon@google.comfea37b52011-04-25 15:51:06 +0000227////////////////////////////////////////////////////////////////////////////////
228
Robert Phillipsbb606772019-02-04 17:50:57 -0500229int GrContext::maxTextureSize() const { return this->caps()->maxTextureSize(); }
Brian Salomonf932a632018-04-05 12:46:09 -0400230
Robert Phillipsbb606772019-02-04 17:50:57 -0500231int GrContext::maxRenderTargetSize() const { return this->caps()->maxRenderTargetSize(); }
Brian Salomonf932a632018-04-05 12:46:09 -0400232
Brian Salomonbdecacf2018-02-02 20:32:49 -0500233bool GrContext::colorTypeSupportedAsImage(SkColorType colorType) const {
Brian Osman2b23c4b2018-06-01 12:25:08 -0400234 GrPixelConfig config = SkColorType2GrPixelConfig(colorType);
Robert Phillipsbb606772019-02-04 17:50:57 -0500235 return this->caps()->isConfigTexturable(config);
Brian Salomonbdecacf2018-02-02 20:32:49 -0500236}
237
238int GrContext::maxSurfaceSampleCountForColorType(SkColorType colorType) const {
Brian Osman2b23c4b2018-06-01 12:25:08 -0400239 GrPixelConfig config = SkColorType2GrPixelConfig(colorType);
Robert Phillipsbb606772019-02-04 17:50:57 -0500240 return this->caps()->maxRenderTargetSampleCount(config);
Brian Salomonbdecacf2018-02-02 20:32:49 -0500241}
242
243////////////////////////////////////////////////////////////////////////////////
244
Greg Daniel06be0792019-04-22 15:53:23 -0400245bool GrContext::wait(int numSemaphores, const GrBackendSemaphore waitSemaphores[]) {
Brian Salomon9ff5acb2019-05-08 09:04:47 -0400246 if (!fGpu || fGpu->caps()->semaphoreSupport()) {
Greg Daniel06be0792019-04-22 15:53:23 -0400247 return false;
248 }
249 for (int i = 0; i < numSemaphores; ++i) {
250 sk_sp<GrSemaphore> sema = fResourceProvider->wrapBackendSemaphore(
251 waitSemaphores[i], GrResourceProvider::SemaphoreWrapType::kWillWait,
252 kAdopt_GrWrapOwnership);
253 fGpu->waitSemaphore(std::move(sema));
254 }
255 return true;
256}
257
258////////////////////////////////////////////////////////////////////////////////
259
Greg Daniel797efca2019-05-09 14:04:20 -0400260GrSemaphoresSubmitted GrContext::flush(const GrFlushInfo& info,
261 const GrPrepareForExternalIORequests& externalRequests) {
Greg Daniel51316782017-08-02 15:10:09 +0000262 ASSERT_SINGLE_OWNER
Robert Phillipsa9162df2019-02-11 14:12:03 -0500263 if (this->abandoned()) {
264 return GrSemaphoresSubmitted::kNo;
265 }
Greg Daniel51316782017-08-02 15:10:09 +0000266
Brian Salomonf9a1fdf2019-05-09 10:30:12 -0400267 return this->drawingManager()->flush(nullptr, 0, SkSurface::BackendSurfaceAccess::kNoAccess,
Greg Daniel797efca2019-05-09 14:04:20 -0400268 info, externalRequests);
Greg Daniel51316782017-08-02 15:10:09 +0000269}
270
Greg Daniela870b462019-01-08 15:49:46 -0500271////////////////////////////////////////////////////////////////////////////////
272
Brian Salomonb0d8b762019-05-06 16:58:22 -0400273void GrContext::checkAsyncWorkCompletion() {
274 if (fGpu) {
275 fGpu->checkFinishProcs();
276 }
277}
278
279////////////////////////////////////////////////////////////////////////////////
280
Greg Daniela870b462019-01-08 15:49:46 -0500281void GrContext::storeVkPipelineCacheData() {
282 if (fGpu) {
283 fGpu->storeVkPipelineCacheData();
284 }
285}
286
287////////////////////////////////////////////////////////////////////////////////
288
Khushal3e7548c2018-05-23 15:45:01 -0700289bool GrContext::supportsDistanceFieldText() const {
Robert Phillipsbb606772019-02-04 17:50:57 -0500290 return this->caps()->shaderCaps()->supportsDistanceFieldText();
Khushal3e7548c2018-05-23 15:45:01 -0700291}
292
bsalomon37f9a262015-02-02 13:00:10 -0800293//////////////////////////////////////////////////////////////////////////////
294
Robert Phillipsfc711a22018-02-13 17:03:00 -0500295// DDL TODO: remove 'maxResources'
Robert Phillips8d1e67e2017-12-04 13:48:14 -0500296void GrContext::getResourceCacheLimits(int* maxResources, size_t* maxResourceBytes) const {
joshualitt1de610a2016-01-06 08:26:09 -0800297 ASSERT_SINGLE_OWNER
Robert Phillips8d1e67e2017-12-04 13:48:14 -0500298 if (maxResources) {
299 *maxResources = fResourceCache->getMaxResourceCount();
bsalomon37f9a262015-02-02 13:00:10 -0800300 }
Robert Phillips8d1e67e2017-12-04 13:48:14 -0500301 if (maxResourceBytes) {
302 *maxResourceBytes = fResourceCache->getMaxResourceBytes();
bsalomon37f9a262015-02-02 13:00:10 -0800303 }
304}
305
Robert Phillips8d1e67e2017-12-04 13:48:14 -0500306void GrContext::setResourceCacheLimits(int maxResources, size_t maxResourceBytes) {
joshualitt1de610a2016-01-06 08:26:09 -0800307 ASSERT_SINGLE_OWNER
Robert Phillips8d1e67e2017-12-04 13:48:14 -0500308 fResourceCache->setLimits(maxResources, maxResourceBytes);
bsalomon37f9a262015-02-02 13:00:10 -0800309}
310
ericrk0a5fa482015-09-15 14:16:10 -0700311//////////////////////////////////////////////////////////////////////////////
ericrk0a5fa482015-09-15 14:16:10 -0700312void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
joshualitt1de610a2016-01-06 08:26:09 -0800313 ASSERT_SINGLE_OWNER
ericrk0a5fa482015-09-15 14:16:10 -0700314 fResourceCache->dumpMemoryStatistics(traceMemoryDump);
Khushal71652e22018-10-29 13:05:36 -0700315 traceMemoryDump->dumpNumericValue("skia/gr_text_blob_cache", "size", "bytes",
Robert Phillips2184fb72019-02-21 16:11:41 -0500316 this->getTextBlobCache()->usedBytes());
ericrk0a5fa482015-09-15 14:16:10 -0700317}
Brian Osman71a18892017-08-10 10:23:25 -0400318
Robert Phillips5c7a25b2019-05-20 08:38:07 -0400319//////////////////////////////////////////////////////////////////////////////
320GrBackendTexture GrContext::createBackendTexture(int width, int height,
Greg Danielf91aeb22019-06-18 09:58:02 -0400321 const GrBackendFormat& backendFormat,
Robert Phillips5c7a25b2019-05-20 08:38:07 -0400322 GrMipMapped mipMapped,
Emircan Uysaler23ca4e72019-06-24 10:53:09 -0400323 GrRenderable renderable,
324 GrProtected isProtected) {
Robert Phillips5c7a25b2019-05-20 08:38:07 -0400325 if (!this->asDirectContext()) {
326 return GrBackendTexture();
327 }
328
329 if (this->abandoned()) {
330 return GrBackendTexture();
331 }
332
333 if (!backendFormat.isValid()) {
334 return GrBackendTexture();
335 }
336
Robert Phillipsf0313ee2019-05-21 13:51:11 -0400337 return fGpu->createBackendTexture(width, height, backendFormat,
338 mipMapped, renderable,
Emircan Uysaler23ca4e72019-06-24 10:53:09 -0400339 nullptr, 0, nullptr, isProtected);
Robert Phillips5c7a25b2019-05-20 08:38:07 -0400340}
341
342GrBackendTexture GrContext::createBackendTexture(int width, int height,
343 SkColorType colorType,
344 GrMipMapped mipMapped,
Emircan Uysaler23ca4e72019-06-24 10:53:09 -0400345 GrRenderable renderable,
346 GrProtected isProtected) {
Robert Phillips5c7a25b2019-05-20 08:38:07 -0400347 if (!this->asDirectContext()) {
348 return GrBackendTexture();
349 }
350
351 if (this->abandoned()) {
352 return GrBackendTexture();
353 }
354
355 GrBackendFormat format = this->caps()->getBackendFormatFromColorType(colorType);
356 if (!format.isValid()) {
357 return GrBackendTexture();
358 }
359
Emircan Uysaler23ca4e72019-06-24 10:53:09 -0400360 return this->createBackendTexture(width, height, format, mipMapped, renderable, isProtected);
Robert Phillips5c7a25b2019-05-20 08:38:07 -0400361}
362
Robert Phillips4bdd36f2019-06-04 11:03:06 -0400363GrBackendTexture GrContext::createBackendTexture(int width, int height,
Greg Danielf91aeb22019-06-18 09:58:02 -0400364 const GrBackendFormat& backendFormat,
Robert Phillips4bdd36f2019-06-04 11:03:06 -0400365 const SkColor4f& color,
366 GrMipMapped mipMapped,
367 GrRenderable renderable) {
368 if (!this->asDirectContext()) {
369 return GrBackendTexture();
370 }
371
372 if (this->abandoned()) {
373 return GrBackendTexture();
374 }
375
376 if (!backendFormat.isValid()) {
377 return GrBackendTexture();
378 }
379
380 return fGpu->createBackendTexture(width, height, backendFormat,
381 mipMapped, renderable,
Emircan Uysaler23ca4e72019-06-24 10:53:09 -0400382 nullptr, 0, &color, GrProtected::kNo);
Robert Phillips4bdd36f2019-06-04 11:03:06 -0400383}
384
385GrBackendTexture GrContext::createBackendTexture(int width, int height,
386 SkColorType colorType,
387 const SkColor4f& color,
388 GrMipMapped mipMapped,
389 GrRenderable renderable) {
390 if (!this->asDirectContext()) {
391 return GrBackendTexture();
392 }
393
394 if (this->abandoned()) {
395 return GrBackendTexture();
396 }
397
398 GrBackendFormat format = this->caps()->getBackendFormatFromColorType(colorType);
399 if (!format.isValid()) {
400 return GrBackendTexture();
401 }
402
403 return this->createBackendTexture(width, height, format, color, mipMapped, renderable);
404}
405
Robert Phillips5c7a25b2019-05-20 08:38:07 -0400406void GrContext::deleteBackendTexture(GrBackendTexture backendTex) {
407 if (this->abandoned() || !backendTex.isValid()) {
408 return;
409 }
410
Robert Phillipsf0313ee2019-05-21 13:51:11 -0400411 fGpu->deleteBackendTexture(backendTex);
Robert Phillips5c7a25b2019-05-20 08:38:07 -0400412}
413