1 /* 2 * Copyright 2020 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef SF_SKIARENDERENGINE_H_ 18 #define SF_SKIARENDERENGINE_H_ 19 20 #include <renderengine/RenderEngine.h> 21 #include <sys/types.h> 22 23 #include <GrBackendSemaphore.h> 24 #include <GrDirectContext.h> 25 #include <SkSurface.h> 26 #include <android-base/thread_annotations.h> 27 #include <renderengine/ExternalTexture.h> 28 #include <renderengine/RenderEngine.h> 29 #include <sys/types.h> 30 31 #include <mutex> 32 #include <unordered_map> 33 34 #include "AutoBackendTexture.h" 35 #include "GrContextOptions.h" 36 #include "SkImageInfo.h" 37 #include "SkiaRenderEngine.h" 38 #include "android-base/macros.h" 39 #include "debug/SkiaCapture.h" 40 #include "filters/BlurFilter.h" 41 #include "filters/LinearEffect.h" 42 #include "filters/StretchShaderFactory.h" 43 44 class SkData; 45 46 struct SkPoint3; 47 48 namespace android { 49 50 namespace renderengine { 51 52 class Mesh; 53 class Texture; 54 55 namespace skia { 56 57 class BlurFilter; 58 59 class SkiaRenderEngine : public RenderEngine { 60 public: 61 static std::unique_ptr<SkiaRenderEngine> create(const RenderEngineCreationArgs& args); 62 SkiaRenderEngine(RenderEngineType type, 63 PixelFormat pixelFormat, 64 bool useColorManagement, 65 bool supportsBackgroundBlur); 66 ~SkiaRenderEngine() override; 67 68 std::future<void> primeCache() override final; 69 void cleanupPostRender() override final; cleanFramebufferCache()70 void cleanFramebufferCache() override final{ } supportsBackgroundBlur()71 bool supportsBackgroundBlur() override final { 72 return mBlurFilter != nullptr; 73 } 74 void onActiveDisplaySizeChanged(ui::Size size) override final; 75 int reportShadersCompiled(); 76 genTextures(size_t,uint32_t *)77 virtual void genTextures(size_t /*count*/, uint32_t* /*names*/) override final{}; deleteTextures(size_t,uint32_t const *)78 virtual void deleteTextures(size_t /*count*/, uint32_t const* /*names*/) override final{}; 79 virtual void setEnableTracing(bool tracingEnabled) override final; 80 81 void useProtectedContext(bool useProtectedContext) override; supportsProtectedContent()82 bool supportsProtectedContent() const override { 83 return supportsProtectedContentImpl(); 84 } 85 void ensureGrContextsCreated(); 86 protected: 87 // This is so backends can stop the generic rendering state first before 88 // cleaning up backend-specific state 89 void finishRenderingAndAbandonContext(); 90 91 // Functions that a given backend (GLES, Vulkan) must implement 92 using Contexts = std::pair<sk_sp<GrDirectContext>, sk_sp<GrDirectContext>>; 93 virtual Contexts createDirectContexts(const GrContextOptions& options) = 0; 94 virtual bool supportsProtectedContentImpl() const = 0; 95 virtual bool useProtectedContextImpl(GrProtected isProtected) = 0; 96 virtual void waitFence(GrDirectContext* grContext, base::borrowed_fd fenceFd) = 0; 97 virtual base::unique_fd flushAndSubmit(GrDirectContext* context) = 0; 98 virtual void appendBackendSpecificInfoToDump(std::string& result) = 0; 99 100 size_t getMaxTextureSize() const override final; 101 size_t getMaxViewportDims() const override final; 102 GrDirectContext* getActiveGrContext(); 103 isProtected()104 bool isProtected() const { return mInProtectedContext; } 105 106 // Implements PersistentCache as a way to monitor what SkSL shaders Skia has 107 // cached. 108 class SkSLCacheMonitor : public GrContextOptions::PersistentCache { 109 public: 110 SkSLCacheMonitor() = default; 111 ~SkSLCacheMonitor() override = default; 112 113 sk_sp<SkData> load(const SkData& key) override; 114 115 void store(const SkData& key, const SkData& data, const SkString& description) override; 116 shadersCachedSinceLastCall()117 int shadersCachedSinceLastCall() { 118 const int shadersCachedSinceLastCall = mShadersCachedSinceLastCall; 119 mShadersCachedSinceLastCall = 0; 120 return shadersCachedSinceLastCall; 121 } 122 totalShadersCompiled()123 int totalShadersCompiled() const { return mTotalShadersCompiled; } 124 125 private: 126 int mShadersCachedSinceLastCall = 0; 127 int mTotalShadersCompiled = 0; 128 }; 129 130 private: 131 void mapExternalTextureBuffer(const sp<GraphicBuffer>& buffer, 132 bool isRenderable) override final; 133 void unmapExternalTextureBuffer(sp<GraphicBuffer>&& buffer) override final; 134 bool canSkipPostRenderCleanup() const override final; 135 136 std::shared_ptr<AutoBackendTexture::LocalRef> getOrCreateBackendTexture( 137 const sp<GraphicBuffer>& buffer, bool isOutputBuffer) REQUIRES(mRenderingMutex); 138 void initCanvas(SkCanvas* canvas, const DisplaySettings& display); 139 void drawShadow(SkCanvas* canvas, const SkRRect& casterRRect, 140 const ShadowSettings& shadowSettings); 141 void drawLayersInternal(const std::shared_ptr<std::promise<FenceResult>>&& resultPromise, 142 const DisplaySettings& display, 143 const std::vector<LayerSettings>& layers, 144 const std::shared_ptr<ExternalTexture>& buffer, 145 const bool useFramebufferCache, 146 base::unique_fd&& bufferFence) override final; 147 148 void dump(std::string& result) override final; 149 150 // If requiresLinearEffect is true or the layer has a stretchEffect a new shader is returned. 151 // Otherwise it returns the input shader. 152 struct RuntimeEffectShaderParameters { 153 sk_sp<SkShader> shader; 154 const LayerSettings& layer; 155 const DisplaySettings& display; 156 bool undoPremultipliedAlpha; 157 bool requiresLinearEffect; 158 float layerDimmingRatio; 159 const ui::Dataspace outputDataSpace; 160 const ui::Dataspace fakeOutputDataspace; 161 }; 162 sk_sp<SkShader> createRuntimeEffectShader(const RuntimeEffectShaderParameters&); 163 164 const PixelFormat mDefaultPixelFormat; 165 const bool mUseColorManagement; 166 167 // Identifier used for various mappings of layers to various 168 // textures or shaders 169 using GraphicBufferId = uint64_t; 170 171 // Number of external holders of ExternalTexture references, per GraphicBuffer ID. 172 std::unordered_map<GraphicBufferId, int32_t> mGraphicBufferExternalRefs 173 GUARDED_BY(mRenderingMutex); 174 // For GL, this cache is shared between protected and unprotected contexts. For Vulkan, it is 175 // only used for the unprotected context, because Vulkan does not allow sharing between 176 // contexts, and protected is less common. 177 std::unordered_map<GraphicBufferId, std::shared_ptr<AutoBackendTexture::LocalRef>> mTextureCache 178 GUARDED_BY(mRenderingMutex); 179 std::unordered_map<shaders::LinearEffect, sk_sp<SkRuntimeEffect>, shaders::LinearEffectHasher> 180 mRuntimeEffects; 181 AutoBackendTexture::CleanupManager mTextureCleanupMgr GUARDED_BY(mRenderingMutex); 182 183 StretchShaderFactory mStretchShaderFactory; 184 185 sp<Fence> mLastDrawFence; 186 BlurFilter* mBlurFilter = nullptr; 187 188 // Object to capture commands send to Skia. 189 std::unique_ptr<SkiaCapture> mCapture; 190 191 // Mutex guarding rendering operations, so that internal state related to 192 // rendering that is potentially modified by multiple threads is guaranteed thread-safe. 193 mutable std::mutex mRenderingMutex; 194 SkSLCacheMonitor mSkSLCacheMonitor; 195 196 // Graphics context used for creating surfaces and submitting commands 197 sk_sp<GrDirectContext> mGrContext; 198 // Same as above, but for protected content (eg. DRM) 199 sk_sp<GrDirectContext> mProtectedGrContext; 200 bool mInProtectedContext = false; 201 }; 202 203 } // namespace skia 204 } // namespace renderengine 205 } // namespace android 206 207 #endif /* SF_GLESRENDERENGINE_H_ */ 208