1 /* 2 * Copyright 2019 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 "GrContextThreadSafeProxy.h" 9 #include "GrContextThreadSafeProxyPriv.h" 10 11 #include "GrBaseContextPriv.h" 12 #include "GrCaps.h" 13 #include "GrContext.h" 14 #include "GrSkSLFPFactoryCache.h" 15 #include "SkSurface_Gpu.h" 16 #include "SkSurfaceCharacterization.h" 17 18 GrContextThreadSafeProxy::GrContextThreadSafeProxy(GrBackendApi backend, 19 const GrContextOptions& options, 20 uint32_t contextID) 21 : INHERITED(backend, options, contextID) { 22 } 23 24 GrContextThreadSafeProxy::~GrContextThreadSafeProxy() = default; 25 26 bool GrContextThreadSafeProxy::init(sk_sp<const GrCaps> caps, 27 sk_sp<GrSkSLFPFactoryCache> FPFactoryCache) { 28 return INHERITED::init(std::move(caps), std::move(FPFactoryCache)); 29 } 30 31 SkSurfaceCharacterization GrContextThreadSafeProxy::createCharacterization( 32 size_t cacheMaxResourceBytes, 33 const SkImageInfo& ii, const GrBackendFormat& backendFormat, 34 int sampleCnt, GrSurfaceOrigin origin, 35 const SkSurfaceProps& surfaceProps, 36 bool isMipMapped, bool willUseGLFBO0, bool isTextureable) { 37 if (!backendFormat.isValid()) { 38 return SkSurfaceCharacterization(); // return an invalid characterization 39 } 40 41 if (GrBackendApi::kOpenGL != backendFormat.backend() && willUseGLFBO0) { 42 // The willUseGLFBO0 flags can only be used for a GL backend. 43 return SkSurfaceCharacterization(); // return an invalid characterization 44 } 45 46 if (!this->caps()->mipMapSupport()) { 47 isMipMapped = false; 48 } 49 50 GrPixelConfig config = this->caps()->getConfigFromBackendFormat(backendFormat, ii.colorType()); 51 if (config == kUnknown_GrPixelConfig) { 52 return SkSurfaceCharacterization(); // return an invalid characterization 53 } 54 55 if (!SkSurface_Gpu::Valid(this->caps(), config, ii.colorSpace())) { 56 return SkSurfaceCharacterization(); // return an invalid characterization 57 } 58 59 sampleCnt = this->caps()->getRenderTargetSampleCount(sampleCnt, config); 60 if (!sampleCnt) { 61 return SkSurfaceCharacterization(); // return an invalid characterization 62 } 63 64 GrFSAAType FSAAType = GrFSAAType::kNone; 65 if (sampleCnt > 1) { 66 FSAAType = this->caps()->usesMixedSamples() ? GrFSAAType::kMixedSamples 67 : GrFSAAType::kUnifiedMSAA; 68 } 69 70 if (willUseGLFBO0 && isTextureable) { 71 return SkSurfaceCharacterization(); // return an invalid characterization 72 } 73 74 if (isTextureable && !this->caps()->isConfigTexturable(config)) { 75 // Skia doesn't agree that this is textureable. 76 return SkSurfaceCharacterization(); // return an invalid characterization 77 } 78 79 return SkSurfaceCharacterization(sk_ref_sp<GrContextThreadSafeProxy>(this), 80 cacheMaxResourceBytes, ii, 81 origin, config, FSAAType, sampleCnt, 82 SkSurfaceCharacterization::Textureable(isTextureable), 83 SkSurfaceCharacterization::MipMapped(isMipMapped), 84 SkSurfaceCharacterization::UsesGLFBO0(willUseGLFBO0), 85 SkSurfaceCharacterization::VulkanSecondaryCBCompatible(false), 86 surfaceProps); 87 } 88 89 //////////////////////////////////////////////////////////////////////////////// 90 sk_sp<GrSkSLFPFactoryCache> GrContextThreadSafeProxyPriv::fpFactoryCache() { 91 return fProxy->fpFactoryCache(); 92 } 93 94 sk_sp<GrContextThreadSafeProxy> GrContextThreadSafeProxyPriv::Make( 95 GrBackendApi backend, 96 const GrContextOptions& options, 97 uint32_t contextID, 98 sk_sp<const GrCaps> caps, 99 sk_sp<GrSkSLFPFactoryCache> cache) { 100 sk_sp<GrContextThreadSafeProxy> proxy(new GrContextThreadSafeProxy(backend, options, 101 contextID)); 102 103 if (!proxy->init(std::move(caps), std::move(cache))) { 104 return nullptr; 105 } 106 return proxy; 107 } 108 109