• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2016 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 "GrTextureProxy.h"
9 #include "GrTextureProxyPriv.h"
10 
11 #include "GrContext.h"
12 #include "GrContextPriv.h"
13 #include "GrDeferredProxyUploader.h"
14 #include "GrProxyProvider.h"
15 #include "GrTexturePriv.h"
16 
17 // Deferred version
GrTextureProxy(const GrSurfaceDesc & srcDesc,SkBackingFit fit,SkBudgeted budgeted,const void * srcData,size_t,uint32_t flags)18 GrTextureProxy::GrTextureProxy(const GrSurfaceDesc& srcDesc, SkBackingFit fit, SkBudgeted budgeted,
19                                const void* srcData, size_t /*rowBytes*/, uint32_t flags)
20         : INHERITED(srcDesc, fit, budgeted, flags)
21         , fMipMapped(GrMipMapped::kNo)
22         , fMipColorMode(SkDestinationSurfaceColorMode::kLegacy)
23         , fProxyProvider(nullptr)
24         , fDeferredUploader(nullptr) {
25     SkASSERT(!srcData);  // currently handled in Make()
26 }
27 
28 // Lazy-callback version
GrTextureProxy(LazyInstantiateCallback && callback,const GrSurfaceDesc & desc,GrMipMapped mipMapped,SkBackingFit fit,SkBudgeted budgeted,uint32_t flags)29 GrTextureProxy::GrTextureProxy(LazyInstantiateCallback&& callback, const GrSurfaceDesc& desc,
30                                GrMipMapped mipMapped, SkBackingFit fit, SkBudgeted budgeted,
31                                uint32_t flags)
32         : INHERITED(std::move(callback), desc, fit, budgeted, flags)
33         , fMipMapped(mipMapped)
34         , fMipColorMode(SkDestinationSurfaceColorMode::kLegacy)
35         , fProxyProvider(nullptr)
36         , fDeferredUploader(nullptr) {
37 }
38 
39 // Wrapped version
GrTextureProxy(sk_sp<GrSurface> surf,GrSurfaceOrigin origin)40 GrTextureProxy::GrTextureProxy(sk_sp<GrSurface> surf, GrSurfaceOrigin origin)
41         : INHERITED(std::move(surf), origin, SkBackingFit::kExact)
42         , fMipMapped(fTarget->asTexture()->texturePriv().mipMapped())
43         , fMipColorMode(fTarget->asTexture()->texturePriv().mipColorMode())
44         , fProxyProvider(nullptr)
45         , fDeferredUploader(nullptr) {
46     if (fTarget->getUniqueKey().isValid()) {
47         fProxyProvider = fTarget->asTexture()->getContext()->contextPriv().proxyProvider();
48         fProxyProvider->adoptUniqueKeyFromSurface(this, fTarget);
49     }
50 }
51 
~GrTextureProxy()52 GrTextureProxy::~GrTextureProxy() {
53     // Due to the order of cleanup the GrSurface this proxy may have wrapped may have gone away
54     // at this point. Zero out the pointer so the cache invalidation code doesn't try to use it.
55     fTarget = nullptr;
56     if (fUniqueKey.isValid()) {
57         fProxyProvider->processInvalidProxyUniqueKey(fUniqueKey, this, false);
58     } else {
59         SkASSERT(!fProxyProvider);
60     }
61 }
62 
instantiate(GrResourceProvider * resourceProvider)63 bool GrTextureProxy::instantiate(GrResourceProvider* resourceProvider) {
64     if (LazyState::kNot != this->lazyInstantiationState()) {
65         return false;
66     }
67     if (!this->instantiateImpl(resourceProvider, 1, /* needsStencil = */ false,
68                                kNone_GrSurfaceFlags, fMipMapped, fMipColorMode,
69                                fUniqueKey.isValid() ? &fUniqueKey : nullptr)) {
70         return false;
71     }
72 
73     SkASSERT(!fTarget->asRenderTarget());
74     SkASSERT(fTarget->asTexture());
75     return true;
76 }
77 
createSurface(GrResourceProvider * resourceProvider) const78 sk_sp<GrSurface> GrTextureProxy::createSurface(GrResourceProvider* resourceProvider) const {
79     sk_sp<GrSurface> surface= this->createSurfaceImpl(resourceProvider, 1,
80                                                       /* needsStencil = */ false,
81                                                       kNone_GrSurfaceFlags,
82                                                       fMipMapped, fMipColorMode);
83     if (!surface) {
84         return nullptr;
85     }
86 
87     SkASSERT(!surface->asRenderTarget());
88     SkASSERT(surface->asTexture());
89     return surface;
90 }
91 
setDeferredUploader(std::unique_ptr<GrDeferredProxyUploader> uploader)92 void GrTextureProxyPriv::setDeferredUploader(std::unique_ptr<GrDeferredProxyUploader> uploader) {
93     SkASSERT(!fTextureProxy->fDeferredUploader);
94     fTextureProxy->fDeferredUploader = std::move(uploader);
95 }
96 
scheduleUpload(GrOpFlushState * flushState)97 void GrTextureProxyPriv::scheduleUpload(GrOpFlushState* flushState) {
98     SkASSERT(fTextureProxy->fDeferredUploader);
99 
100     // Instantiate might have failed
101     if (fTextureProxy->fTarget) {
102         fTextureProxy->fDeferredUploader->scheduleUpload(flushState, fTextureProxy);
103     }
104 }
105 
resetDeferredUploader()106 void GrTextureProxyPriv::resetDeferredUploader() {
107     SkASSERT(fTextureProxy->fDeferredUploader);
108     fTextureProxy->fDeferredUploader.reset();
109 }
110 
111 // This method parallels the highest_filter_mode functions in GrGLTexture & GrVkTexture.
highestFilterMode() const112 GrSamplerState::Filter GrTextureProxy::highestFilterMode() const {
113     if (fTarget) {
114         return fTarget->asTexture()->texturePriv().highestFilterMode();
115     }
116 
117     if (GrPixelConfigIsSint(this->config())) {
118         // We only ever want to nearest-neighbor sample signed int textures.
119         return GrSamplerState::Filter::kNearest;
120     }
121 
122     // In OpenGL, GR_GL_TEXTURE_RECTANGLE and GR_GL_TEXTURE_EXTERNAL (which have a highest filter
123     // mode of bilerp) can only be created via wrapping.
124 
125     return GrSamplerState::Filter::kMipMap;
126 }
127 
onUninstantiatedGpuMemorySize() const128 size_t GrTextureProxy::onUninstantiatedGpuMemorySize() const {
129     return GrSurface::ComputeSize(this->config(), this->width(), this->height(), 1,
130                                   this->mipMapped(), !this->priv().isExact());
131 }
132 
setUniqueKey(GrProxyProvider * proxyProvider,const GrUniqueKey & key)133 void GrTextureProxy::setUniqueKey(GrProxyProvider* proxyProvider, const GrUniqueKey& key) {
134     SkASSERT(key.isValid());
135     SkASSERT(!fUniqueKey.isValid()); // proxies can only ever get one uniqueKey
136 
137     if (fTarget) {
138         if (!fTarget->getUniqueKey().isValid()) {
139             fTarget->resourcePriv().setUniqueKey(key);
140         }
141         SkASSERT(fTarget->getUniqueKey() == key);
142     }
143 
144     fUniqueKey = key;
145     fProxyProvider = proxyProvider;
146 }
147 
clearUniqueKey()148 void GrTextureProxy::clearUniqueKey() {
149     fUniqueKey.reset();
150     fProxyProvider = nullptr;
151 }
152 
153 #ifdef SK_DEBUG
validateLazyTexture(const GrTexture * texture)154 void GrTextureProxy::validateLazyTexture(const GrTexture* texture) {
155     SkASSERT(!texture->asRenderTarget());
156 }
157 #endif
158 
159