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 #ifndef GrContextPriv_DEFINED
9 #define GrContextPriv_DEFINED
10
11 #include "GrContext.h"
12 #include "GrSurfaceContext.h"
13 #include "text/GrAtlasManager.h"
14
15 class GrBackendRenderTarget;
16 class GrOnFlushCallbackObject;
17 class GrSemaphore;
18 class GrSurfaceProxy;
19 class GrTextureContext;
20
21 class SkDeferredDisplayList;
22
23 /** Class that adds methods to GrContext that are only intended for use internal to Skia.
24 This class is purely a privileged window into GrContext. It should never have additional
25 data members or virtual methods. */
26 class GrContextPriv {
27 public:
28 /**
29 * Create a GrContext without a resource cache
30 */
31 static sk_sp<GrContext> MakeDDL(sk_sp<GrContextThreadSafeProxy>);
32
drawingManager()33 GrDrawingManager* drawingManager() { return fContext->fDrawingManager.get(); }
34
35 sk_sp<GrSurfaceContext> makeWrappedSurfaceContext(sk_sp<GrSurfaceProxy>,
36 sk_sp<SkColorSpace> = nullptr,
37 const SkSurfaceProps* = nullptr);
38
39 sk_sp<GrSurfaceContext> makeDeferredSurfaceContext(const GrSurfaceDesc&,
40 GrMipMapped,
41 SkBackingFit,
42 SkBudgeted,
43 sk_sp<SkColorSpace> colorSpace = nullptr,
44 const SkSurfaceProps* = nullptr);
45
46 sk_sp<GrTextureContext> makeBackendTextureContext(const GrBackendTexture& tex,
47 GrSurfaceOrigin origin,
48 sk_sp<SkColorSpace> colorSpace);
49
50 sk_sp<GrRenderTargetContext> makeBackendTextureRenderTargetContext(
51 const GrBackendTexture& tex,
52 GrSurfaceOrigin origin,
53 int sampleCnt,
54 sk_sp<SkColorSpace> colorSpace,
55 const SkSurfaceProps* = nullptr);
56
57 sk_sp<GrRenderTargetContext> makeBackendRenderTargetRenderTargetContext(
58 const GrBackendRenderTarget&,
59 GrSurfaceOrigin origin,
60 sk_sp<SkColorSpace> colorSpace,
61 const SkSurfaceProps* = nullptr);
62
63 sk_sp<GrRenderTargetContext> makeBackendTextureAsRenderTargetRenderTargetContext(
64 const GrBackendTexture& tex,
65 GrSurfaceOrigin origin,
66 int sampleCnt,
67 sk_sp<SkColorSpace> colorSpace,
68 const SkSurfaceProps* = nullptr);
69
disableGpuYUVConversion()70 bool disableGpuYUVConversion() const { return fContext->fDisableGpuYUVConversion; }
sharpenMipmappedTextures()71 bool sharpenMipmappedTextures() const { return fContext->fSharpenMipmappedTextures; }
72
73 /**
74 * Call to ensure all drawing to the context has been issued to the
75 * underlying 3D API.
76 * The 'proxy' parameter is a hint. If it is supplied the context will guarantee that
77 * the draws required for that proxy are flushed but it could do more. If no 'proxy' is
78 * provided then all current work will be flushed.
79 */
80 void flush(GrSurfaceProxy*);
81
82 /**
83 * Registers an object for flush-related callbacks. (See GrOnFlushCallbackObject.)
84 *
85 * NOTE: the drawing manager tracks this object as a raw pointer; it is up to the caller to
86 * ensure its lifetime is tied to that of the context.
87 */
88 void addOnFlushCallbackObject(GrOnFlushCallbackObject*);
89
90 void testingOnly_flushAndRemoveOnFlushCallbackObject(GrOnFlushCallbackObject*);
91
92 /**
93 * After this returns any pending writes to the surface will have been issued to the
94 * backend 3D API.
95 */
96 void flushSurfaceWrites(GrSurfaceProxy*);
97
98 /**
99 * After this returns any pending reads or writes to the surface will have been issued to the
100 * backend 3D API.
101 */
102 void flushSurfaceIO(GrSurfaceProxy*);
103
104 /**
105 * Finalizes all pending reads and writes to the surface and also performs an MSAA resolve
106 * if necessary.
107 *
108 * It is not necessary to call this before reading the render target via Skia/GrContext.
109 * GrContext will detect when it must perform a resolve before reading pixels back from the
110 * surface or using it as a texture.
111 */
112 void prepareSurfaceForExternalIO(GrSurfaceProxy*);
113
114 /**
115 * These flags can be used with the read/write pixels functions below.
116 */
117 enum PixelOpsFlags {
118 /** The GrContext will not be flushed before the surface read or write. This means that
119 the read or write may occur before previous draws have executed. */
120 kDontFlush_PixelOpsFlag = 0x1,
121 /** Any surface writes should be flushed to the backend 3D API after the surface operation
122 is complete */
123 kFlushWrites_PixelOp = 0x2,
124 /** The src for write or dst read is unpremultiplied. This is only respected if both the
125 config src and dst configs are an RGBA/BGRA 8888 format. */
126 kUnpremul_PixelOpsFlag = 0x4,
127 };
128
129 /**
130 * Reads a rectangle of pixels from a surface.
131 * @param src the surface context to read from.
132 * @param left left edge of the rectangle to read (inclusive)
133 * @param top top edge of the rectangle to read (inclusive)
134 * @param width width of rectangle to read in pixels.
135 * @param height height of rectangle to read in pixels.
136 * @param dstConfig the pixel config of the destination buffer
137 * @param dstColorSpace color space of the destination buffer
138 * @param buffer memory to read the rectangle into.
139 * @param rowBytes number of bytes bewtween consecutive rows. Zero means rows are tightly
140 * packed.
141 * @param pixelOpsFlags see PixelOpsFlags enum above.
142 *
143 * @return true if the read succeeded, false if not. The read can fail because of an unsupported
144 * pixel configs
145 */
146 bool readSurfacePixels(GrSurfaceContext* src, int left, int top, int width, int height,
147 GrColorType dstColorType, SkColorSpace* dstColorSpace, void* buffer,
148 size_t rowBytes = 0, uint32_t pixelOpsFlags = 0);
149
150 /**
151 * Writes a rectangle of pixels to a surface. There are currently two versions of this.
152 * writeSurfacePixels() is the older version which will be replaced by the more robust and
153 * maintainable (but perhaps slower) writeSurfacePixels2().
154 *
155 * @param dst the surface context to write to.
156 * @param left left edge of the rectangle to write (inclusive)
157 * @param top top edge of the rectangle to write (inclusive)
158 * @param width width of rectangle to write in pixels.
159 * @param height height of rectangle to write in pixels.
160 * @param srcColorType the color type of the source buffer
161 * @param srcColorSpace color space of the source buffer
162 * @param buffer memory to read pixels from
163 * @param rowBytes number of bytes between consecutive rows. Zero
164 * means rows are tightly packed.
165 * @param pixelOpsFlags see PixelOpsFlags enum above.
166 * @return true if the write succeeded, false if not. The write can fail because of an
167 * unsupported combination of surface and src configs.
168 */
169 bool writeSurfacePixels(GrSurfaceContext* dst, int left, int top, int width, int height,
170 GrColorType srcColorType, SkColorSpace* srcColorSpace,
171 const void* buffer, size_t rowBytes, uint32_t pixelOpsFlags = 0);
172 bool writeSurfacePixels2(GrSurfaceContext* dst, int left, int top, int width, int height,
173 GrColorType srcColorType, SkColorSpace* srcColorSpace,
174 const void* buffer, size_t rowBytes, uint32_t pixelOpsFlags = 0);
175
getBackend()176 GrBackend getBackend() const { return fContext->fBackend; }
177
getTaskGroup()178 SkTaskGroup* getTaskGroup() { return fContext->fTaskGroup.get(); }
179
proxyProvider()180 GrProxyProvider* proxyProvider() { return fContext->fProxyProvider; }
proxyProvider()181 const GrProxyProvider* proxyProvider() const { return fContext->fProxyProvider; }
182
resourceProvider()183 GrResourceProvider* resourceProvider() { return fContext->fResourceProvider; }
resourceProvider()184 const GrResourceProvider* resourceProvider() const { return fContext->fResourceProvider; }
185
getResourceCache()186 GrResourceCache* getResourceCache() { return fContext->fResourceCache; }
187
getGpu()188 GrGpu* getGpu() { return fContext->fGpu.get(); }
getGpu()189 const GrGpu* getGpu() const { return fContext->fGpu.get(); }
190
getGlyphCache()191 GrGlyphCache* getGlyphCache() { return fContext->fGlyphCache; }
getTextBlobCache()192 GrTextBlobCache* getTextBlobCache() { return fContext->fTextBlobCache.get(); }
193
getRestrictedAtlasManager()194 GrRestrictedAtlasManager* getRestrictedAtlasManager() {
195 return fContext->onGetRestrictedAtlasManager();
196 }
197
198 // This accessor should only ever be called by the GrOpFlushState.
getFullAtlasManager()199 GrAtlasManager* getFullAtlasManager() {
200 return fContext->onGetFullAtlasManager();
201 }
202
203 void moveOpListsToDDL(SkDeferredDisplayList*);
204 void copyOpListsFromDDL(const SkDeferredDisplayList*, GrRenderTargetProxy* newDest);
205
206 private:
GrContextPriv(GrContext * context)207 explicit GrContextPriv(GrContext* context) : fContext(context) {}
208 GrContextPriv(const GrContextPriv&); // unimpl
209 GrContextPriv& operator=(const GrContextPriv&); // unimpl
210
211 // No taking addresses of this type.
212 const GrContextPriv* operator&() const;
213 GrContextPriv* operator&();
214
215 GrContext* fContext;
216
217 friend class GrContext; // to construct/copy this type.
218 };
219
contextPriv()220 inline GrContextPriv GrContext::contextPriv() { return GrContextPriv(this); }
221
contextPriv()222 inline const GrContextPriv GrContext::contextPriv () const {
223 return GrContextPriv(const_cast<GrContext*>(this));
224 }
225
226 #endif
227