1 /*
2 * Copyright 2011 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 "GrContext.h"
9 #include "GrBackendSemaphore.h"
10 #include "GrClip.h"
11 #include "GrContextOptions.h"
12 #include "GrContextPriv.h"
13 #include "GrDrawingManager.h"
14 #include "GrGpu.h"
15 #include "GrProxyProvider.h"
16 #include "GrRenderTargetContext.h"
17 #include "GrRenderTargetProxy.h"
18 #include "GrResourceCache.h"
19 #include "GrResourceProvider.h"
20 #include "GrSemaphore.h"
21 #include "GrSoftwarePathRenderer.h"
22 #include "GrSurfaceContext.h"
23 #include "GrSurfacePriv.h"
24 #include "GrSurfaceProxyPriv.h"
25 #include "GrTexture.h"
26 #include "GrTextureContext.h"
27 #include "GrTracing.h"
28 #include "SkConvertPixels.h"
29 #include "SkDeferredDisplayList.h"
30 #include "SkGr.h"
31 #include "SkImageInfoPriv.h"
32 #include "SkJSONWriter.h"
33 #include "SkMakeUnique.h"
34 #include "SkTaskGroup.h"
35 #include "SkUnPreMultiplyPriv.h"
36 #include "effects/GrConfigConversionEffect.h"
37 #include "gl/GrGLGpu.h"
38 #include "mock/GrMockGpu.h"
39 #include "text/GrTextBlobCache.h"
40 #ifdef SK_METAL
41 #include "mtl/GrMtlTrampoline.h"
42 #endif
43 #ifdef SK_VULKAN
44 #include "vk/GrVkGpu.h"
45 #endif
46
47 #define ASSERT_OWNED_PROXY(P) \
48 SkASSERT(!(P) || !((P)->priv().peekTexture()) || (P)->priv().peekTexture()->getContext() == this)
49 #define ASSERT_OWNED_PROXY_PRIV(P) \
50 SkASSERT(!(P) || !((P)->priv().peekTexture()) || (P)->priv().peekTexture()->getContext() == fContext)
51
52 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
53 #define ASSERT_SINGLE_OWNER \
54 SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(&fSingleOwner);)
55 #define ASSERT_SINGLE_OWNER_PRIV \
56 SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(&fContext->fSingleOwner);)
57 #define RETURN_IF_ABANDONED if (fDrawingManager->wasAbandoned()) { return; }
58 #define RETURN_IF_ABANDONED_PRIV if (fContext->fDrawingManager->wasAbandoned()) { return; }
59 #define RETURN_FALSE_IF_ABANDONED if (fDrawingManager->wasAbandoned()) { return false; }
60 #define RETURN_FALSE_IF_ABANDONED_PRIV if (fContext->fDrawingManager->wasAbandoned()) { return false; }
61 #define RETURN_NULL_IF_ABANDONED if (fDrawingManager->wasAbandoned()) { return nullptr; }
62
63 ////////////////////////////////////////////////////////////////////////////////
64
65 class SK_API GrDirectContext : public GrContext {
66 public:
GrDirectContext(GrBackend backend)67 GrDirectContext(GrBackend backend) : INHERITED(backend) { }
68
69 protected:
70
71 private:
72 typedef GrContext INHERITED;
73 };
74
75 class SK_API GrDDLContext : public GrContext {
76 public:
GrDDLContext(GrContextThreadSafeProxy * proxy)77 GrDDLContext(GrContextThreadSafeProxy* proxy) : INHERITED(proxy) {}
78
79 protected:
80
81 private:
82 typedef GrContext INHERITED;
83 };
84
Create(GrBackend backend,GrBackendContext backendContext)85 GrContext* GrContext::Create(GrBackend backend, GrBackendContext backendContext) {
86 GrContextOptions defaultOptions;
87 return Create(backend, backendContext, defaultOptions);
88 }
89
Create(GrBackend backend,GrBackendContext backendContext,const GrContextOptions & options)90 GrContext* GrContext::Create(GrBackend backend, GrBackendContext backendContext,
91 const GrContextOptions& options) {
92
93 sk_sp<GrContext> context(new GrDirectContext(backend));
94
95 context->fGpu = GrGpu::Make(backend, backendContext, options, context.get());
96 if (!context->fGpu) {
97 return nullptr;
98 }
99
100 if (!context->init(options)) {
101 return nullptr;
102 }
103
104 return context.release();
105 }
106
MakeGL(sk_sp<const GrGLInterface> interface)107 sk_sp<GrContext> GrContext::MakeGL(sk_sp<const GrGLInterface> interface) {
108 GrContextOptions defaultOptions;
109 return MakeGL(std::move(interface), defaultOptions);
110 }
111
MakeGL(sk_sp<const GrGLInterface> interface,const GrContextOptions & options)112 sk_sp<GrContext> GrContext::MakeGL(sk_sp<const GrGLInterface> interface,
113 const GrContextOptions& options) {
114 sk_sp<GrContext> context(new GrDirectContext(kOpenGL_GrBackend));
115
116 context->fGpu = GrGLGpu::Make(std::move(interface), options, context.get());
117 if (!context->fGpu) {
118 return nullptr;
119 }
120 if (!context->init(options)) {
121 return nullptr;
122 }
123 return context;
124 }
125
MakeGL(const GrGLInterface * interface)126 sk_sp<GrContext> GrContext::MakeGL(const GrGLInterface* interface) {
127 return MakeGL(sk_ref_sp(interface));
128 }
129
MakeGL(const GrGLInterface * interface,const GrContextOptions & options)130 sk_sp<GrContext> GrContext::MakeGL(const GrGLInterface* interface,
131 const GrContextOptions& options) {
132 return MakeGL(sk_ref_sp(interface), options);
133 }
134
MakeMock(const GrMockOptions * mockOptions)135 sk_sp<GrContext> GrContext::MakeMock(const GrMockOptions* mockOptions) {
136 GrContextOptions defaultOptions;
137 return MakeMock(mockOptions, defaultOptions);
138 }
139
MakeMock(const GrMockOptions * mockOptions,const GrContextOptions & options)140 sk_sp<GrContext> GrContext::MakeMock(const GrMockOptions* mockOptions,
141 const GrContextOptions& options) {
142 sk_sp<GrContext> context(new GrDirectContext(kMock_GrBackend));
143
144 context->fGpu = GrMockGpu::Make(mockOptions, options, context.get());
145 if (!context->fGpu) {
146 return nullptr;
147 }
148 if (!context->init(options)) {
149 return nullptr;
150 }
151 return context;
152 }
153
154 #ifdef SK_VULKAN
MakeVulkan(sk_sp<const GrVkBackendContext> backendContext)155 sk_sp<GrContext> GrContext::MakeVulkan(sk_sp<const GrVkBackendContext> backendContext) {
156 GrContextOptions defaultOptions;
157 return MakeVulkan(std::move(backendContext), defaultOptions);
158 }
159
MakeVulkan(sk_sp<const GrVkBackendContext> backendContext,const GrContextOptions & options)160 sk_sp<GrContext> GrContext::MakeVulkan(sk_sp<const GrVkBackendContext> backendContext,
161 const GrContextOptions& options) {
162 sk_sp<GrContext> context(new GrDirectContext(kVulkan_GrBackend));
163
164 context->fGpu = GrVkGpu::Make(std::move(backendContext), options, context.get());
165 if (!context->fGpu) {
166 return nullptr;
167 }
168 if (!context->init(options)) {
169 return nullptr;
170 }
171 return context;
172 }
173 #endif
174
175 #ifdef SK_METAL
MakeMetal(void * device,void * queue)176 sk_sp<GrContext> GrContext::MakeMetal(void* device, void* queue) {
177 GrContextOptions defaultOptions;
178 return MakeMetal(device, queue, defaultOptions);
179 }
180
MakeMetal(void * device,void * queue,const GrContextOptions & options)181 sk_sp<GrContext> GrContext::MakeMetal(void* device, void* queue, const GrContextOptions& options) {
182 sk_sp<GrContext> context(new GrContext(kMetal_GrBackend));
183
184 context->fGpu = GrMtlTrampoline::MakeGpu(context.get(), options, device, queue);
185 if (!context->fGpu) {
186 return nullptr;
187 }
188 if (!context->init(options)) {
189 return nullptr;
190 }
191 return context;
192 }
193 #endif
194
195 static int32_t gNextID = 1;
next_id()196 static int32_t next_id() {
197 int32_t id;
198 do {
199 id = sk_atomic_inc(&gNextID);
200 } while (id == SK_InvalidGenID);
201 return id;
202 }
203
MakeDDL(GrContextThreadSafeProxy * proxy)204 sk_sp<GrContext> GrContextPriv::MakeDDL(GrContextThreadSafeProxy* proxy) {
205 sk_sp<GrContext> context(new GrDDLContext(proxy));
206
207 // Note: we aren't creating a Gpu here. This causes the resource provider & cache to
208 // also not be created
209 if (!context->init(proxy->fOptions)) {
210 return nullptr;
211 }
212 return context;
213 }
214
GrContext(GrBackend backend)215 GrContext::GrContext(GrBackend backend)
216 : fUniqueID(next_id())
217 , fBackend(backend) {
218 fResourceCache = nullptr;
219 fResourceProvider = nullptr;
220 fProxyProvider = nullptr;
221 fAtlasGlyphCache = nullptr;
222 }
223
GrContext(GrContextThreadSafeProxy * proxy)224 GrContext::GrContext(GrContextThreadSafeProxy* proxy)
225 : fCaps(proxy->fCaps)
226 , fUniqueID(proxy->fContextUniqueID)
227 , fBackend(proxy->fBackend) {
228 fResourceCache = nullptr;
229 fResourceProvider = nullptr;
230 fProxyProvider = nullptr;
231 fAtlasGlyphCache = nullptr;
232 }
233
init(const GrContextOptions & options)234 bool GrContext::init(const GrContextOptions& options) {
235 ASSERT_SINGLE_OWNER
236
237 if (fGpu) {
238 fCaps = fGpu->refCaps();
239 fResourceCache = new GrResourceCache(fCaps.get(), fUniqueID);
240 fResourceProvider = new GrResourceProvider(fGpu.get(), fResourceCache, &fSingleOwner,
241 options.fExplicitlyAllocateGPUResources);
242 }
243
244 fProxyProvider = new GrProxyProvider(fResourceProvider, fResourceCache, fCaps, &fSingleOwner);
245
246 if (fResourceCache) {
247 fResourceCache->setProxyProvider(fProxyProvider);
248 }
249
250 // DDL TODO: we need to think through how the task group & persistent cache
251 // get passed on to/shared between all the DDLRecorders created with this context.
252 fThreadSafeProxy.reset(new GrContextThreadSafeProxy(fCaps, this->uniqueID(), fBackend,
253 options));
254
255 fDisableGpuYUVConversion = options.fDisableGpuYUVConversion;
256 fSharpenMipmappedTextures = options.fSharpenMipmappedTextures;
257 fDidTestPMConversions = false;
258
259 GrPathRendererChain::Options prcOptions;
260 prcOptions.fAllowPathMaskCaching = options.fAllowPathMaskCaching;
261 #if GR_TEST_UTILS
262 prcOptions.fGpuPathRenderers = options.fGpuPathRenderers;
263 #endif
264 if (options.fDisableDistanceFieldPaths) {
265 prcOptions.fGpuPathRenderers &= ~GpuPathRenderers::kSmall;
266 }
267
268 if (!fResourceCache) {
269 // DDL TODO: remove this crippling of the path renderer chain
270 // Disable the small path renderer bc of the proxies in the atlas. They need to be
271 // unified when the opLists are added back to the destination drawing manager.
272 prcOptions.fGpuPathRenderers &= ~GpuPathRenderers::kSmall;
273 }
274
275 GrAtlasTextContext::Options atlasTextContextOptions;
276 atlasTextContextOptions.fMaxDistanceFieldFontSize = options.fGlyphsAsPathsFontSize;
277 atlasTextContextOptions.fMinDistanceFieldFontSize = options.fMinDistanceFieldFontSize;
278 atlasTextContextOptions.fDistanceFieldVerticesAlwaysHaveW = false;
279 #if SK_SUPPORT_ATLAS_TEXT
280 if (GrContextOptions::Enable::kYes == options.fDistanceFieldGlyphVerticesAlwaysHaveW) {
281 atlasTextContextOptions.fDistanceFieldVerticesAlwaysHaveW = true;
282 }
283 #endif
284
285 fDrawingManager.reset(new GrDrawingManager(this, prcOptions, atlasTextContextOptions,
286 &fSingleOwner, options.fSortRenderTargets));
287
288 GrDrawOpAtlas::AllowMultitexturing allowMultitexturing;
289 if (GrContextOptions::Enable::kNo == options.fAllowMultipleGlyphCacheTextures ||
290 // multitexturing supported only if range can represent the index + texcoords fully
291 !(fCaps->shaderCaps()->floatIs32Bits() || fCaps->shaderCaps()->integerSupport())) {
292 allowMultitexturing = GrDrawOpAtlas::AllowMultitexturing::kNo;
293 } else {
294 allowMultitexturing = GrDrawOpAtlas::AllowMultitexturing::kYes;
295 }
296 fAtlasGlyphCache = new GrAtlasGlyphCache(this, options.fGlyphCacheTextureMaximumBytes,
297 allowMultitexturing);
298 this->contextPriv().addOnFlushCallbackObject(fAtlasGlyphCache);
299
300 fTextBlobCache.reset(new GrTextBlobCache(TextBlobCacheOverBudgetCB,
301 this, this->uniqueID(), SkToBool(fGpu)));
302
303 if (options.fExecutor) {
304 fTaskGroup = skstd::make_unique<SkTaskGroup>(*options.fExecutor);
305 }
306
307 fPersistentCache = options.fPersistentCache;
308
309 return true;
310 }
311
~GrContext()312 GrContext::~GrContext() {
313 ASSERT_SINGLE_OWNER
314
315 if (fGpu) {
316 this->flush();
317 }
318
319 if (fDrawingManager) {
320 fDrawingManager->cleanup();
321 }
322
323 for (int i = 0; i < fCleanUpData.count(); ++i) {
324 (*fCleanUpData[i].fFunc)(this, fCleanUpData[i].fInfo);
325 }
326
327 delete fResourceProvider;
328 delete fResourceCache;
329 delete fProxyProvider;
330 delete fAtlasGlyphCache;
331 }
332
threadSafeProxy()333 sk_sp<GrContextThreadSafeProxy> GrContext::threadSafeProxy() {
334 return fThreadSafeProxy;
335 }
336
createCharacterization(size_t cacheMaxResourceBytes,const SkImageInfo & ii,const GrBackendFormat & backendFormat,int sampleCnt,GrSurfaceOrigin origin,const SkSurfaceProps & surfaceProps,bool isMipMapped)337 SkSurfaceCharacterization GrContextThreadSafeProxy::createCharacterization(
338 size_t cacheMaxResourceBytes,
339 const SkImageInfo& ii, const GrBackendFormat& backendFormat,
340 int sampleCnt, GrSurfaceOrigin origin,
341 const SkSurfaceProps& surfaceProps,
342 bool isMipMapped) {
343 if (!backendFormat.isValid()) {
344 return SkSurfaceCharacterization(); // return an invalid characterization
345 }
346
347 // We're assuming GrFSAAType::kMixedSamples will never be specified via this code path
348 GrFSAAType FSAAType = sampleCnt > 1 ? GrFSAAType::kUnifiedMSAA : GrFSAAType::kNone;
349
350 if (!fCaps->mipMapSupport()) {
351 isMipMapped = false;
352 }
353
354 GrPixelConfig config = kUnknown_GrPixelConfig;
355 if (!fCaps->getConfigFromBackendFormat(backendFormat, ii.colorType(), &config)) {
356 return SkSurfaceCharacterization(); // return an invalid characterization
357 }
358
359 // This surface characterization factory assumes that the resulting characterization is
360 // textureable.
361 if (!fCaps->isConfigTexturable(config)) {
362 return SkSurfaceCharacterization(); // return an invalid characterization
363 }
364
365 return SkSurfaceCharacterization(sk_ref_sp<GrContextThreadSafeProxy>(this),
366 cacheMaxResourceBytes,
367 origin, ii.width(), ii.height(), config, FSAAType, sampleCnt,
368 SkSurfaceCharacterization::Textureable(true),
369 SkSurfaceCharacterization::MipMapped(isMipMapped),
370 ii.refColorSpace(), surfaceProps);
371 }
372
abandonContext()373 void GrContext::abandonContext() {
374 ASSERT_SINGLE_OWNER
375
376 fProxyProvider->abandon();
377 fResourceProvider->abandon();
378
379 // Need to abandon the drawing manager first so all the render targets
380 // will be released/forgotten before they too are abandoned.
381 fDrawingManager->abandon();
382
383 // abandon first to so destructors
384 // don't try to free the resources in the API.
385 fResourceCache->abandonAll();
386
387 fGpu->disconnect(GrGpu::DisconnectType::kAbandon);
388
389 fAtlasGlyphCache->freeAll();
390 fTextBlobCache->freeAll();
391 }
392
releaseResourcesAndAbandonContext()393 void GrContext::releaseResourcesAndAbandonContext() {
394 ASSERT_SINGLE_OWNER
395
396 fProxyProvider->abandon();
397 fResourceProvider->abandon();
398
399 // Need to abandon the drawing manager first so all the render targets
400 // will be released/forgotten before they too are abandoned.
401 fDrawingManager->abandon();
402
403 // Release all resources in the backend 3D API.
404 fResourceCache->releaseAll();
405
406 fGpu->disconnect(GrGpu::DisconnectType::kCleanup);
407
408 fAtlasGlyphCache->freeAll();
409 fTextBlobCache->freeAll();
410 }
411
resetContext(uint32_t state)412 void GrContext::resetContext(uint32_t state) {
413 ASSERT_SINGLE_OWNER
414 fGpu->markContextDirty(state);
415 }
416
freeGpuResources()417 void GrContext::freeGpuResources() {
418 ASSERT_SINGLE_OWNER
419
420 this->flush();
421
422 fAtlasGlyphCache->freeAll();
423
424 fDrawingManager->freeGpuResources();
425
426 fResourceCache->purgeAllUnlocked();
427 }
428
performDeferredCleanup(std::chrono::milliseconds msNotUsed)429 void GrContext::performDeferredCleanup(std::chrono::milliseconds msNotUsed) {
430 ASSERT_SINGLE_OWNER
431 fResourceCache->purgeAsNeeded();
432 fResourceCache->purgeResourcesNotUsedSince(GrStdSteadyClock::now() - msNotUsed);
433
434 fTextBlobCache->purgeStaleBlobs();
435 }
436
purgeUnlockedResources(size_t bytesToPurge,bool preferScratchResources)437 void GrContext::purgeUnlockedResources(size_t bytesToPurge, bool preferScratchResources) {
438 ASSERT_SINGLE_OWNER
439 fResourceCache->purgeUnlockedResources(bytesToPurge, preferScratchResources);
440 }
441
getResourceCacheUsage(int * resourceCount,size_t * resourceBytes) const442 void GrContext::getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const {
443 ASSERT_SINGLE_OWNER
444
445 if (resourceCount) {
446 *resourceCount = fResourceCache->getBudgetedResourceCount();
447 }
448 if (resourceBytes) {
449 *resourceBytes = fResourceCache->getBudgetedResourceBytes();
450 }
451 }
452
getResourceCachePurgeableBytes() const453 size_t GrContext::getResourceCachePurgeableBytes() const {
454 ASSERT_SINGLE_OWNER
455 return fResourceCache->getPurgeableBytes();
456 }
457
458 ////////////////////////////////////////////////////////////////////////////////
459
colorTypeSupportedAsImage(SkColorType colorType) const460 bool GrContext::colorTypeSupportedAsImage(SkColorType colorType) const {
461 GrPixelConfig config = SkImageInfo2GrPixelConfig(colorType, nullptr, *this->caps());
462 return this->caps()->isConfigTexturable(config);
463 }
464
maxSurfaceSampleCountForColorType(SkColorType colorType) const465 int GrContext::maxSurfaceSampleCountForColorType(SkColorType colorType) const {
466 GrPixelConfig config = SkImageInfo2GrPixelConfig(colorType, nullptr, *this->caps());
467 return this->caps()->maxRenderTargetSampleCount(config);
468 }
469
470 ////////////////////////////////////////////////////////////////////////////////
471
TextBlobCacheOverBudgetCB(void * data)472 void GrContext::TextBlobCacheOverBudgetCB(void* data) {
473 SkASSERT(data);
474 // TextBlobs are drawn at the SkGpuDevice level, therefore they cannot rely on
475 // GrRenderTargetContext to perform a necessary flush. The solution is to move drawText calls
476 // to below the GrContext level, but this is not trivial because they call drawPath on
477 // SkGpuDevice.
478 GrContext* context = reinterpret_cast<GrContext*>(data);
479 context->flush();
480 }
481
482 ////////////////////////////////////////////////////////////////////////////////
483
flush()484 void GrContext::flush() {
485 ASSERT_SINGLE_OWNER
486 RETURN_IF_ABANDONED
487
488 fDrawingManager->flush(nullptr);
489 }
490
flushAndSignalSemaphores(int numSemaphores,GrBackendSemaphore signalSemaphores[])491 GrSemaphoresSubmitted GrContext::flushAndSignalSemaphores(int numSemaphores,
492 GrBackendSemaphore signalSemaphores[]) {
493 ASSERT_SINGLE_OWNER
494 if (fDrawingManager->wasAbandoned()) { return GrSemaphoresSubmitted::kNo; }
495
496 return fDrawingManager->flush(nullptr, numSemaphores, signalSemaphores);
497 }
498
flush(GrSurfaceProxy * proxy)499 void GrContextPriv::flush(GrSurfaceProxy* proxy) {
500 ASSERT_SINGLE_OWNER_PRIV
501 RETURN_IF_ABANDONED_PRIV
502 ASSERT_OWNED_PROXY_PRIV(proxy);
503
504 fContext->fDrawingManager->flush(proxy);
505 }
506
sw_convert_to_premul(GrColorType srcColorType,int width,int height,size_t inRowBytes,const void * inPixels,size_t outRowBytes,void * outPixels)507 bool sw_convert_to_premul(GrColorType srcColorType, int width, int height, size_t inRowBytes,
508 const void* inPixels, size_t outRowBytes, void* outPixels) {
509 SkColorType colorType = GrColorTypeToSkColorType(srcColorType);
510 if (kUnknown_SkColorType == colorType || 4 != SkColorTypeBytesPerPixel(colorType)) {
511 return false;
512 }
513
514 for (int y = 0; y < height; y++) {
515 SkOpts::RGBA_to_rgbA((uint32_t*) outPixels, inPixels, width);
516 outPixels = SkTAddOffset<void>(outPixels, outRowBytes);
517 inPixels = SkTAddOffset<const void>(inPixels, inRowBytes);
518 }
519
520 return true;
521 }
522
523 // TODO: This will be removed when GrSurfaceContexts are aware of their color types.
524 // (skbug.com/6718)
valid_premul_config(GrPixelConfig config)525 static bool valid_premul_config(GrPixelConfig config) {
526 switch (config) {
527 case kUnknown_GrPixelConfig: return false;
528 case kAlpha_8_GrPixelConfig: return false;
529 case kGray_8_GrPixelConfig: return false;
530 case kRGB_565_GrPixelConfig: return false;
531 case kRGBA_4444_GrPixelConfig: return true;
532 case kRGBA_8888_GrPixelConfig: return true;
533 case kBGRA_8888_GrPixelConfig: return true;
534 case kSRGBA_8888_GrPixelConfig: return true;
535 case kSBGRA_8888_GrPixelConfig: return true;
536 case kRGBA_float_GrPixelConfig: return true;
537 case kRG_float_GrPixelConfig: return false;
538 case kAlpha_half_GrPixelConfig: return false;
539 case kRGBA_half_GrPixelConfig: return true;
540 case kAlpha_8_as_Alpha_GrPixelConfig: return false;
541 case kAlpha_8_as_Red_GrPixelConfig: return false;
542 case kAlpha_half_as_Red_GrPixelConfig: return false;
543 case kGray_8_as_Lum_GrPixelConfig: return false;
544 case kGray_8_as_Red_GrPixelConfig: return false;
545 }
546 SK_ABORT("Invalid GrPixelConfig");
547 return false;
548 }
549
valid_premul_color_type(GrColorType ct)550 static bool valid_premul_color_type(GrColorType ct) {
551 switch (ct) {
552 case GrColorType::kUnknown: return false;
553 case GrColorType::kAlpha_8: return false;
554 case GrColorType::kRGB_565: return false;
555 case GrColorType::kABGR_4444: return true;
556 case GrColorType::kRGBA_8888: return true;
557 case GrColorType::kBGRA_8888: return true;
558 case GrColorType::kGray_8: return false;
559 case GrColorType::kAlpha_F16: return false;
560 case GrColorType::kRGBA_F16: return true;
561 case GrColorType::kRG_F32: return false;
562 case GrColorType::kRGBA_F32: return true;
563 }
564 SK_ABORT("Invalid GrColorType");
565 return false;
566 }
567
valid_pixel_conversion(GrColorType cpuColorType,GrPixelConfig gpuConfig,bool premulConversion)568 static bool valid_pixel_conversion(GrColorType cpuColorType, GrPixelConfig gpuConfig,
569 bool premulConversion) {
570 // We only allow premul <-> unpremul conversions for some formats
571 if (premulConversion &&
572 (!valid_premul_color_type(cpuColorType) || !valid_premul_config(gpuConfig))) {
573 return false;
574 }
575
576 return true;
577 }
578
pm_upm_must_round_trip(GrColorType cpuColorType,const SkColorSpace * cpuColorSpace)579 static bool pm_upm_must_round_trip(GrColorType cpuColorType, const SkColorSpace* cpuColorSpace) {
580 return !cpuColorSpace &&
581 (GrColorType::kRGBA_8888 == cpuColorType || GrColorType::kBGRA_8888 == cpuColorType);
582 }
583
584 // TODO: This will be removed when GrSurfaceContexts are aware of their color types.
585 // (skbug.com/6718)
pm_upm_must_round_trip(GrPixelConfig surfaceConfig,const SkColorSpace * surfaceColorSpace)586 static bool pm_upm_must_round_trip(GrPixelConfig surfaceConfig,
587 const SkColorSpace* surfaceColorSpace) {
588 return !surfaceColorSpace &&
589 (kRGBA_8888_GrPixelConfig == surfaceConfig || kBGRA_8888_GrPixelConfig == surfaceConfig);
590 }
591
determine_write_pixels_srgb_conversion(GrColorType srcColorType,const SkColorSpace * srcColorSpace,GrSRGBEncoded dstSRGBEncoded,const SkColorSpace * dstColorSpace,const GrCaps & caps)592 static GrSRGBConversion determine_write_pixels_srgb_conversion(GrColorType srcColorType,
593 const SkColorSpace* srcColorSpace,
594 GrSRGBEncoded dstSRGBEncoded,
595 const SkColorSpace* dstColorSpace,
596 const GrCaps& caps) {
597 // No support for sRGB-encoded alpha.
598 if (GrColorTypeIsAlphaOnly(srcColorType)) {
599 return GrSRGBConversion::kNone;
600 }
601 // No conversions without GPU support for sRGB. (Legacy mode)
602 if (!caps.srgbSupport()) {
603 return GrSRGBConversion::kNone;
604 }
605 // If the GrSurfaceContext has no color space then it is in legacy mode.
606 if (!dstColorSpace) {
607 return GrSRGBConversion::kNone;
608 }
609
610 bool srcColorSpaceIsSRGB = srcColorSpace && srcColorSpace->gammaCloseToSRGB();
611 bool dstColorSpaceIsSRGB = dstColorSpace->gammaCloseToSRGB();
612
613 // For now we are assuming that if color space of the dst does not have sRGB gamma then the
614 // texture format is not sRGB encoded and vice versa. Note that we already checked for "legacy"
615 // mode being forced on by caps above. This may change in the future. We will then have to
616 // perform shader based conversions.
617 SkASSERT(dstColorSpaceIsSRGB == (GrSRGBEncoded::kYes == dstSRGBEncoded));
618
619 if (srcColorSpaceIsSRGB == dstColorSpaceIsSRGB) {
620 return GrSRGBConversion::kNone;
621 }
622 return srcColorSpaceIsSRGB ? GrSRGBConversion::kSRGBToLinear : GrSRGBConversion::kLinearToSRGB;
623 }
624
determine_read_pixels_srgb_conversion(GrSRGBEncoded srcSRGBEncoded,const SkColorSpace * srcColorSpace,GrColorType dstColorType,const SkColorSpace * dstColorSpace,const GrCaps & caps)625 static GrSRGBConversion determine_read_pixels_srgb_conversion(GrSRGBEncoded srcSRGBEncoded,
626 const SkColorSpace* srcColorSpace,
627 GrColorType dstColorType,
628 const SkColorSpace* dstColorSpace,
629 const GrCaps& caps) {
630 // This is symmetrical with the write version.
631 switch (determine_write_pixels_srgb_conversion(dstColorType, dstColorSpace, srcSRGBEncoded,
632 srcColorSpace, caps)) {
633 case GrSRGBConversion::kNone: return GrSRGBConversion::kNone;
634 case GrSRGBConversion::kLinearToSRGB: return GrSRGBConversion::kSRGBToLinear;
635 case GrSRGBConversion::kSRGBToLinear: return GrSRGBConversion::kLinearToSRGB;
636 }
637 return GrSRGBConversion::kNone;
638 }
639
writeSurfacePixels(GrSurfaceContext * dst,int left,int top,int width,int height,GrColorType srcColorType,SkColorSpace * srcColorSpace,const void * buffer,size_t rowBytes,uint32_t pixelOpsFlags)640 bool GrContextPriv::writeSurfacePixels(GrSurfaceContext* dst, int left, int top, int width,
641 int height, GrColorType srcColorType,
642 SkColorSpace* srcColorSpace, const void* buffer,
643 size_t rowBytes, uint32_t pixelOpsFlags) {
644 #ifndef SK_LEGACY_GPU_PIXEL_OPS
645 return this->writeSurfacePixels2(dst, left, top, width, height, srcColorType, srcColorSpace,
646 buffer, rowBytes, pixelOpsFlags);
647 #endif
648
649 // TODO: Color space conversion
650
651 ASSERT_SINGLE_OWNER_PRIV
652 RETURN_FALSE_IF_ABANDONED_PRIV
653 SkASSERT(dst);
654 ASSERT_OWNED_PROXY_PRIV(dst->asSurfaceProxy());
655 GR_CREATE_TRACE_MARKER_CONTEXT("GrContextPriv", "writeSurfacePixels", fContext);
656
657 if (!dst->asSurfaceProxy()->instantiate(this->resourceProvider())) {
658 return false;
659 }
660
661 GrSurfaceProxy* dstProxy = dst->asSurfaceProxy();
662 GrSurface* dstSurface = dstProxy->priv().peekSurface();
663
664 // The src is unpremul but the dst is premul -> premul the src before or as part of the write
665 const bool premul = SkToBool(kUnpremul_PixelOpsFlag & pixelOpsFlags);
666
667 if (!valid_pixel_conversion(srcColorType, dstProxy->config(), premul)) {
668 return false;
669 }
670
671 // We need to guarantee round-trip conversion if we are reading and writing 8888 non-sRGB data,
672 // without any color spaces attached, and the caller wants us to premul.
673 bool useConfigConversionEffect =
674 premul && pm_upm_must_round_trip(srcColorType, srcColorSpace) &&
675 pm_upm_must_round_trip(dstProxy->config(), dst->colorSpaceInfo().colorSpace());
676
677 // Are we going to try to premul as part of a draw? For the non-legacy case, we always allow
678 // this. GrConfigConversionEffect fails on some GPUs, so only allow this if it works perfectly.
679 bool premulOnGpu = premul &&
680 (!useConfigConversionEffect || fContext->validPMUPMConversionExists());
681
682 // Trim the params here so that if we wind up making a temporary surface it can be as small as
683 // necessary and because GrGpu::getWritePixelsInfo requires it.
684 if (!GrSurfacePriv::AdjustWritePixelParams(dstSurface->width(), dstSurface->height(),
685 GrColorTypeBytesPerPixel(srcColorType), &left, &top,
686 &width, &height, &buffer, &rowBytes)) {
687 return false;
688 }
689
690 GrGpu::DrawPreference drawPreference = premulOnGpu ? GrGpu::kCallerPrefersDraw_DrawPreference
691 : GrGpu::kNoDraw_DrawPreference;
692 GrGpu::WritePixelTempDrawInfo tempDrawInfo;
693 GrSRGBConversion srgbConversion = determine_write_pixels_srgb_conversion(
694 srcColorType, srcColorSpace, GrPixelConfigIsSRGBEncoded(dstProxy->config()),
695 dst->colorSpaceInfo().colorSpace(), *fContext->caps());
696 if (!fContext->fGpu->getWritePixelsInfo(dstSurface, dstProxy->origin(), width, height,
697 srcColorType, srgbConversion, &drawPreference,
698 &tempDrawInfo)) {
699 return false;
700 }
701
702 if (!(kDontFlush_PixelOpsFlag & pixelOpsFlags) && dstSurface->surfacePriv().hasPendingIO()) {
703 this->flush(nullptr); // MDB TODO: tighten this
704 }
705
706 sk_sp<GrTextureProxy> tempProxy;
707 if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
708 tempProxy = this->proxyProvider()->createProxy(tempDrawInfo.fTempSurfaceDesc,
709 SkBackingFit::kApprox,
710 SkBudgeted::kYes);
711 if (!tempProxy && GrGpu::kRequireDraw_DrawPreference == drawPreference) {
712 return false;
713 }
714 }
715
716 // temp buffer for doing sw premul conversion, if needed.
717 SkAutoSTMalloc<128 * 128, uint32_t> tmpPixels(0);
718 // We need to do sw premul if we were unable to create a RT for drawing, or if we can't do the
719 // premul on the GPU
720 if (premul && (!tempProxy || !premulOnGpu)) {
721 size_t tmpRowBytes = 4 * width;
722 tmpPixels.reset(width * height);
723 if (!sw_convert_to_premul(srcColorType, width, height, rowBytes, buffer, tmpRowBytes,
724 tmpPixels.get())) {
725 return false;
726 }
727 rowBytes = tmpRowBytes;
728 buffer = tmpPixels.get();
729 }
730
731 if (tempProxy) {
732 auto fp = GrSimpleTextureEffect::Make(tempProxy, SkMatrix::I());
733 if (premulOnGpu) {
734 fp = fContext->createUPMToPMEffect(std::move(fp), useConfigConversionEffect);
735 }
736 fp = GrFragmentProcessor::SwizzleOutput(std::move(fp), tempDrawInfo.fSwizzle);
737 if (!fp) {
738 return false;
739 }
740
741 if (!tempProxy->instantiate(this->resourceProvider())) {
742 return false;
743 }
744 GrTexture* texture = tempProxy->priv().peekTexture();
745
746 if (tempProxy->priv().hasPendingIO()) {
747 this->flush(tempProxy.get());
748 }
749
750 if (!fContext->fGpu->writePixels(texture, tempProxy->origin(), 0, 0, width, height,
751 tempDrawInfo.fWriteColorType, buffer, rowBytes)) {
752 return false;
753 }
754 tempProxy = nullptr;
755
756 SkMatrix matrix;
757 matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
758 GrRenderTargetContext* renderTargetContext = dst->asRenderTargetContext();
759 if (!renderTargetContext) {
760 return false;
761 }
762 GrPaint paint;
763 paint.addColorFragmentProcessor(std::move(fp));
764 paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
765 paint.setAllowSRGBInputs(dst->colorSpaceInfo().isGammaCorrect() ||
766 GrPixelConfigIsSRGB(dst->colorSpaceInfo().config()));
767 SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
768 renderTargetContext->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, matrix, rect,
769 nullptr);
770
771 if (kFlushWrites_PixelOp & pixelOpsFlags) {
772 this->flushSurfaceWrites(renderTargetContext->asRenderTargetProxy());
773 }
774 } else {
775 return fContext->fGpu->writePixels(dstSurface, dstProxy->origin(), left, top, width, height,
776 srcColorType, buffer, rowBytes);
777 }
778 return true;
779 }
780
readSurfacePixels(GrSurfaceContext * src,int left,int top,int width,int height,GrColorType dstColorType,SkColorSpace * dstColorSpace,void * buffer,size_t rowBytes,uint32_t flags)781 bool GrContextPriv::readSurfacePixels(GrSurfaceContext* src, int left, int top, int width,
782 int height, GrColorType dstColorType,
783 SkColorSpace* dstColorSpace, void* buffer, size_t rowBytes,
784 uint32_t flags) {
785 // TODO: Color space conversion
786
787 ASSERT_SINGLE_OWNER_PRIV
788 RETURN_FALSE_IF_ABANDONED_PRIV
789 SkASSERT(src);
790 ASSERT_OWNED_PROXY_PRIV(src->asSurfaceProxy());
791 GR_CREATE_TRACE_MARKER_CONTEXT("GrContextPriv", "readSurfacePixels", fContext);
792
793 // MDB TODO: delay this instantiation until later in the method
794 if (!src->asSurfaceProxy()->instantiate(this->resourceProvider())) {
795 return false;
796 }
797
798 GrSurfaceProxy* srcProxy = src->asSurfaceProxy();
799 GrSurface* srcSurface = srcProxy->priv().peekSurface();
800
801 // The src is premul but the dst is unpremul -> unpremul the src after or as part of the read
802 bool unpremul = SkToBool(kUnpremul_PixelOpsFlag & flags);
803
804 if (!valid_pixel_conversion(dstColorType, srcProxy->config(), unpremul)) {
805 return false;
806 }
807
808 // We need to guarantee round-trip conversion if we are reading and writing 8888 non-sRGB data,
809 // without any color spaces attached, and the caller wants us to unpremul.
810 bool useConfigConversionEffect =
811 unpremul &&
812 pm_upm_must_round_trip(srcProxy->config(), src->colorSpaceInfo().colorSpace()) &&
813 pm_upm_must_round_trip(dstColorType, dstColorSpace);
814
815 // Are we going to try to unpremul as part of a draw? For the non-legacy case, we always allow
816 // this. GrConfigConversionEffect fails on some GPUs, so only allow this if it works perfectly.
817 bool unpremulOnGpu = unpremul &&
818 (!useConfigConversionEffect || fContext->validPMUPMConversionExists());
819
820 // Adjust the params so that if we wind up using an intermediate surface we've already done
821 // all the trimming and the temporary can be the min size required.
822 if (!GrSurfacePriv::AdjustReadPixelParams(srcSurface->width(), srcSurface->height(),
823 GrColorTypeBytesPerPixel(dstColorType), &left, &top,
824 &width, &height, &buffer, &rowBytes)) {
825 return false;
826 }
827
828 GrGpu::DrawPreference drawPreference = unpremulOnGpu ? GrGpu::kCallerPrefersDraw_DrawPreference
829 : GrGpu::kNoDraw_DrawPreference;
830 GrGpu::ReadPixelTempDrawInfo tempDrawInfo;
831 GrSRGBConversion srgbConversion = determine_read_pixels_srgb_conversion(
832 GrPixelConfigIsSRGBEncoded(srcProxy->config()), src->colorSpaceInfo().colorSpace(),
833 dstColorType, dstColorSpace, *fContext->caps());
834
835 if (!fContext->fGpu->getReadPixelsInfo(srcSurface, srcProxy->origin(), width, height, rowBytes,
836 dstColorType, srgbConversion, &drawPreference,
837 &tempDrawInfo)) {
838 return false;
839 }
840
841 if (!(kDontFlush_PixelOpsFlag & flags) && srcSurface->surfacePriv().hasPendingWrite()) {
842 this->flush(nullptr); // MDB TODO: tighten this
843 }
844
845 sk_sp<GrSurfaceProxy> proxyToRead = src->asSurfaceProxyRef();
846 bool didTempDraw = false;
847 if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
848 if (SkBackingFit::kExact == tempDrawInfo.fTempSurfaceFit) {
849 // We only respect this when the entire src is being read. Otherwise we can trigger too
850 // many odd ball texture sizes and trash the cache.
851 if (width != srcSurface->width() || height != srcSurface->height()) {
852 tempDrawInfo.fTempSurfaceFit= SkBackingFit::kApprox;
853 }
854 }
855 // TODO: Need to decide the semantics of this function for color spaces. Do we support
856 // conversion to a passed-in color space? For now, specifying nullptr means that this
857 // path will do no conversion, so it will match the behavior of the non-draw path. For
858 // now we simply infer an sRGB color space if the config is sRGB in order to avoid an
859 // illegal combination.
860 sk_sp<SkColorSpace> colorSpace;
861 if (GrPixelConfigIsSRGB(tempDrawInfo.fTempSurfaceDesc.fConfig)) {
862 colorSpace = SkColorSpace::MakeSRGB();
863 }
864 sk_sp<GrRenderTargetContext> tempRTC =
865 fContext->makeDeferredRenderTargetContext(tempDrawInfo.fTempSurfaceFit,
866 tempDrawInfo.fTempSurfaceDesc.fWidth,
867 tempDrawInfo.fTempSurfaceDesc.fHeight,
868 tempDrawInfo.fTempSurfaceDesc.fConfig,
869 std::move(colorSpace),
870 tempDrawInfo.fTempSurfaceDesc.fSampleCnt,
871 GrMipMapped::kNo,
872 tempDrawInfo.fTempSurfaceDesc.fOrigin);
873 if (tempRTC) {
874 // Adding discard to appease vulkan validation warning about loading uninitialized data
875 // on draw
876 tempRTC->discard();
877 SkMatrix textureMatrix = SkMatrix::MakeTrans(SkIntToScalar(left), SkIntToScalar(top));
878 sk_sp<GrTextureProxy> proxy = src->asTextureProxyRef();
879 auto fp = GrSimpleTextureEffect::Make(std::move(proxy), textureMatrix);
880 if (unpremulOnGpu) {
881 fp = fContext->createPMToUPMEffect(std::move(fp), useConfigConversionEffect);
882 // We no longer need to do this on CPU after the read back.
883 unpremul = false;
884 }
885 fp = GrFragmentProcessor::SwizzleOutput(std::move(fp), tempDrawInfo.fSwizzle);
886 if (!fp) {
887 return false;
888 }
889
890 GrPaint paint;
891 paint.addColorFragmentProcessor(std::move(fp));
892 paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
893 paint.setAllowSRGBInputs(true);
894 SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
895 tempRTC->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(), rect,
896 nullptr);
897 proxyToRead = tempRTC->asTextureProxyRef();
898 left = 0;
899 top = 0;
900 didTempDraw = true;
901 }
902 }
903
904 if (!proxyToRead) {
905 return false;
906 }
907
908 if (GrGpu::kRequireDraw_DrawPreference == drawPreference && !didTempDraw) {
909 return false;
910 }
911 GrColorType colorTypeToRead = dstColorType;
912 if (didTempDraw) {
913 this->flushSurfaceWrites(proxyToRead.get());
914 colorTypeToRead = tempDrawInfo.fReadColorType;
915 }
916
917 if (!proxyToRead->instantiate(this->resourceProvider())) {
918 return false;
919 }
920
921 GrSurface* surfaceToRead = proxyToRead->priv().peekSurface();
922
923 if (!fContext->fGpu->readPixels(surfaceToRead, proxyToRead->origin(), left, top, width, height,
924 colorTypeToRead, buffer, rowBytes)) {
925 return false;
926 }
927
928 // Perform umpremul conversion if we weren't able to perform it as a draw.
929 if (unpremul) {
930 SkColorType colorType = GrColorTypeToSkColorType(dstColorType);
931 if (kUnknown_SkColorType == colorType || 4 != SkColorTypeBytesPerPixel(colorType)) {
932 return false;
933 }
934
935 for (int y = 0; y < height; y++) {
936 SkUnpremultiplyRow<false>((uint32_t*) buffer, (const uint32_t*) buffer, width);
937 buffer = SkTAddOffset<void>(buffer, rowBytes);
938 }
939 }
940 return true;
941 }
942
writeSurfacePixels2(GrSurfaceContext * dst,int left,int top,int width,int height,GrColorType srcColorType,SkColorSpace * srcColorSpace,const void * buffer,size_t rowBytes,uint32_t pixelOpsFlags)943 bool GrContextPriv::writeSurfacePixels2(GrSurfaceContext* dst, int left, int top, int width,
944 int height, GrColorType srcColorType,
945 SkColorSpace* srcColorSpace, const void* buffer,
946 size_t rowBytes, uint32_t pixelOpsFlags) {
947 ASSERT_SINGLE_OWNER_PRIV
948 RETURN_FALSE_IF_ABANDONED_PRIV
949 SkASSERT(dst);
950 SkASSERT(buffer);
951 ASSERT_OWNED_PROXY_PRIV(dst->asSurfaceProxy());
952 GR_CREATE_TRACE_MARKER_CONTEXT("GrContextPriv", "writeSurfacePixels2", fContext);
953
954 if (GrColorType::kUnknown == srcColorType) {
955 return false;
956 }
957
958 if (!dst->asSurfaceProxy()->instantiate(this->resourceProvider())) {
959 return false;
960 }
961
962 GrSurfaceProxy* dstProxy = dst->asSurfaceProxy();
963 GrSurface* dstSurface = dstProxy->priv().peekSurface();
964
965 if (!GrSurfacePriv::AdjustWritePixelParams(dstSurface->width(), dstSurface->height(),
966 GrColorTypeBytesPerPixel(srcColorType), &left, &top,
967 &width, &height, &buffer, &rowBytes)) {
968 return false;
969 }
970
971 if (!fContext->caps()->surfaceSupportsWritePixels(dstSurface)) {
972 GrSurfaceDesc desc;
973 desc.fConfig = dstProxy->config();
974 desc.fWidth = width;
975 desc.fHeight = height;
976 desc.fSampleCnt = 1;
977 desc.fOrigin = kTopLeft_GrSurfaceOrigin;
978 auto tempProxy =
979 this->proxyProvider()->createProxy(desc, SkBackingFit::kApprox, SkBudgeted::kYes);
980 if (!tempProxy) {
981 return false;
982 }
983 auto tempCtx = this->drawingManager()->makeTextureContext(
984 tempProxy, dst->colorSpaceInfo().refColorSpace());
985 if (!tempCtx) {
986 return false;
987 }
988 if (!this->writeSurfacePixels2(tempCtx.get(), 0, 0, width, height, srcColorType,
989 srcColorSpace, buffer, rowBytes, pixelOpsFlags)) {
990 return false;
991 }
992 return dst->copy(tempProxy.get(), SkIRect::MakeWH(width, height), {left, top});
993 }
994
995 // TODO: Make GrSurfaceContext know its alpha type and pass src buffer's alpha type.
996 bool premul = SkToBool(kUnpremul_PixelOpsFlag & pixelOpsFlags);
997 bool convert = premul;
998
999 if (!valid_pixel_conversion(srcColorType, dstProxy->config(), premul)) {
1000 return false;
1001 }
1002
1003 GrColorType allowedColorType =
1004 fContext->caps()->supportedWritePixelsColorType(dstProxy->config(), srcColorType);
1005 convert = convert || (srcColorType != allowedColorType);
1006
1007 if (!dst->colorSpaceInfo().colorSpace()) {
1008 // "Legacy" mode - no color space conversions.
1009 srcColorSpace = nullptr;
1010 }
1011 convert = convert || !SkColorSpace::Equals(srcColorSpace, dst->colorSpaceInfo().colorSpace());
1012
1013 std::unique_ptr<char[]> tempBuffer;
1014 if (convert) {
1015 auto srcSkColorType = GrColorTypeToSkColorType(srcColorType);
1016 auto dstSkColorType = GrColorTypeToSkColorType(allowedColorType);
1017 if (kUnknown_SkColorType == srcSkColorType || kUnknown_SkColorType == dstSkColorType) {
1018 return false;
1019 }
1020 auto srcAlphaType = premul ? kUnpremul_SkAlphaType : kPremul_SkAlphaType;
1021 SkPixmap src(SkImageInfo::Make(width, height, srcSkColorType, srcAlphaType,
1022 sk_ref_sp(srcColorSpace)),
1023 buffer, rowBytes);
1024 auto tempSrcII = SkImageInfo::Make(width, height, dstSkColorType, kPremul_SkAlphaType,
1025 dst->colorSpaceInfo().refColorSpace());
1026 auto size = tempSrcII.computeMinByteSize();
1027 if (!size) {
1028 return false;
1029 }
1030 tempBuffer.reset(new char[size]);
1031 SkPixmap tempSrc(tempSrcII, tempBuffer.get(), tempSrcII.minRowBytes());
1032 if (!src.readPixels(tempSrc)) {
1033 return false;
1034 }
1035 srcColorType = allowedColorType;
1036 buffer = tempSrc.addr();
1037 rowBytes = tempSrc.rowBytes();
1038 if (dstProxy->origin() == kBottomLeft_GrSurfaceOrigin) {
1039 std::unique_ptr<char[]> row(new char[rowBytes]);
1040 for (int y = 0; y < height / 2; ++y) {
1041 memcpy(row.get(), tempSrc.addr(0, y), rowBytes);
1042 memcpy(tempSrc.writable_addr(0, y), tempSrc.addr(0, height - 1 - y), rowBytes);
1043 memcpy(tempSrc.writable_addr(0, height - 1 - y), row.get(), rowBytes);
1044 }
1045 top = dstProxy->height() - top - height;
1046 }
1047 } else if (dstProxy->origin() == kBottomLeft_GrSurfaceOrigin) {
1048 size_t trimRowBytes = GrColorTypeBytesPerPixel(srcColorType) * width;
1049 tempBuffer.reset(new char[trimRowBytes * height]);
1050 char* dst = reinterpret_cast<char*>(tempBuffer.get()) + trimRowBytes * (height - 1);
1051 const char* src = reinterpret_cast<const char*>(buffer);
1052 for (int i = 0; i < height; ++i, src += rowBytes, dst -= trimRowBytes) {
1053 memcpy(dst, src, trimRowBytes);
1054 }
1055 buffer = tempBuffer.get();
1056 rowBytes = trimRowBytes;
1057 top = dstProxy->height() - top - height;
1058 }
1059
1060 if (!(kDontFlush_PixelOpsFlag & pixelOpsFlags) && dstSurface->surfacePriv().hasPendingIO()) {
1061 this->flush(nullptr); // MDB TODO: tighten this
1062 }
1063
1064 return this->getGpu()->writePixels(dstSurface, left, top, width, height, srcColorType, buffer,
1065 rowBytes);
1066 }
1067
prepareSurfaceForExternalIO(GrSurfaceProxy * proxy)1068 void GrContextPriv::prepareSurfaceForExternalIO(GrSurfaceProxy* proxy) {
1069 ASSERT_SINGLE_OWNER_PRIV
1070 RETURN_IF_ABANDONED_PRIV
1071 SkASSERT(proxy);
1072 ASSERT_OWNED_PROXY_PRIV(proxy);
1073 fContext->fDrawingManager->prepareSurfaceForExternalIO(proxy, 0, nullptr);
1074 }
1075
flushSurfaceWrites(GrSurfaceProxy * proxy)1076 void GrContextPriv::flushSurfaceWrites(GrSurfaceProxy* proxy) {
1077 ASSERT_SINGLE_OWNER_PRIV
1078 RETURN_IF_ABANDONED_PRIV
1079 SkASSERT(proxy);
1080 ASSERT_OWNED_PROXY_PRIV(proxy);
1081 if (proxy->priv().hasPendingWrite()) {
1082 this->flush(proxy);
1083 }
1084 }
1085
flushSurfaceIO(GrSurfaceProxy * proxy)1086 void GrContextPriv::flushSurfaceIO(GrSurfaceProxy* proxy) {
1087 ASSERT_SINGLE_OWNER_PRIV
1088 RETURN_IF_ABANDONED_PRIV
1089 SkASSERT(proxy);
1090 ASSERT_OWNED_PROXY_PRIV(proxy);
1091 if (proxy->priv().hasPendingIO()) {
1092 this->flush(proxy);
1093 }
1094 }
1095
1096 ////////////////////////////////////////////////////////////////////////////////
1097
makeWrappedSurfaceContext(sk_sp<GrSurfaceProxy> proxy,sk_sp<SkColorSpace> colorSpace,const SkSurfaceProps * props)1098 sk_sp<GrSurfaceContext> GrContextPriv::makeWrappedSurfaceContext(sk_sp<GrSurfaceProxy> proxy,
1099 sk_sp<SkColorSpace> colorSpace,
1100 const SkSurfaceProps* props) {
1101 ASSERT_SINGLE_OWNER_PRIV
1102
1103 // sRGB pixel configs may only be used with near-sRGB gamma color spaces.
1104 if (GrPixelConfigIsSRGB(proxy->config())) {
1105 if (!colorSpace || !colorSpace->gammaCloseToSRGB()) {
1106 return nullptr;
1107 }
1108 }
1109 if (proxy->asRenderTargetProxy()) {
1110 return this->drawingManager()->makeRenderTargetContext(std::move(proxy),
1111 std::move(colorSpace), props);
1112 } else {
1113 SkASSERT(proxy->asTextureProxy());
1114 SkASSERT(!props);
1115 return this->drawingManager()->makeTextureContext(std::move(proxy), std::move(colorSpace));
1116 }
1117 }
1118
makeDeferredSurfaceContext(const GrSurfaceDesc & dstDesc,GrMipMapped mipMapped,SkBackingFit fit,SkBudgeted isDstBudgeted,sk_sp<SkColorSpace> colorSpace,const SkSurfaceProps * props)1119 sk_sp<GrSurfaceContext> GrContextPriv::makeDeferredSurfaceContext(const GrSurfaceDesc& dstDesc,
1120 GrMipMapped mipMapped,
1121 SkBackingFit fit,
1122 SkBudgeted isDstBudgeted,
1123 sk_sp<SkColorSpace> colorSpace,
1124 const SkSurfaceProps* props) {
1125 sk_sp<GrTextureProxy> proxy;
1126 if (GrMipMapped::kNo == mipMapped) {
1127 proxy = this->proxyProvider()->createProxy(dstDesc, fit, isDstBudgeted);
1128 } else {
1129 SkASSERT(SkBackingFit::kExact == fit);
1130 proxy = this->proxyProvider()->createMipMapProxy(dstDesc, isDstBudgeted);
1131 }
1132 if (!proxy) {
1133 return nullptr;
1134 }
1135
1136 return this->makeWrappedSurfaceContext(std::move(proxy), std::move(colorSpace), props);
1137 }
1138
makeBackendTextureContext(const GrBackendTexture & tex,GrSurfaceOrigin origin,sk_sp<SkColorSpace> colorSpace)1139 sk_sp<GrTextureContext> GrContextPriv::makeBackendTextureContext(const GrBackendTexture& tex,
1140 GrSurfaceOrigin origin,
1141 sk_sp<SkColorSpace> colorSpace) {
1142 ASSERT_SINGLE_OWNER_PRIV
1143
1144 sk_sp<GrSurfaceProxy> proxy = this->proxyProvider()->createWrappedTextureProxy(tex, origin);
1145 if (!proxy) {
1146 return nullptr;
1147 }
1148
1149 return this->drawingManager()->makeTextureContext(std::move(proxy), std::move(colorSpace));
1150 }
1151
makeBackendTextureRenderTargetContext(const GrBackendTexture & tex,GrSurfaceOrigin origin,int sampleCnt,sk_sp<SkColorSpace> colorSpace,const SkSurfaceProps * props)1152 sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendTextureRenderTargetContext(
1153 const GrBackendTexture& tex,
1154 GrSurfaceOrigin origin,
1155 int sampleCnt,
1156 sk_sp<SkColorSpace> colorSpace,
1157 const SkSurfaceProps* props) {
1158 ASSERT_SINGLE_OWNER_PRIV
1159 SkASSERT(sampleCnt > 0);
1160
1161 sk_sp<GrTextureProxy> proxy(this->proxyProvider()->createWrappedTextureProxy(tex, origin,
1162 sampleCnt));
1163 if (!proxy) {
1164 return nullptr;
1165 }
1166
1167 return this->drawingManager()->makeRenderTargetContext(std::move(proxy),
1168 std::move(colorSpace), props);
1169 }
1170
makeBackendRenderTargetRenderTargetContext(const GrBackendRenderTarget & backendRT,GrSurfaceOrigin origin,sk_sp<SkColorSpace> colorSpace,const SkSurfaceProps * surfaceProps)1171 sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendRenderTargetRenderTargetContext(
1172 const GrBackendRenderTarget& backendRT,
1173 GrSurfaceOrigin origin,
1174 sk_sp<SkColorSpace> colorSpace,
1175 const SkSurfaceProps* surfaceProps) {
1176 ASSERT_SINGLE_OWNER_PRIV
1177
1178 sk_sp<GrSurfaceProxy> proxy = this->proxyProvider()->createWrappedRenderTargetProxy(backendRT,
1179 origin);
1180 if (!proxy) {
1181 return nullptr;
1182 }
1183
1184 return this->drawingManager()->makeRenderTargetContext(std::move(proxy),
1185 std::move(colorSpace),
1186 surfaceProps);
1187 }
1188
makeBackendTextureAsRenderTargetRenderTargetContext(const GrBackendTexture & tex,GrSurfaceOrigin origin,int sampleCnt,sk_sp<SkColorSpace> colorSpace,const SkSurfaceProps * props)1189 sk_sp<GrRenderTargetContext> GrContextPriv::makeBackendTextureAsRenderTargetRenderTargetContext(
1190 const GrBackendTexture& tex,
1191 GrSurfaceOrigin origin,
1192 int sampleCnt,
1193 sk_sp<SkColorSpace> colorSpace,
1194 const SkSurfaceProps* props) {
1195 ASSERT_SINGLE_OWNER_PRIV
1196 SkASSERT(sampleCnt > 0);
1197 sk_sp<GrSurfaceProxy> proxy(this->proxyProvider()->createWrappedRenderTargetProxy(tex, origin,
1198 sampleCnt));
1199 if (!proxy) {
1200 return nullptr;
1201 }
1202
1203 return this->drawingManager()->makeRenderTargetContext(std::move(proxy),
1204 std::move(colorSpace),
1205 props);
1206 }
1207
addOnFlushCallbackObject(GrOnFlushCallbackObject * onFlushCBObject)1208 void GrContextPriv::addOnFlushCallbackObject(GrOnFlushCallbackObject* onFlushCBObject) {
1209 fContext->fDrawingManager->addOnFlushCallbackObject(onFlushCBObject);
1210 }
1211
moveOpListsToDDL(SkDeferredDisplayList * ddl)1212 void GrContextPriv::moveOpListsToDDL(SkDeferredDisplayList* ddl) {
1213 fContext->fDrawingManager->moveOpListsToDDL(ddl);
1214 }
1215
copyOpListsFromDDL(const SkDeferredDisplayList * ddl,GrRenderTargetProxy * newDest)1216 void GrContextPriv::copyOpListsFromDDL(const SkDeferredDisplayList* ddl,
1217 GrRenderTargetProxy* newDest) {
1218 fContext->fDrawingManager->copyOpListsFromDDL(ddl, newDest);
1219 }
1220
GrPixelConfigFallback(GrPixelConfig config)1221 static inline GrPixelConfig GrPixelConfigFallback(GrPixelConfig config) {
1222 switch (config) {
1223 case kAlpha_8_GrPixelConfig:
1224 case kRGB_565_GrPixelConfig:
1225 case kRGBA_4444_GrPixelConfig:
1226 case kBGRA_8888_GrPixelConfig:
1227 return kRGBA_8888_GrPixelConfig;
1228 case kSBGRA_8888_GrPixelConfig:
1229 return kSRGBA_8888_GrPixelConfig;
1230 case kAlpha_half_GrPixelConfig:
1231 return kRGBA_half_GrPixelConfig;
1232 default:
1233 return kUnknown_GrPixelConfig;
1234 }
1235 }
1236
makeDeferredRenderTargetContextWithFallback(SkBackingFit fit,int width,int height,GrPixelConfig config,sk_sp<SkColorSpace> colorSpace,int sampleCnt,GrMipMapped mipMapped,GrSurfaceOrigin origin,const SkSurfaceProps * surfaceProps,SkBudgeted budgeted)1237 sk_sp<GrRenderTargetContext> GrContext::makeDeferredRenderTargetContextWithFallback(
1238 SkBackingFit fit,
1239 int width, int height,
1240 GrPixelConfig config,
1241 sk_sp<SkColorSpace> colorSpace,
1242 int sampleCnt,
1243 GrMipMapped mipMapped,
1244 GrSurfaceOrigin origin,
1245 const SkSurfaceProps* surfaceProps,
1246 SkBudgeted budgeted) {
1247 SkASSERT(sampleCnt > 0);
1248 if (0 == this->caps()->getRenderTargetSampleCount(sampleCnt, config)) {
1249 config = GrPixelConfigFallback(config);
1250 }
1251
1252 return this->makeDeferredRenderTargetContext(fit, width, height, config, std::move(colorSpace),
1253 sampleCnt, mipMapped, origin, surfaceProps,
1254 budgeted);
1255 }
1256
makeDeferredRenderTargetContext(SkBackingFit fit,int width,int height,GrPixelConfig config,sk_sp<SkColorSpace> colorSpace,int sampleCnt,GrMipMapped mipMapped,GrSurfaceOrigin origin,const SkSurfaceProps * surfaceProps,SkBudgeted budgeted)1257 sk_sp<GrRenderTargetContext> GrContext::makeDeferredRenderTargetContext(
1258 SkBackingFit fit,
1259 int width, int height,
1260 GrPixelConfig config,
1261 sk_sp<SkColorSpace> colorSpace,
1262 int sampleCnt,
1263 GrMipMapped mipMapped,
1264 GrSurfaceOrigin origin,
1265 const SkSurfaceProps* surfaceProps,
1266 SkBudgeted budgeted) {
1267 SkASSERT(sampleCnt > 0);
1268 if (this->abandoned()) {
1269 return nullptr;
1270 }
1271
1272 GrSurfaceDesc desc;
1273 desc.fFlags = kRenderTarget_GrSurfaceFlag;
1274 desc.fOrigin = origin;
1275 desc.fWidth = width;
1276 desc.fHeight = height;
1277 desc.fConfig = config;
1278 desc.fSampleCnt = sampleCnt;
1279
1280 sk_sp<GrTextureProxy> rtp;
1281 if (GrMipMapped::kNo == mipMapped) {
1282 rtp = fProxyProvider->createProxy(desc, fit, budgeted);
1283 } else {
1284 rtp = fProxyProvider->createMipMapProxy(desc, budgeted);
1285 }
1286 if (!rtp) {
1287 return nullptr;
1288 }
1289
1290 sk_sp<GrRenderTargetContext> renderTargetContext(
1291 fDrawingManager->makeRenderTargetContext(std::move(rtp),
1292 std::move(colorSpace),
1293 surfaceProps));
1294 if (!renderTargetContext) {
1295 return nullptr;
1296 }
1297
1298 renderTargetContext->discard();
1299
1300 return renderTargetContext;
1301 }
1302
abandoned() const1303 bool GrContext::abandoned() const {
1304 ASSERT_SINGLE_OWNER
1305 return fDrawingManager->wasAbandoned();
1306 }
1307
createPMToUPMEffect(std::unique_ptr<GrFragmentProcessor> fp,bool useConfigConversionEffect)1308 std::unique_ptr<GrFragmentProcessor> GrContext::createPMToUPMEffect(
1309 std::unique_ptr<GrFragmentProcessor> fp, bool useConfigConversionEffect) {
1310 ASSERT_SINGLE_OWNER
1311 // We have specialized effects that guarantee round-trip conversion for some formats
1312 if (useConfigConversionEffect) {
1313 // We should have already called this->validPMUPMConversionExists() in this case
1314 SkASSERT(fDidTestPMConversions);
1315 // ...and it should have succeeded
1316 SkASSERT(this->validPMUPMConversionExists());
1317
1318 return GrConfigConversionEffect::Make(std::move(fp), PMConversion::kToUnpremul);
1319 } else {
1320 // For everything else (sRGB, half-float, etc...), it doesn't make sense to try and
1321 // explicitly round the results. Just do the obvious, naive thing in the shader.
1322 return GrFragmentProcessor::UnpremulOutput(std::move(fp));
1323 }
1324 }
1325
createUPMToPMEffect(std::unique_ptr<GrFragmentProcessor> fp,bool useConfigConversionEffect)1326 std::unique_ptr<GrFragmentProcessor> GrContext::createUPMToPMEffect(
1327 std::unique_ptr<GrFragmentProcessor> fp, bool useConfigConversionEffect) {
1328 ASSERT_SINGLE_OWNER
1329 // We have specialized effects that guarantee round-trip conversion for these formats
1330 if (useConfigConversionEffect) {
1331 // We should have already called this->validPMUPMConversionExists() in this case
1332 SkASSERT(fDidTestPMConversions);
1333 // ...and it should have succeeded
1334 SkASSERT(this->validPMUPMConversionExists());
1335
1336 return GrConfigConversionEffect::Make(std::move(fp), PMConversion::kToPremul);
1337 } else {
1338 // For everything else (sRGB, half-float, etc...), it doesn't make sense to try and
1339 // explicitly round the results. Just do the obvious, naive thing in the shader.
1340 return GrFragmentProcessor::PremulOutput(std::move(fp));
1341 }
1342 }
1343
validPMUPMConversionExists()1344 bool GrContext::validPMUPMConversionExists() {
1345 ASSERT_SINGLE_OWNER
1346 if (!fDidTestPMConversions) {
1347 fPMUPMConversionsRoundTrip = GrConfigConversionEffect::TestForPreservingPMConversions(this);
1348 fDidTestPMConversions = true;
1349 }
1350
1351 // The PM<->UPM tests fail or succeed together so we only need to check one.
1352 return fPMUPMConversionsRoundTrip;
1353 }
1354
1355 //////////////////////////////////////////////////////////////////////////////
1356
1357 // DDL TODO: remove 'maxResources'
getResourceCacheLimits(int * maxResources,size_t * maxResourceBytes) const1358 void GrContext::getResourceCacheLimits(int* maxResources, size_t* maxResourceBytes) const {
1359 ASSERT_SINGLE_OWNER
1360 if (maxResources) {
1361 *maxResources = fResourceCache->getMaxResourceCount();
1362 }
1363 if (maxResourceBytes) {
1364 *maxResourceBytes = fResourceCache->getMaxResourceBytes();
1365 }
1366 }
1367
setResourceCacheLimits(int maxResources,size_t maxResourceBytes)1368 void GrContext::setResourceCacheLimits(int maxResources, size_t maxResourceBytes) {
1369 ASSERT_SINGLE_OWNER
1370 fResourceCache->setLimits(maxResources, maxResourceBytes);
1371 }
1372
1373 //////////////////////////////////////////////////////////////////////////////
1374
dumpMemoryStatistics(SkTraceMemoryDump * traceMemoryDump) const1375 void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
1376 ASSERT_SINGLE_OWNER
1377 fResourceCache->dumpMemoryStatistics(traceMemoryDump);
1378 }
1379
1380 //////////////////////////////////////////////////////////////////////////////
1381
dump() const1382 SkString GrContext::dump() const {
1383 SkDynamicMemoryWStream stream;
1384 SkJSONWriter writer(&stream, SkJSONWriter::Mode::kPretty);
1385 writer.beginObject();
1386
1387 static const char* kBackendStr[] = {
1388 "Metal",
1389 "OpenGL",
1390 "Vulkan",
1391 "Mock",
1392 };
1393 GR_STATIC_ASSERT(0 == kMetal_GrBackend);
1394 GR_STATIC_ASSERT(1 == kOpenGL_GrBackend);
1395 GR_STATIC_ASSERT(2 == kVulkan_GrBackend);
1396 GR_STATIC_ASSERT(3 == kMock_GrBackend);
1397 writer.appendString("backend", kBackendStr[fBackend]);
1398
1399 writer.appendName("caps");
1400 fCaps->dumpJSON(&writer);
1401
1402 writer.appendName("gpu");
1403 fGpu->dumpJSON(&writer);
1404
1405 // Flush JSON to the memory stream
1406 writer.endObject();
1407 writer.flush();
1408
1409 // Null terminate the JSON data in the memory stream
1410 stream.write8(0);
1411
1412 // Allocate a string big enough to hold all the data, then copy out of the stream
1413 SkString result(stream.bytesWritten());
1414 stream.copyToAndReset(result.writable_str());
1415 return result;
1416 }
1417