1 /*
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
8 #include "include/gpu/GrDirectContext.h"
9 #include "include/gpu/GrRecordingContext.h"
10 #include "src/core/SkMessageBus.h"
11 #include "src/gpu/GrBackendTextureImageGenerator.h"
12 #include "src/gpu/GrDirectContextPriv.h"
13 #include "src/gpu/GrGpu.h"
14 #include "src/gpu/GrProxyProvider.h"
15 #include "src/gpu/GrRecordingContextPriv.h"
16 #include "src/gpu/GrResourceCache.h"
17 #include "src/gpu/GrResourceProvider.h"
18 #include "src/gpu/GrResourceProviderPriv.h"
19 #include "src/gpu/GrSemaphore.h"
20 #include "src/gpu/GrTexture.h"
21 #include "src/gpu/GrTextureProxyPriv.h"
22 #include "src/gpu/SkGr.h"
23 #include "src/gpu/gl/GrGLTexture.h"
24
RefHelper(GrTexture * texture,GrDirectContext::DirectContextID owningContextID,std::unique_ptr<GrSemaphore> semaphore)25 GrBackendTextureImageGenerator::RefHelper::RefHelper(
26 GrTexture* texture,
27 GrDirectContext::DirectContextID owningContextID,
28 std::unique_ptr<GrSemaphore> semaphore)
29 : fOriginalTexture(texture)
30 , fOwningContextID(owningContextID)
31 , fBorrowingContextReleaseProc(nullptr)
32 , fSemaphore(std::move(semaphore)) {}
33
~RefHelper()34 GrBackendTextureImageGenerator::RefHelper::~RefHelper() {
35 SkASSERT(!fBorrowingContextID.isValid());
36
37 // Generator has been freed, and no one is borrowing the texture. Notify the original cache
38 // that it can free the last ref, so it happens on the correct thread.
39 GrTextureFreedMessage msg { fOriginalTexture, fOwningContextID };
40 SkMessageBus<GrTextureFreedMessage, GrDirectContext::DirectContextID>::Post(msg);
41 }
42
43 std::unique_ptr<SkImageGenerator>
Make(sk_sp<GrTexture> texture,GrSurfaceOrigin origin,std::unique_ptr<GrSemaphore> semaphore,SkColorType colorType,SkAlphaType alphaType,sk_sp<SkColorSpace> colorSpace)44 GrBackendTextureImageGenerator::Make(sk_sp<GrTexture> texture, GrSurfaceOrigin origin,
45 std::unique_ptr<GrSemaphore> semaphore, SkColorType colorType,
46 SkAlphaType alphaType, sk_sp<SkColorSpace> colorSpace) {
47 GrDirectContext* dContext = texture->getContext();
48
49 // Attach our texture to this context's resource cache. This ensures that deletion will happen
50 // in the correct thread/context. This adds the only ref to the texture that will persist from
51 // this point. That ref will be released when the generator's RefHelper is freed.
52 dContext->priv().getResourceCache()->insertDelayedTextureUnref(texture.get());
53
54 GrBackendTexture backendTexture = texture->getBackendTexture();
55
56 if (!dContext->priv().caps()->areColorTypeAndFormatCompatible(
57 SkColorTypeToGrColorType(colorType), backendTexture.getBackendFormat())) {
58 return nullptr;
59 }
60
61 SkImageInfo info = SkImageInfo::Make(texture->width(), texture->height(), colorType, alphaType,
62 std::move(colorSpace));
63 return std::unique_ptr<SkImageGenerator>(new GrBackendTextureImageGenerator(
64 info, texture.get(), origin, dContext->directContextID(),
65 std::move(semaphore), backendTexture));
66 }
67
GrBackendTextureImageGenerator(const SkImageInfo & info,GrTexture * texture,GrSurfaceOrigin origin,GrDirectContext::DirectContextID owningContextID,std::unique_ptr<GrSemaphore> semaphore,const GrBackendTexture & backendTex)68 GrBackendTextureImageGenerator::GrBackendTextureImageGenerator(
69 const SkImageInfo& info,
70 GrTexture* texture,
71 GrSurfaceOrigin origin,
72 GrDirectContext::DirectContextID owningContextID,
73 std::unique_ptr<GrSemaphore> semaphore,
74 const GrBackendTexture& backendTex)
75 : INHERITED(info)
76 , fRefHelper(new RefHelper(texture, owningContextID, std::move(semaphore)))
77 , fBackendTexture(backendTex)
78 , fSurfaceOrigin(origin) {}
79
~GrBackendTextureImageGenerator()80 GrBackendTextureImageGenerator::~GrBackendTextureImageGenerator() {
81 fRefHelper->unref();
82 }
83
84 ///////////////////////////////////////////////////////////////////////////////////////////////////
85
ReleaseRefHelper_TextureReleaseProc(void * ctx)86 void GrBackendTextureImageGenerator::ReleaseRefHelper_TextureReleaseProc(void* ctx) {
87 RefHelper* refHelper = static_cast<RefHelper*>(ctx);
88 SkASSERT(refHelper);
89
90 refHelper->fBorrowingContextReleaseProc = nullptr;
91 refHelper->fBorrowingContextID.makeInvalid();
92 refHelper->unref();
93 }
94
onGenerateTexture(GrRecordingContext * rContext,const SkImageInfo & info,const SkIPoint & origin,GrMipmapped mipMapped,GrImageTexGenPolicy texGenPolicy)95 GrSurfaceProxyView GrBackendTextureImageGenerator::onGenerateTexture(
96 GrRecordingContext* rContext,
97 const SkImageInfo& info,
98 const SkIPoint& origin,
99 GrMipmapped mipMapped,
100 GrImageTexGenPolicy texGenPolicy) {
101 SkASSERT(rContext);
102
103 // We currently limit GrBackendTextureImageGenerators to direct contexts since
104 // only Flutter uses them and doesn't use recording/DDL contexts. Ideally, the
105 // cross context texture functionality can be subsumed by the thread-safe cache
106 // working with utility contexts.
107 auto dContext = rContext->asDirectContext();
108 if (!dContext) {
109 return {};
110 }
111
112 if (dContext->backend() != fBackendTexture.backend()) {
113 return {};
114 }
115 if (info.colorType() != this->getInfo().colorType()) {
116 return {};
117 }
118
119 auto proxyProvider = dContext->priv().proxyProvider();
120
121 fBorrowingMutex.acquire();
122 sk_sp<GrRefCntedCallback> releaseProcHelper;
123 if (fRefHelper->fBorrowingContextID.isValid()) {
124 if (fRefHelper->fBorrowingContextID != dContext->directContextID()) {
125 fBorrowingMutex.release();
126 rContext->priv().printWarningMessage(
127 "GrBackendTextureImageGenerator: Trying to use texture on two GrContexts!\n");
128 return {};
129 } else {
130 SkASSERT(fRefHelper->fBorrowingContextReleaseProc);
131 // Ref the release proc to be held by the proxy we make below
132 releaseProcHelper = sk_ref_sp(fRefHelper->fBorrowingContextReleaseProc);
133 }
134 } else {
135 SkASSERT(!fRefHelper->fBorrowingContextReleaseProc);
136 // The ref we add to fRefHelper here will be passed into and owned by the
137 // GrRefCntedCallback.
138 fRefHelper->ref();
139 releaseProcHelper =
140 GrRefCntedCallback::Make(ReleaseRefHelper_TextureReleaseProc, fRefHelper);
141 fRefHelper->fBorrowingContextReleaseProc = releaseProcHelper.get();
142 }
143 fRefHelper->fBorrowingContextID = dContext->directContextID();
144 if (!fRefHelper->fBorrowedTextureKey.isValid()) {
145 static const auto kDomain = GrUniqueKey::GenerateDomain();
146 GrUniqueKey::Builder builder(&fRefHelper->fBorrowedTextureKey, kDomain, 1);
147 builder[0] = this->uniqueID();
148 }
149 fBorrowingMutex.release();
150
151 SkASSERT(fRefHelper->fBorrowingContextID == dContext->directContextID());
152
153 GrBackendFormat backendFormat = fBackendTexture.getBackendFormat();
154 SkASSERT(backendFormat.isValid());
155
156 GrColorType grColorType = SkColorTypeToGrColorType(info.colorType());
157
158 GrMipmapped textureIsMipMapped = fBackendTexture.hasMipmaps() ? GrMipmapped::kYes
159 : GrMipmapped::kNo;
160
161 // Ganesh assumes that, when wrapping a mipmapped backend texture from a client, that its
162 // mipmaps are fully fleshed out.
163 GrMipmapStatus mipmapStatus = fBackendTexture.hasMipmaps()
164 ? GrMipmapStatus::kValid : GrMipmapStatus::kNotAllocated;
165
166 GrSwizzle readSwizzle = dContext->priv().caps()->getReadSwizzle(backendFormat, grColorType);
167
168 // Must make copies of member variables to capture in the lambda since this image generator may
169 // be deleted before we actually execute the lambda.
170 sk_sp<GrTextureProxy> proxy = proxyProvider->createLazyProxy(
171 [refHelper = fRefHelper, releaseProcHelper, backendTexture = fBackendTexture](
172 GrResourceProvider* resourceProvider,
173 const GrSurfaceProxy::LazySurfaceDesc&) -> GrSurfaceProxy::LazyCallbackResult {
174 if (refHelper->fSemaphore) {
175 resourceProvider->priv().gpu()->waitSemaphore(refHelper->fSemaphore.get());
176 }
177
178 // If a client re-draws the same image multiple times, the texture we return
179 // will be cached and re-used. If they draw a subset, though, we may be
180 // re-called. In that case, we want to re-use the borrowed texture we've
181 // previously created.
182 sk_sp<GrTexture> tex;
183 SkASSERT(refHelper->fBorrowedTextureKey.isValid());
184 auto surf = resourceProvider->findByUniqueKey<GrSurface>(
185 refHelper->fBorrowedTextureKey);
186 if (surf) {
187 SkASSERT(surf->asTexture());
188 tex = sk_ref_sp(surf->asTexture());
189 } else {
190 // We just gained access to the texture. If we're on the original
191 // context, we could use the original texture, but we'd have no way of
192 // detecting that it's no longer in-use. So we always make a wrapped
193 // copy, where the release proc informs us that the context is done with
194 // it. This is unfortunate - we'll have two texture objects referencing
195 // the same GPU object. However, no client can ever see the original
196 // texture, so this should be safe. We make the texture uncacheable so
197 // that the release proc is called ASAP.
198 tex = resourceProvider->wrapBackendTexture(
199 backendTexture, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
200 kRead_GrIOType);
201 if (!tex) {
202 return {};
203 }
204 tex->setRelease(releaseProcHelper);
205 tex->resourcePriv().setUniqueKey(refHelper->fBorrowedTextureKey);
206 }
207 // We use keys to avoid re-wrapping the GrBackendTexture in a GrTexture.
208 // This is unrelated to the whatever SkImage key may be assigned to the
209 // proxy.
210 return {std::move(tex), true, GrSurfaceProxy::LazyInstantiationKeyMode::kUnsynced};
211 },
212 backendFormat, fBackendTexture.dimensions(), textureIsMipMapped, mipmapStatus,
213 GrInternalSurfaceFlags::kReadOnly, SkBackingFit::kExact, SkBudgeted::kNo,
214 GrProtected::kNo, GrSurfaceProxy::UseAllocator::kYes);
215 if (!proxy) {
216 return {};
217 }
218
219 if (texGenPolicy == GrImageTexGenPolicy::kDraw && origin.isZero() &&
220 info.dimensions() == fBackendTexture.dimensions() &&
221 (mipMapped == GrMipmapped::kNo || proxy->mipmapped() == GrMipmapped::kYes)) {
222 // If the caller wants the entire texture and we have the correct mip support, we're done
223 return GrSurfaceProxyView(std::move(proxy), fSurfaceOrigin, readSwizzle);
224 } else {
225 SkIRect subset = SkIRect::MakeXYWH(origin.fX, origin.fY, info.width(), info.height());
226
227 SkBudgeted budgeted = texGenPolicy == GrImageTexGenPolicy::kNew_Uncached_Unbudgeted
228 ? SkBudgeted::kNo
229 : SkBudgeted::kYes;
230
231 auto copy = GrSurfaceProxy::Copy(dContext,
232 std::move(proxy),
233 fSurfaceOrigin,
234 mipMapped,
235 subset,
236 SkBackingFit::kExact,
237 budgeted);
238 return {std::move(copy), fSurfaceOrigin, readSwizzle};
239 }
240 }
241