blob: 091fcc8887d860ac631f0a2a3584f56c8e732565 [file] [log] [blame]
robertphillips76948d42016-05-04 12:47:41 -07001/*
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#ifndef GrSurfaceProxy_DEFINED
9#define GrSurfaceProxy_DEFINED
10
11#include "GrGpuResource.h"
Robert Phillipsc7635fa2016-10-28 13:25:24 -040012#include "GrSurface.h"
Robert Phillips93f16332016-11-23 19:37:13 -050013
csmartdaltonbf4a8f92016-09-06 10:01:06 -070014#include "SkRect.h"
robertphillips76948d42016-05-04 12:47:41 -070015
Greg Daniel7ef28f32017-04-20 16:41:55 +000016class GrBackendTexture;
Robert Phillips37430132016-11-09 06:50:43 -050017class GrCaps;
Robert Phillipsc589b0b2017-04-17 07:53:07 -040018class GrOpList;
Brian Osman45580d32016-11-23 09:37:01 -050019class GrRenderTargetOpList;
20class GrRenderTargetProxy;
Brian Osman32342f02017-03-04 08:12:46 -050021class GrResourceProvider;
Robert Phillipsd46697a2017-01-25 12:10:37 -050022class GrSurfaceContext;
Robert Phillips757914d2017-01-25 15:48:30 -050023class GrSurfaceProxyPriv;
Brian Osman45580d32016-11-23 09:37:01 -050024class GrTextureOpList;
robertphillips76948d42016-05-04 12:47:41 -070025class GrTextureProxy;
robertphillips76948d42016-05-04 12:47:41 -070026
Robert Phillipsc7635fa2016-10-28 13:25:24 -040027// This class replicates the functionality GrIORef<GrSurface> but tracks the
28// utilitization for later resource allocation (for the deferred case) and
29// forwards on the utilization in the wrapped case
30class GrIORefProxy : public SkNoncopyable {
31public:
32 void ref() const {
33 this->validate();
34
35 ++fRefCnt;
36 if (fTarget) {
37 fTarget->ref();
38 }
39 }
40
41 void unref() const {
42 this->validate();
43
44 if (fTarget) {
45 fTarget->unref();
46 }
47
Robert Phillipsb6deea82017-05-11 14:14:30 -040048 --fRefCnt;
49 this->didRemoveRefOrPendingIO();
Robert Phillipsc7635fa2016-10-28 13:25:24 -040050 }
51
52 void validate() const {
Robert Phillipsb6deea82017-05-11 14:14:30 -040053#ifdef SK_DEBUG
54 SkASSERT(fRefCnt >= 0);
robertphillips1125a032016-11-16 11:17:17 -080055 SkASSERT(fPendingReads >= 0);
56 SkASSERT(fPendingWrites >= 0);
57 SkASSERT(fRefCnt + fPendingReads + fPendingWrites >= 1);
58
59 if (fTarget) {
robertphillips1125a032016-11-16 11:17:17 -080060 // The backing GrSurface can have more refs than the proxy if the proxy
61 // started off wrapping an external resource (that came in with refs).
62 // The GrSurface should never have fewer refs than the proxy however.
63 SkASSERT(fTarget->fRefCnt >= fRefCnt);
Robert Phillipsb6deea82017-05-11 14:14:30 -040064 SkASSERT(fTarget->fPendingReads >= fPendingReads);
65 SkASSERT(fTarget->fPendingWrites >= fPendingWrites);
robertphillips1125a032016-11-16 11:17:17 -080066 }
Robert Phillipsc7635fa2016-10-28 13:25:24 -040067#endif
68 }
69
robertphillips1125a032016-11-16 11:17:17 -080070 int32_t getProxyRefCnt_TestOnly() const;
71 int32_t getBackingRefCnt_TestOnly() const;
72 int32_t getPendingReadCnt_TestOnly() const;
73 int32_t getPendingWriteCnt_TestOnly() const;
74
Robert Phillipsc7635fa2016-10-28 13:25:24 -040075protected:
robertphillips1125a032016-11-16 11:17:17 -080076 GrIORefProxy() : fTarget(nullptr), fRefCnt(1), fPendingReads(0), fPendingWrites(0) {}
77 GrIORefProxy(sk_sp<GrSurface> surface) : fRefCnt(1), fPendingReads(0), fPendingWrites(0) {
Robert Phillipsc7635fa2016-10-28 13:25:24 -040078 // Since we're manually forwarding on refs & unrefs we don't want sk_sp doing
79 // anything extra.
80 fTarget = surface.release();
81 }
82 virtual ~GrIORefProxy() {
83 // We don't unref 'fTarget' here since the 'unref' method will already
84 // have forwarded on the unref call that got use here.
85 }
86
robertphillips1125a032016-11-16 11:17:17 -080087 // This GrIORefProxy was deferred before but has just been instantiated. To
88 // make all the reffing & unreffing work out we now need to transfer any deferred
89 // refs & unrefs to the new GrSurface
90 void transferRefs() {
91 SkASSERT(fTarget);
92
93 fTarget->fRefCnt += (fRefCnt-1); // don't xfer the proxy's creation ref
94 fTarget->fPendingReads += fPendingReads;
95 fTarget->fPendingWrites += fPendingWrites;
robertphillips1125a032016-11-16 11:17:17 -080096 }
Robert Phillipsc7635fa2016-10-28 13:25:24 -040097
Robert Phillips757914d2017-01-25 15:48:30 -050098 bool internalHasPendingIO() const {
99 if (fTarget) {
100 return fTarget->internalHasPendingIO();
101 }
102
103 return SkToBool(fPendingWrites | fPendingReads);
104 }
105
Robert Phillips7ee385e2017-03-30 08:02:11 -0400106 bool internalHasPendingWrite() const {
107 if (fTarget) {
108 return fTarget->internalHasPendingWrite();
109 }
110
111 return SkToBool(fPendingWrites);
112 }
113
Robert Phillipsc7635fa2016-10-28 13:25:24 -0400114 // For deferred proxies this will be null. For wrapped proxies it will point to the
115 // wrapped resource.
116 GrSurface* fTarget;
robertphillips1125a032016-11-16 11:17:17 -0800117
118private:
119 // This class is used to manage conversion of refs to pending reads/writes.
Robert Phillipsb6deea82017-05-11 14:14:30 -0400120 friend class GrSurfaceProxyRef;
robertphillips1125a032016-11-16 11:17:17 -0800121 template <typename, GrIOType> friend class GrPendingIOResource;
122
123 void addPendingRead() const {
124 this->validate();
125
Robert Phillipsb6deea82017-05-11 14:14:30 -0400126 ++fPendingReads;
robertphillips1125a032016-11-16 11:17:17 -0800127 if (fTarget) {
128 fTarget->addPendingRead();
robertphillips1125a032016-11-16 11:17:17 -0800129 }
robertphillips1125a032016-11-16 11:17:17 -0800130 }
131
132 void completedRead() const {
133 this->validate();
134
135 if (fTarget) {
136 fTarget->completedRead();
robertphillips1125a032016-11-16 11:17:17 -0800137 }
Robert Phillipsb6deea82017-05-11 14:14:30 -0400138
139 --fPendingReads;
140 this->didRemoveRefOrPendingIO();
robertphillips1125a032016-11-16 11:17:17 -0800141 }
142
143 void addPendingWrite() const {
144 this->validate();
145
Robert Phillipsb6deea82017-05-11 14:14:30 -0400146 ++fPendingWrites;
robertphillips1125a032016-11-16 11:17:17 -0800147 if (fTarget) {
148 fTarget->addPendingWrite();
robertphillips1125a032016-11-16 11:17:17 -0800149 }
robertphillips1125a032016-11-16 11:17:17 -0800150 }
151
152 void completedWrite() const {
153 this->validate();
154
155 if (fTarget) {
156 fTarget->completedWrite();
robertphillips1125a032016-11-16 11:17:17 -0800157 }
Robert Phillipsb6deea82017-05-11 14:14:30 -0400158
159 --fPendingWrites;
160 this->didRemoveRefOrPendingIO();
161 }
162
163 void didRemoveRefOrPendingIO() const {
164 if (0 == fPendingReads && 0 == fPendingWrites && 0 == fRefCnt) {
165 delete this;
166 }
robertphillips1125a032016-11-16 11:17:17 -0800167 }
168
169 mutable int32_t fRefCnt;
170 mutable int32_t fPendingReads;
171 mutable int32_t fPendingWrites;
Robert Phillipsc7635fa2016-10-28 13:25:24 -0400172};
173
174class GrSurfaceProxy : public GrIORefProxy {
robertphillips76948d42016-05-04 12:47:41 -0700175public:
Robert Phillips37430132016-11-09 06:50:43 -0500176 static sk_sp<GrSurfaceProxy> MakeWrapped(sk_sp<GrSurface>);
Robert Phillips63c67462017-02-15 14:19:01 -0500177 static sk_sp<GrTextureProxy> MakeWrapped(sk_sp<GrTexture>);
Robert Phillips37430132016-11-09 06:50:43 -0500178
Robert Phillips26c90e02017-03-14 14:39:29 -0400179 static sk_sp<GrTextureProxy> MakeDeferred(GrResourceProvider*,
Robert Phillips7928e762017-02-28 16:30:28 -0500180 const GrSurfaceDesc&, SkBackingFit,
181 SkBudgeted, uint32_t flags = 0);
Robert Phillips37430132016-11-09 06:50:43 -0500182
183 // TODO: need to refine ownership semantics of 'srcData' if we're in completely
184 // deferred mode
Robert Phillips26c90e02017-03-14 14:39:29 -0400185 static sk_sp<GrTextureProxy> MakeDeferred(GrResourceProvider*,
Robert Phillips37430132016-11-09 06:50:43 -0500186 const GrSurfaceDesc&, SkBudgeted,
187 const void* srcData, size_t rowBytes);
188
Greg Daniel7ef28f32017-04-20 16:41:55 +0000189 static sk_sp<GrTextureProxy> MakeWrappedBackend(GrContext*, GrBackendTexture&, GrSurfaceOrigin);
Robert Phillips26caf892017-01-27 10:58:31 -0500190
robertphillips76948d42016-05-04 12:47:41 -0700191 GrSurfaceOrigin origin() const {
Brian Salomonbb5711a2017-05-17 13:49:59 -0400192 SkASSERT(kTopLeft_GrSurfaceOrigin == fOrigin || kBottomLeft_GrSurfaceOrigin == fOrigin);
193 return fOrigin;
robertphillips76948d42016-05-04 12:47:41 -0700194 }
Brian Salomonbb5711a2017-05-17 13:49:59 -0400195 int width() const { return fWidth; }
196 int height() const { return fHeight; }
197 GrPixelConfig config() const { return fConfig; }
robertphillips76948d42016-05-04 12:47:41 -0700198
Robert Phillips294870f2016-11-11 12:38:40 -0500199 class UniqueID {
200 public:
Robert Phillips7ee385e2017-03-30 08:02:11 -0400201 static UniqueID InvalidID() {
202 return UniqueID(uint32_t(SK_InvalidUniqueID));
203 }
204
Robert Phillips294870f2016-11-11 12:38:40 -0500205 // wrapped
206 explicit UniqueID(const GrGpuResource::UniqueID& id) : fID(id.asUInt()) { }
207 // deferred
208 UniqueID() : fID(GrGpuResource::CreateUniqueID()) { }
209
210 uint32_t asUInt() const { return fID; }
211
212 bool operator==(const UniqueID& other) const {
213 return fID == other.fID;
214 }
215 bool operator!=(const UniqueID& other) const {
216 return !(*this == other);
217 }
218
Robert Phillips7ee385e2017-03-30 08:02:11 -0400219 void makeInvalid() { fID = SK_InvalidUniqueID; }
Robert Phillips294870f2016-11-11 12:38:40 -0500220 bool isInvalid() const { return SK_InvalidUniqueID == fID; }
221
222 private:
Robert Phillips7ee385e2017-03-30 08:02:11 -0400223 explicit UniqueID(uint32_t id) : fID(id) {}
224
225 uint32_t fID;
Robert Phillips294870f2016-11-11 12:38:40 -0500226 };
227
228 /*
229 * The contract for the uniqueID is:
230 * for wrapped resources:
231 * the uniqueID will match that of the wrapped resource
232 *
233 * for deferred resources:
234 * the uniqueID will be different from the real resource, when it is allocated
235 * the proxy's uniqueID will not change across the instantiate call
236 *
237 * the uniqueIDs of the proxies and the resources draw from the same pool
238 *
239 * What this boils down to is that the uniqueID of a proxy can be used to consistently
240 * track/identify a proxy but should never be used to distinguish between
241 * resources and proxies - beware!
242 */
243 UniqueID uniqueID() const { return fUniqueID; }
robertphillips76948d42016-05-04 12:47:41 -0700244
Robert Phillipseee4d6e2017-06-05 09:26:07 -0400245 virtual bool instantiate(GrResourceProvider* resourceProvider) = 0;
Robert Phillips37430132016-11-09 06:50:43 -0500246
robertphillips76948d42016-05-04 12:47:41 -0700247 /**
robertphillips13a7eee2016-08-31 15:06:24 -0700248 * Helper that gets the width and height of the surface as a bounding rectangle.
249 */
250 SkRect getBoundsRect() const { return SkRect::MakeIWH(this->width(), this->height()); }
Robert Phillips784b7bf2016-12-09 13:35:02 -0500251
robertphillips13a7eee2016-08-31 15:06:24 -0700252 /**
robertphillips76948d42016-05-04 12:47:41 -0700253 * @return the texture proxy associated with the surface proxy, may be NULL.
254 */
255 virtual GrTextureProxy* asTextureProxy() { return nullptr; }
256 virtual const GrTextureProxy* asTextureProxy() const { return nullptr; }
257
258 /**
259 * @return the render target proxy associated with the surface proxy, may be NULL.
260 */
261 virtual GrRenderTargetProxy* asRenderTargetProxy() { return nullptr; }
262 virtual const GrRenderTargetProxy* asRenderTargetProxy() const { return nullptr; }
263
robertphillips13a7eee2016-08-31 15:06:24 -0700264 /**
265 * Does the resource count against the resource budget?
266 */
267 SkBudgeted isBudgeted() const { return fBudgeted; }
268
Robert Phillipsf2361d22016-10-25 14:20:06 -0400269 void setLastOpList(GrOpList* opList);
270 GrOpList* getLastOpList() { return fLastOpList; }
271
Brian Osman45580d32016-11-23 09:37:01 -0500272 GrRenderTargetOpList* getLastRenderTargetOpList();
273 GrTextureOpList* getLastTextureOpList();
274
Robert Phillips8bc06d02016-11-01 17:28:40 -0400275 /**
Robert Phillipsf5442bb2017-04-17 14:18:34 -0400276 * Retrieves the amount of GPU memory that will be or currently is used by this resource
Robert Phillips8bc06d02016-11-01 17:28:40 -0400277 * in bytes. It is approximate since we aren't aware of additional padding or copies made
278 * by the driver.
279 *
280 * @return the amount of GPU memory used in bytes
281 */
282 size_t gpuMemorySize() const {
Brian Salomonbb5711a2017-05-17 13:49:59 -0400283 if (fTarget) {
284 return fTarget->gpuMemorySize();
285 }
Robert Phillips8bc06d02016-11-01 17:28:40 -0400286 if (kInvalidGpuMemorySize == fGpuMemorySize) {
Brian Salomonbb5711a2017-05-17 13:49:59 -0400287 fGpuMemorySize = this->onUninstantiatedGpuMemorySize();
Robert Phillips8bc06d02016-11-01 17:28:40 -0400288 SkASSERT(kInvalidGpuMemorySize != fGpuMemorySize);
289 }
290 return fGpuMemorySize;
291 }
292
Robert Phillipse2f7d182016-12-15 09:23:05 -0500293 // Helper function that creates a temporary SurfaceContext to perform the copy
Robert Phillips0ae6faa2017-03-21 16:22:00 -0400294 // It always returns a kExact-backed proxy bc it is used when converting an SkSpecialImage
Brian Salomon63e79732017-05-15 21:23:13 -0400295 // to an SkImage. The copy is is not a render target and not multisampled.
Robert Phillips63c67462017-02-15 14:19:01 -0500296 static sk_sp<GrTextureProxy> Copy(GrContext*, GrSurfaceProxy* src,
Robert Phillipse2f7d182016-12-15 09:23:05 -0500297 SkIRect srcRect, SkBudgeted);
298
299 // Copy the entire 'src'
Robert Phillips0ae6faa2017-03-21 16:22:00 -0400300 // It always returns a kExact-backed proxy bc it is used in SkGpuDevice::snapSpecial
Robert Phillips63c67462017-02-15 14:19:01 -0500301 static sk_sp<GrTextureProxy> Copy(GrContext* context, GrSurfaceProxy* src,
302 SkBudgeted budgeted);
Robert Phillipse2f7d182016-12-15 09:23:05 -0500303
304 // Test-only entry point - should decrease in use as proxies propagate
Robert Phillipsd46697a2017-01-25 12:10:37 -0500305 static sk_sp<GrSurfaceContext> TestCopy(GrContext* context, const GrSurfaceDesc& dstDesc,
306 GrSurfaceProxy* srcProxy);
Robert Phillipse2f7d182016-12-15 09:23:05 -0500307
Robert Phillipseaa86252016-11-08 13:49:39 +0000308 bool isWrapped_ForTesting() const;
309
Brian Osman45580d32016-11-23 09:37:01 -0500310 SkDEBUGCODE(void validate(GrContext*) const;)
311
Robert Phillips757914d2017-01-25 15:48:30 -0500312 // Provides access to functions that aren't part of the public API.
313 GrSurfaceProxyPriv priv();
314 const GrSurfaceProxyPriv priv() const;
315
robertphillips76948d42016-05-04 12:47:41 -0700316protected:
robertphillips8abb3702016-08-31 14:04:06 -0700317 // Deferred version
Robert Phillipsc787e492017-02-28 11:26:32 -0500318 GrSurfaceProxy(const GrSurfaceDesc& desc, SkBackingFit fit, SkBudgeted budgeted, uint32_t flags)
Brian Salomonbb5711a2017-05-17 13:49:59 -0400319 : fConfig(desc.fConfig)
320 , fWidth(desc.fWidth)
321 , fHeight(desc.fHeight)
322 , fOrigin(desc.fOrigin)
323 , fFit(fit)
324 , fBudgeted(budgeted)
325 , fFlags(flags)
Brian Salomond17b4a62017-05-23 16:53:47 -0400326 , fNeedsClear(SkToBool(desc.fFlags & kPerformInitialClear_GrSurfaceFlag))
Brian Salomonbb5711a2017-05-17 13:49:59 -0400327 , fGpuMemorySize(kInvalidGpuMemorySize)
328 , fLastOpList(nullptr) {
Robert Phillips294870f2016-11-11 12:38:40 -0500329 // Note: this ctor pulls a new uniqueID from the same pool at the GrGpuResources
robertphillips8abb3702016-08-31 14:04:06 -0700330 }
331
332 // Wrapped version
Robert Phillipsc7635fa2016-10-28 13:25:24 -0400333 GrSurfaceProxy(sk_sp<GrSurface> surface, SkBackingFit fit);
robertphillips76948d42016-05-04 12:47:41 -0700334
Robert Phillipsf2361d22016-10-25 14:20:06 -0400335 virtual ~GrSurfaceProxy();
336
Robert Phillips757914d2017-01-25 15:48:30 -0500337 friend class GrSurfaceProxyPriv;
338
339 // Methods made available via GrSurfaceProxyPriv
340 bool hasPendingIO() const {
341 return this->internalHasPendingIO();
342 }
343
Robert Phillips7ee385e2017-03-30 08:02:11 -0400344 bool hasPendingWrite() const {
345 return this->internalHasPendingWrite();
346 }
347
Robert Phillipseee4d6e2017-06-05 09:26:07 -0400348 bool instantiateImpl(GrResourceProvider* resourceProvider, int sampleCnt,
349 GrSurfaceFlags flags, bool isMipMapped,
350 SkDestinationSurfaceColorMode mipColorMode);
Brian Salomonbb5711a2017-05-17 13:49:59 -0400351
352 // For wrapped resources, 'fConfig', 'fWidth', 'fHeight', and 'fOrigin; will always be filled in
353 // from the wrapped resource.
354 GrPixelConfig fConfig;
355 int fWidth;
356 int fHeight;
357 GrSurfaceOrigin fOrigin;
Robert Phillips0ae6faa2017-03-21 16:22:00 -0400358 SkBackingFit fFit; // always exact for wrapped resources
Robert Phillipsb726d582017-03-09 16:36:32 -0500359 mutable SkBudgeted fBudgeted; // set from the backing resource for wrapped resources
360 // mutable bc of SkSurface/SkImage wishy-washiness
Robert Phillipsc787e492017-02-28 11:26:32 -0500361 const uint32_t fFlags;
Robert Phillipsa4c41b32017-03-15 13:02:45 -0400362
Robert Phillips294870f2016-11-11 12:38:40 -0500363 const UniqueID fUniqueID; // set from the backing resource for wrapped resources
robertphillips76948d42016-05-04 12:47:41 -0700364
Robert Phillips8bc06d02016-11-01 17:28:40 -0400365 static const size_t kInvalidGpuMemorySize = ~static_cast<size_t>(0);
Robert Phillips29e52f12016-11-03 10:19:14 -0400366 SkDEBUGCODE(size_t getRawGpuMemorySize_debugOnly() const { return fGpuMemorySize; })
367
368private:
Brian Salomonbb5711a2017-05-17 13:49:59 -0400369 virtual size_t onUninstantiatedGpuMemorySize() const = 0;
Robert Phillips29e52f12016-11-03 10:19:14 -0400370
Brian Salomond17b4a62017-05-23 16:53:47 -0400371 bool fNeedsClear;
372
Robert Phillips8bc06d02016-11-01 17:28:40 -0400373 // This entry is lazily evaluated so, when the proxy wraps a resource, the resource
374 // will be called but, when the proxy is deferred, it will compute the answer itself.
375 // If the proxy computes its own answer that answer is checked (in debug mode) in
376 // the instantiation method.
377 mutable size_t fGpuMemorySize;
378
Robert Phillipsf2361d22016-10-25 14:20:06 -0400379 // The last opList that wrote to or is currently going to write to this surface
Robert Phillipsb6deea82017-05-11 14:14:30 -0400380 // The opList can be closed (e.g., no surface context is currently bound
381 // to this proxy).
Robert Phillipsf2361d22016-10-25 14:20:06 -0400382 // This back-pointer is required so that we can add a dependancy between
383 // the opList used to create the current contents of this surface
384 // and the opList of a destination surface to which this one is being drawn or copied.
Robert Phillips6cdc22c2017-05-11 16:29:14 -0400385 // This pointer is unreffed. OpLists own a ref on their surface proxies.
Robert Phillipsf2361d22016-10-25 14:20:06 -0400386 GrOpList* fLastOpList;
387
Robert Phillipsc7635fa2016-10-28 13:25:24 -0400388 typedef GrIORefProxy INHERITED;
robertphillips76948d42016-05-04 12:47:41 -0700389};
390
391#endif