blob: 9f892bd0f7ff75f28511eda6e386baf54e585836 [file] [log] [blame]
John Reck67b1e2b2020-08-26 13:17:24 -07001/*
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
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070023#include <GrBackendSemaphore.h>
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070024#include <SkSurface.h>
25#include <android-base/thread_annotations.h>
26#include <renderengine/ExternalTexture.h>
27#include <renderengine/RenderEngine.h>
28#include <sys/types.h>
29
Nolan Scobiefc125ec2024-03-11 20:08:27 -040030#include <memory>
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070031#include <mutex>
32#include <unordered_map>
33
34#include "AutoBackendTexture.h"
35#include "GrContextOptions.h"
36#include "SkImageInfo.h"
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070037#include "android-base/macros.h"
Nolan Scobiefc125ec2024-03-11 20:08:27 -040038#include "compat/SkiaGpuContext.h"
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070039#include "debug/SkiaCapture.h"
40#include "filters/BlurFilter.h"
41#include "filters/LinearEffect.h"
42#include "filters/StretchShaderFactory.h"
43
44class SkData;
45
46struct SkPoint3;
47
John Reck67b1e2b2020-08-26 13:17:24 -070048namespace android {
49
50namespace renderengine {
51
52class Mesh;
53class Texture;
54
55namespace skia {
56
57class BlurFilter;
58
Alec Mouri081be4c2020-09-16 10:24:47 -070059class SkiaRenderEngine : public RenderEngine {
John Reck67b1e2b2020-08-26 13:17:24 -070060public:
61 static std::unique_ptr<SkiaRenderEngine> create(const RenderEngineCreationArgs& args);
Leon Scroggins III696bf932024-01-24 15:21:05 -050062 SkiaRenderEngine(Threaded, PixelFormat pixelFormat, bool supportsBackgroundBlur);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070063 ~SkiaRenderEngine() override;
John Reck67b1e2b2020-08-26 13:17:24 -070064
Bruno BELANYIb9b5b702023-10-13 13:25:11 +000065 std::future<void> primeCache(bool shouldPrimeUltraHDR) override final;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070066 void cleanupPostRender() override final;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070067 bool supportsBackgroundBlur() override final {
68 return mBlurFilter != nullptr;
69 }
70 void onActiveDisplaySizeChanged(ui::Size size) override final;
71 int reportShadersCompiled();
Alec Mouria90a5702021-04-16 16:36:21 +000072
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070073 virtual void setEnableTracing(bool tracingEnabled) override final;
74
75 void useProtectedContext(bool useProtectedContext) override;
76 bool supportsProtectedContent() const override {
77 return supportsProtectedContentImpl();
78 }
Nolan Scobiefc125ec2024-03-11 20:08:27 -040079 void ensureContextsCreated();
80
Alec Mouria90a5702021-04-16 16:36:21 +000081protected:
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070082 // This is so backends can stop the generic rendering state first before
83 // cleaning up backend-specific state
84 void finishRenderingAndAbandonContext();
Sally Qi4cabdd02021-08-05 16:45:57 -070085
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070086 // Functions that a given backend (GLES, Vulkan) must implement
Nolan Scobiefc125ec2024-03-11 20:08:27 -040087 using Contexts = std::pair<unique_ptr<SkiaGpuContext>, unique_ptr<SkiaGpuContext>>;
88 virtual Contexts createContexts() = 0;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070089 virtual bool supportsProtectedContentImpl() const = 0;
90 virtual bool useProtectedContextImpl(GrProtected isProtected) = 0;
Nolan Scobiefc125ec2024-03-11 20:08:27 -040091 virtual void waitFence(SkiaGpuContext* context, base::borrowed_fd fenceFd) = 0;
92 virtual base::unique_fd flushAndSubmit(SkiaGpuContext* context) = 0;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070093 virtual void appendBackendSpecificInfoToDump(std::string& result) = 0;
94
95 size_t getMaxTextureSize() const override final;
96 size_t getMaxViewportDims() const override final;
Nolan Scobiefc125ec2024-03-11 20:08:27 -040097 SkiaGpuContext* getActiveContext();
Lingfeng Yang00c1ff62022-06-02 09:19:28 -070098
Patrick Williams8aed5d22022-10-31 22:18:10 +000099 bool isProtected() const { return mInProtectedContext; }
100
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700101 // Implements PersistentCache as a way to monitor what SkSL shaders Skia has
102 // cached.
103 class SkSLCacheMonitor : public GrContextOptions::PersistentCache {
104 public:
105 SkSLCacheMonitor() = default;
106 ~SkSLCacheMonitor() override = default;
107
108 sk_sp<SkData> load(const SkData& key) override;
109
110 void store(const SkData& key, const SkData& data, const SkString& description) override;
111
112 int shadersCachedSinceLastCall() {
113 const int shadersCachedSinceLastCall = mShadersCachedSinceLastCall;
114 mShadersCachedSinceLastCall = 0;
115 return shadersCachedSinceLastCall;
116 }
117
118 int totalShadersCompiled() const { return mTotalShadersCompiled; }
119
120 private:
121 int mShadersCachedSinceLastCall = 0;
122 int mTotalShadersCompiled = 0;
Sally Qi4cabdd02021-08-05 16:45:57 -0700123 };
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700124
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400125 SkSLCacheMonitor mSkSLCacheMonitor;
126
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700127private:
128 void mapExternalTextureBuffer(const sp<GraphicBuffer>& buffer,
129 bool isRenderable) override final;
Alec Mouri92f89fa2023-02-24 00:05:06 +0000130 void unmapExternalTextureBuffer(sp<GraphicBuffer>&& buffer) override final;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700131 bool canSkipPostRenderCleanup() const override final;
132
Ian Elliott8506e362023-03-08 12:12:09 -0700133 std::shared_ptr<AutoBackendTexture::LocalRef> getOrCreateBackendTexture(
134 const sp<GraphicBuffer>& buffer, bool isOutputBuffer) REQUIRES(mRenderingMutex);
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700135 void initCanvas(SkCanvas* canvas, const DisplaySettings& display);
136 void drawShadow(SkCanvas* canvas, const SkRRect& casterRRect,
137 const ShadowSettings& shadowSettings);
Patrick Williams2e9748f2022-08-09 22:48:18 +0000138 void drawLayersInternal(const std::shared_ptr<std::promise<FenceResult>>&& resultPromise,
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700139 const DisplaySettings& display,
140 const std::vector<LayerSettings>& layers,
141 const std::shared_ptr<ExternalTexture>& buffer,
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700142 base::unique_fd&& bufferFence) override final;
143
144 void dump(std::string& result) override final;
145
146 // If requiresLinearEffect is true or the layer has a stretchEffect a new shader is returned.
147 // Otherwise it returns the input shader.
148 struct RuntimeEffectShaderParameters {
149 sk_sp<SkShader> shader;
150 const LayerSettings& layer;
151 const DisplaySettings& display;
152 bool undoPremultipliedAlpha;
153 bool requiresLinearEffect;
154 float layerDimmingRatio;
Sally Qi628ef6e2023-03-30 14:49:03 -0700155 const ui::Dataspace outputDataSpace;
Alec Mourie0bb6f42023-08-02 22:41:52 +0000156 const ui::Dataspace fakeOutputDataspace;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700157 };
158 sk_sp<SkShader> createRuntimeEffectShader(const RuntimeEffectShaderParameters&);
159
160 const PixelFormat mDefaultPixelFormat;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700161
162 // Identifier used for various mappings of layers to various
163 // textures or shaders
164 using GraphicBufferId = uint64_t;
165
166 // Number of external holders of ExternalTexture references, per GraphicBuffer ID.
167 std::unordered_map<GraphicBufferId, int32_t> mGraphicBufferExternalRefs
168 GUARDED_BY(mRenderingMutex);
Ian Elliott8506e362023-03-08 12:12:09 -0700169 // For GL, this cache is shared between protected and unprotected contexts. For Vulkan, it is
170 // only used for the unprotected context, because Vulkan does not allow sharing between
171 // contexts, and protected is less common.
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700172 std::unordered_map<GraphicBufferId, std::shared_ptr<AutoBackendTexture::LocalRef>> mTextureCache
173 GUARDED_BY(mRenderingMutex);
174 std::unordered_map<shaders::LinearEffect, sk_sp<SkRuntimeEffect>, shaders::LinearEffectHasher>
175 mRuntimeEffects;
176 AutoBackendTexture::CleanupManager mTextureCleanupMgr GUARDED_BY(mRenderingMutex);
177
178 StretchShaderFactory mStretchShaderFactory;
179
180 sp<Fence> mLastDrawFence;
181 BlurFilter* mBlurFilter = nullptr;
182
183 // Object to capture commands send to Skia.
184 std::unique_ptr<SkiaCapture> mCapture;
185
186 // Mutex guarding rendering operations, so that internal state related to
187 // rendering that is potentially modified by multiple threads is guaranteed thread-safe.
188 mutable std::mutex mRenderingMutex;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700189
190 // Graphics context used for creating surfaces and submitting commands
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400191 unique_ptr<SkiaGpuContext> mContext;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700192 // Same as above, but for protected content (eg. DRM)
Nolan Scobiefc125ec2024-03-11 20:08:27 -0400193 unique_ptr<SkiaGpuContext> mProtectedContext;
Lingfeng Yang00c1ff62022-06-02 09:19:28 -0700194 bool mInProtectedContext = false;
John Reck67b1e2b2020-08-26 13:17:24 -0700195};
196
197} // namespace skia
198} // namespace renderengine
199} // namespace android
200
Leon Scroggins IIIb9216dc2021-03-08 17:19:01 -0500201#endif /* SF_GLESRENDERENGINE_H_ */