blob: 6320809765e59fcf25c3bb1fd6907dce2a38b146 [file] [log] [blame]
Brian Osman13dddce2017-05-09 13:19:50 -04001/*
2 * Copyright 2017 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/GrContext.h"
9#include "include/gpu/GrTexture.h"
10#include "include/private/GrRecordingContext.h"
Ben Wagner21bca282019-05-15 10:15:52 -040011#include "src/core/SkMessageBus.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050012#include "src/gpu/GrBackendTextureImageGenerator.h"
13#include "src/gpu/GrContextPriv.h"
14#include "src/gpu/GrGpu.h"
15#include "src/gpu/GrProxyProvider.h"
16#include "src/gpu/GrRecordingContextPriv.h"
17#include "src/gpu/GrRenderTargetContext.h"
18#include "src/gpu/GrResourceCache.h"
19#include "src/gpu/GrResourceProvider.h"
20#include "src/gpu/GrResourceProviderPriv.h"
21#include "src/gpu/GrSemaphore.h"
22#include "src/gpu/GrTexturePriv.h"
23#include "src/gpu/GrTextureProxyPriv.h"
24#include "src/gpu/SkGr.h"
25#include "src/gpu/gl/GrGLTexture.h"
Brian Osman13dddce2017-05-09 13:19:50 -040026
Brian Salomonb916b7b2019-04-01 13:34:34 -040027GrBackendTextureImageGenerator::RefHelper::RefHelper(GrTexture* texture, uint32_t owningContextID)
28 : fOriginalTexture(texture)
29 , fOwningContextID(owningContextID)
30 , fBorrowingContextReleaseProc(nullptr)
31 , fBorrowingContextID(SK_InvalidGenID) {}
32
Brian Osman13dddce2017-05-09 13:19:50 -040033GrBackendTextureImageGenerator::RefHelper::~RefHelper() {
Brian Salomonb916b7b2019-04-01 13:34:34 -040034 SkASSERT(fBorrowingContextID == SK_InvalidUniqueID);
Brian Osman13dddce2017-05-09 13:19:50 -040035
36 // Generator has been freed, and no one is borrowing the texture. Notify the original cache
37 // that it can free the last ref, so it happens on the correct thread.
38 GrGpuResourceFreedMessage msg { fOriginalTexture, fOwningContextID };
39 SkMessageBus<GrGpuResourceFreedMessage>::Post(msg);
40}
41
Brian Osman13dddce2017-05-09 13:19:50 -040042std::unique_ptr<SkImageGenerator>
Robert Phillipsb0e93a22017-08-29 08:26:54 -040043GrBackendTextureImageGenerator::Make(sk_sp<GrTexture> texture, GrSurfaceOrigin origin,
Brian Osman052ef692018-03-27 09:56:31 -040044 sk_sp<GrSemaphore> semaphore, SkColorType colorType,
Brian Osman13dddce2017-05-09 13:19:50 -040045 SkAlphaType alphaType, sk_sp<SkColorSpace> colorSpace) {
Brian Osman13dddce2017-05-09 13:19:50 -040046 GrContext* context = texture->getContext();
47
48 // Attach our texture to this context's resource cache. This ensures that deletion will happen
49 // in the correct thread/context. This adds the only ref to the texture that will persist from
50 // this point. That ref will be released when the generator's RefHelper is freed.
Brian Salomon876a0172019-03-08 11:12:14 -050051 context->priv().getResourceCache()->insertDelayedResourceUnref(texture.get());
Brian Osman13dddce2017-05-09 13:19:50 -040052
Robert Phillipsb67821d2017-12-13 15:00:45 -050053 GrBackendTexture backendTexture = texture->getBackendTexture();
Brian Salomonf391d0f2018-12-14 09:18:50 -050054 GrBackendFormat backendFormat = backendTexture.getBackendFormat();
55 if (!backendFormat.isValid()) {
56 return nullptr;
57 }
58 backendTexture.fConfig =
Robert Phillips9da87e02019-02-04 13:26:26 -050059 context->priv().caps()->getConfigFromBackendFormat(backendFormat, colorType);
Brian Salomonf391d0f2018-12-14 09:18:50 -050060 if (backendTexture.fConfig == kUnknown_GrPixelConfig) {
Brian Osman052ef692018-03-27 09:56:31 -040061 return nullptr;
62 }
Brian Osman13dddce2017-05-09 13:19:50 -040063
64 SkImageInfo info = SkImageInfo::Make(texture->width(), texture->height(), colorType, alphaType,
65 std::move(colorSpace));
66 return std::unique_ptr<SkImageGenerator>(new GrBackendTextureImageGenerator(
Robert Phillips9da87e02019-02-04 13:26:26 -050067 info, texture.get(), origin, context->priv().contextID(),
Robert Phillipsfd0d9702019-02-01 10:19:42 -050068 std::move(semaphore), backendTexture));
Brian Osman13dddce2017-05-09 13:19:50 -040069}
70
71GrBackendTextureImageGenerator::GrBackendTextureImageGenerator(const SkImageInfo& info,
72 GrTexture* texture,
Robert Phillipsb0e93a22017-08-29 08:26:54 -040073 GrSurfaceOrigin origin,
Brian Osman13dddce2017-05-09 13:19:50 -040074 uint32_t owningContextID,
75 sk_sp<GrSemaphore> semaphore,
76 const GrBackendTexture& backendTex)
Brian Salomonb916b7b2019-04-01 13:34:34 -040077 : INHERITED(info)
78 , fRefHelper(new RefHelper(texture, owningContextID))
79 , fSemaphore(std::move(semaphore))
80 , fBackendTexture(backendTex)
81 , fConfig(backendTex.config())
82 , fSurfaceOrigin(origin) {}
Brian Osman13dddce2017-05-09 13:19:50 -040083
84GrBackendTextureImageGenerator::~GrBackendTextureImageGenerator() {
85 fRefHelper->unref();
86}
87
Brian Osman13dddce2017-05-09 13:19:50 -040088///////////////////////////////////////////////////////////////////////////////////////////////////
89
Brian Osman13dddce2017-05-09 13:19:50 -040090void GrBackendTextureImageGenerator::ReleaseRefHelper_TextureReleaseProc(void* ctx) {
91 RefHelper* refHelper = static_cast<RefHelper*>(ctx);
92 SkASSERT(refHelper);
93
Greg Danielabba9982018-02-01 10:07:57 -050094 refHelper->fBorrowingContextReleaseProc = nullptr;
Greg Daniel48661b82018-01-22 16:11:35 -050095 refHelper->fBorrowingContextID = SK_InvalidGenID;
Brian Osman13dddce2017-05-09 13:19:50 -040096 refHelper->unref();
97}
98
Stan Ilievba81af22017-06-08 15:16:53 -040099sk_sp<GrTextureProxy> GrBackendTextureImageGenerator::onGenerateTexture(
Robert Phillips9338c602019-02-19 12:52:29 -0500100 GrRecordingContext* context, const SkImageInfo& info,
101 const SkIPoint& origin, bool willNeedMipMaps) {
Brian Osman13dddce2017-05-09 13:19:50 -0400102 SkASSERT(context);
103
Robert Phillips4217ea72019-01-30 13:08:28 -0500104 if (context->backend() != fBackendTexture.backend()) {
Brian Osman13dddce2017-05-09 13:19:50 -0400105 return nullptr;
106 }
Brian Osman052ef692018-03-27 09:56:31 -0400107 if (info.colorType() != this->getInfo().colorType()) {
108 return nullptr;
109 }
Brian Osman13dddce2017-05-09 13:19:50 -0400110
Robert Phillips9da87e02019-02-04 13:26:26 -0500111 auto proxyProvider = context->priv().proxyProvider();
Robert Phillips777707b2018-01-17 11:40:14 -0500112
Greg Danielabba9982018-02-01 10:07:57 -0500113 fBorrowingMutex.acquire();
Brian Salomonb2c5dae2019-03-04 10:25:17 -0500114 sk_sp<GrRefCntedCallback> releaseProcHelper;
Greg Danielabba9982018-02-01 10:07:57 -0500115 if (SK_InvalidGenID != fRefHelper->fBorrowingContextID) {
Robert Phillips9da87e02019-02-04 13:26:26 -0500116 if (fRefHelper->fBorrowingContextID != context->priv().contextID()) {
Greg Danielabba9982018-02-01 10:07:57 -0500117 fBorrowingMutex.release();
Greg Daniel966db9e2018-01-12 13:15:06 -0500118 return nullptr;
Greg Danielabba9982018-02-01 10:07:57 -0500119 } else {
120 SkASSERT(fRefHelper->fBorrowingContextReleaseProc);
121 // Ref the release proc to be held by the proxy we make below
122 releaseProcHelper = sk_ref_sp(fRefHelper->fBorrowingContextReleaseProc);
Greg Daniel966db9e2018-01-12 13:15:06 -0500123 }
Greg Danielabba9982018-02-01 10:07:57 -0500124 } else {
125 SkASSERT(!fRefHelper->fBorrowingContextReleaseProc);
126 // The ref we add to fRefHelper here will be passed into and owned by the
Brian Salomonb2c5dae2019-03-04 10:25:17 -0500127 // GrRefCntedCallback.
Greg Danielabba9982018-02-01 10:07:57 -0500128 fRefHelper->ref();
Brian Salomonb2c5dae2019-03-04 10:25:17 -0500129 releaseProcHelper.reset(
130 new GrRefCntedCallback(ReleaseRefHelper_TextureReleaseProc, fRefHelper));
Greg Danielabba9982018-02-01 10:07:57 -0500131 fRefHelper->fBorrowingContextReleaseProc = releaseProcHelper.get();
Brian Osman13dddce2017-05-09 13:19:50 -0400132 }
Robert Phillips9da87e02019-02-04 13:26:26 -0500133 fRefHelper->fBorrowingContextID = context->priv().contextID();
Brian Salomonb916b7b2019-04-01 13:34:34 -0400134 if (!fRefHelper->fBorrowedTextureKey.isValid()) {
135 static const auto kDomain = GrUniqueKey::GenerateDomain();
136 GrUniqueKey::Builder builder(&fRefHelper->fBorrowedTextureKey, kDomain, 1);
137 builder[0] = this->uniqueID();
138 }
Greg Danielabba9982018-02-01 10:07:57 -0500139 fBorrowingMutex.release();
Brian Osman13dddce2017-05-09 13:19:50 -0400140
Robert Phillips9da87e02019-02-04 13:26:26 -0500141 SkASSERT(fRefHelper->fBorrowingContextID == context->priv().contextID());
Brian Osman13dddce2017-05-09 13:19:50 -0400142
Greg Daniele728f672018-01-17 10:52:04 -0500143 GrSurfaceDesc desc;
Greg Daniele728f672018-01-17 10:52:04 -0500144 desc.fWidth = fBackendTexture.width();
145 desc.fHeight = fBackendTexture.height();
146 desc.fConfig = fConfig;
147 GrMipMapped mipMapped = fBackendTexture.hasMipMaps() ? GrMipMapped::kYes : GrMipMapped::kNo;
148
Brian Salomonb6a3a3b2019-04-01 12:29:34 -0400149 GrBackendFormat format = fBackendTexture.getBackendFormat();
Greg Daniel4065d452018-11-16 15:43:41 -0500150 SkASSERT(format.isValid());
151
Brian Salomonb6a3a3b2019-04-01 12:29:34 -0400152 // Must make copies of member variables to capture in the lambda since this image generator may
153 // be deleted before we actually execute the lambda.
Robert Phillips777707b2018-01-17 11:40:14 -0500154 sk_sp<GrTextureProxy> proxy = proxyProvider->createLazyProxy(
Brian Salomonb6a3a3b2019-04-01 12:29:34 -0400155 [refHelper = fRefHelper, releaseProcHelper, semaphore = fSemaphore,
156 backendTexture = fBackendTexture](GrResourceProvider* resourceProvider)
157 -> GrSurfaceProxy::LazyInstantiationResult {
Greg Daniel48661b82018-01-22 16:11:35 -0500158 if (semaphore) {
Greg Daniele728f672018-01-17 10:52:04 -0500159 resourceProvider->priv().gpu()->waitSemaphore(semaphore);
160 }
161
Brian Salomonb916b7b2019-04-01 13:34:34 -0400162 // If a client re-draws the same image multiple times, the texture we return
163 // will be cached and re-used. If they draw a subset, though, we may be
164 // re-called. In that case, we want to re-use the borrowed texture we've
165 // previously created.
Greg Daniele728f672018-01-17 10:52:04 -0500166 sk_sp<GrTexture> tex;
Brian Salomonb916b7b2019-04-01 13:34:34 -0400167 SkASSERT(refHelper->fBorrowedTextureKey.isValid());
168 auto surf = resourceProvider->findByUniqueKey<GrSurface>(
169 refHelper->fBorrowedTextureKey);
170 if (surf) {
171 SkASSERT(surf->asTexture());
172 tex = sk_ref_sp(surf->asTexture());
Greg Daniele728f672018-01-17 10:52:04 -0500173 } else {
174 // We just gained access to the texture. If we're on the original context, we
175 // could use the original texture, but we'd have no way of detecting that it's
176 // no longer in-use. So we always make a wrapped copy, where the release proc
177 // informs us that the context is done with it. This is unfortunate - we'll have
178 // two texture objects referencing the same GPU object. However, no client can
179 // ever see the original texture, so this should be safe.
Brian Salomonfa2ebea2019-01-24 15:58:58 -0500180 // We make the texture uncacheable so that the release proc is called ASAP.
Brian Salomonc67c31c2018-12-06 10:00:03 -0500181 tex = resourceProvider->wrapBackendTexture(
Brian Salomonaa6ca0a2019-01-24 16:03:07 -0500182 backendTexture, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
183 kRead_GrIOType);
Greg Daniele728f672018-01-17 10:52:04 -0500184 if (!tex) {
Brian Salomonb6a3a3b2019-04-01 12:29:34 -0400185 return {};
Greg Daniele728f672018-01-17 10:52:04 -0500186 }
Greg Danielabba9982018-02-01 10:07:57 -0500187 tex->setRelease(releaseProcHelper);
Brian Salomonb916b7b2019-04-01 13:34:34 -0400188 tex->resourcePriv().setUniqueKey(refHelper->fBorrowedTextureKey);
Greg Daniele728f672018-01-17 10:52:04 -0500189 }
Brian Salomonb916b7b2019-04-01 13:34:34 -0400190 // We use keys to avoid re-wrapping the GrBackendTexture in a GrTexture. This is
191 // unrelated to the whatever SkImage key may be assigned to the proxy.
192 return {std::move(tex), GrSurfaceProxy::LazyInstantiationKeyMode::kUnsynced};
Brian Salomon2a4f9832018-03-03 22:43:43 -0500193 },
Brian Salomonc67c31c2018-12-06 10:00:03 -0500194 format, desc, fSurfaceOrigin, mipMapped, GrInternalSurfaceFlags::kReadOnly,
195 SkBackingFit::kExact, SkBudgeted::kNo);
Brian Osman13dddce2017-05-09 13:19:50 -0400196
Greg Daniele3204862018-04-16 11:24:10 -0400197 if (!proxy) {
198 return nullptr;
199 }
200
Brian Osman13dddce2017-05-09 13:19:50 -0400201 if (0 == origin.fX && 0 == origin.fY &&
Greg Daniel261b8aa2017-10-23 09:37:36 -0400202 info.width() == fBackendTexture.width() && info.height() == fBackendTexture.height() &&
Greg Daniele252f082017-10-23 16:05:23 -0400203 (!willNeedMipMaps || GrMipMapped::kYes == proxy->mipMapped())) {
Greg Daniel261b8aa2017-10-23 09:37:36 -0400204 // If the caller wants the entire texture and we have the correct mip support, we're done
Brian Osman13dddce2017-05-09 13:19:50 -0400205 return proxy;
206 } else {
207 // Otherwise, make a copy of the requested subset. Make sure our temporary is renderable,
Greg Daniel261b8aa2017-10-23 09:37:36 -0400208 // because Vulkan will want to do the copy as a draw. All other copies would require a
209 // layout change in Vulkan and we do not change the layout of borrowed images.
Greg Daniel45d63032017-10-30 13:41:26 -0400210 GrMipMapped mipMapped = willNeedMipMaps ? GrMipMapped::kYes : GrMipMapped::kNo;
Greg Daniel4c6f9b72019-06-06 13:40:59 -0400211 SkIRect subset = SkIRect::MakeXYWH(origin.fX, origin.fY, info.width(), info.height());
Greg Daniel4c6f9b72019-06-06 13:40:59 -0400212
Greg Daniel46cfbc62019-06-07 11:43:30 -0400213 return GrSurfaceProxy::Copy(context, proxy.get(), mipMapped, subset, SkBackingFit::kExact,
214 SkBudgeted::kYes);
Brian Osman13dddce2017-05-09 13:19:50 -0400215 }
216}
Greg Daniel9cc28232018-04-06 10:00:09 -0400217