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
25GrBackendTextureImageGenerator::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
34GrBackendTextureImageGenerator::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
43std::unique_ptr<SkImageGenerator>
44GrBackendTextureImageGenerator::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
68GrBackendTextureImageGenerator::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
80GrBackendTextureImageGenerator::~GrBackendTextureImageGenerator() {
81    fRefHelper->unref();
82}
83
84///////////////////////////////////////////////////////////////////////////////////////////////////
85
86void 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
95GrSurfaceProxyView 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