blob: ed62a2a84f0aadc6e0c773858c9f576d47f81912 [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_SKIAGLRENDERENGINE_H_
18#define SF_SKIAGLRENDERENGINE_H_
19
Alec Mourib5777452020-09-28 11:32:42 -070020#include <EGL/egl.h>
21#include <EGL/eglext.h>
22#include <GLES2/gl2.h>
23#include <GrDirectContext.h>
24#include <SkSurface.h>
25#include <android-base/thread_annotations.h>
26#include <renderengine/RenderEngine.h>
John Reck67b1e2b2020-08-26 13:17:24 -070027#include <sys/types.h>
Alec Mourib5777452020-09-28 11:32:42 -070028
John Reck67b1e2b2020-08-26 13:17:24 -070029#include <mutex>
30#include <unordered_map>
31
Alec Mouric7f6c8b2020-11-09 18:35:20 -080032#include "AutoBackendTexture.h"
Alec Mourib5777452020-09-28 11:32:42 -070033#include "EGL/egl.h"
Alec Mouric7f6c8b2020-11-09 18:35:20 -080034#include "SkImageInfo.h"
John Reck67b1e2b2020-08-26 13:17:24 -070035#include "SkiaRenderEngine.h"
Alec Mouric7f6c8b2020-11-09 18:35:20 -080036#include "android-base/macros.h"
Alec Mouric0aae732021-01-12 13:32:18 -080037#include "debug/SkiaCapture.h"
Lucas Dupinf4cb4a02020-09-22 14:19:26 -070038#include "filters/BlurFilter.h"
Alec Mouric0aae732021-01-12 13:32:18 -080039#include "filters/LinearEffect.h"
John Reck67b1e2b2020-08-26 13:17:24 -070040
41namespace android {
42namespace renderengine {
43namespace skia {
44
45class SkiaGLRenderEngine : public skia::SkiaRenderEngine {
46public:
47 static std::unique_ptr<SkiaGLRenderEngine> create(const RenderEngineCreationArgs& args);
Lucas Dupind508e472020-11-04 04:32:06 +000048 SkiaGLRenderEngine(const RenderEngineCreationArgs& args, EGLDisplay display, EGLContext ctxt,
49 EGLSurface placeholder, EGLContext protectedContext,
John Reck67b1e2b2020-08-26 13:17:24 -070050 EGLSurface protectedPlaceholder);
Alec Mouric0aae732021-01-12 13:32:18 -080051 ~SkiaGLRenderEngine() override EXCLUDES(mRenderingMutex);
John Reck67b1e2b2020-08-26 13:17:24 -070052
53 void unbindExternalTextureBuffer(uint64_t bufferId) override;
54 status_t drawLayers(const DisplaySettings& display,
55 const std::vector<const LayerSettings*>& layers,
56 const sp<GraphicBuffer>& buffer, const bool useFramebufferCache,
57 base::unique_fd&& bufferFence, base::unique_fd* drawFence) override;
58 void cleanFramebufferCache() override;
Alec Mourid6f09462020-12-07 11:18:17 -080059 int getContextPriority() override;
Lucas Dupind508e472020-11-04 04:32:06 +000060 bool isProtected() const override { return mInProtectedContext; }
61 bool supportsProtectedContent() const override;
62 bool useProtectedContext(bool useProtectedContext) override;
John Reck67b1e2b2020-08-26 13:17:24 -070063
64protected:
65 void dump(std::string& /*result*/) override{};
66 size_t getMaxTextureSize() const override;
67 size_t getMaxViewportDims() const override;
68
69private:
70 static EGLConfig chooseEglConfig(EGLDisplay display, int format, bool logConfig);
71 static EGLContext createEglContext(EGLDisplay display, EGLConfig config,
Alec Mourid6f09462020-12-07 11:18:17 -080072 EGLContext shareContext,
73 std::optional<ContextPriority> contextPriority,
John Reck67b1e2b2020-08-26 13:17:24 -070074 Protection protection);
Alec Mourid6f09462020-12-07 11:18:17 -080075 static std::optional<RenderEngine::ContextPriority> createContextPriority(
76 const RenderEngineCreationArgs& args);
John Reck67b1e2b2020-08-26 13:17:24 -070077 static EGLSurface createPlaceholderEglPbufferSurface(EGLDisplay display, EGLConfig config,
78 int hwcFormat, Protection protection);
Lucas Dupin3f11e922020-09-22 17:31:04 -070079 inline SkRect getSkRect(const FloatRect& layer);
80 inline SkRect getSkRect(const Rect& layer);
Lucas Dupin21f348e2020-09-16 17:31:26 -070081 inline SkRRect getRoundedRect(const LayerSettings* layer);
Galia Peycheva80116e52020-11-06 11:57:25 +010082 inline BlurRegion getBlurRegion(const LayerSettings* layer);
Lucas Dupin3f11e922020-09-22 17:31:04 -070083 inline SkColor getSkColor(const vec4& color);
Lucas Dupinbb1a1d42020-09-18 15:17:02 -070084 inline SkM44 getSkM44(const mat4& matrix);
Lucas Dupin3f11e922020-09-22 17:31:04 -070085 inline SkPoint3 getSkPoint3(const vec3& vector);
John Reck67b1e2b2020-08-26 13:17:24 -070086
87 base::unique_fd flush();
88 bool waitFence(base::unique_fd fenceFd);
Lucas Dupin3f11e922020-09-22 17:31:04 -070089 void drawShadow(SkCanvas* canvas, const SkRect& casterRect, float casterCornerRadius,
90 const ShadowSettings& shadowSettings);
Galia Peychevaf7889b32020-11-25 22:22:40 +010091 void drawBlurRegion(SkCanvas* canvas, const BlurRegion& blurRegion, const SkRect& layerRect,
92 sk_sp<SkSurface> blurredSurface);
93 SkMatrix getBlurShaderTransform(const SkCanvas* canvas, const SkRect& layerRect);
Ana Krulec47814212021-01-06 19:00:10 -080094 // If mUseColorManagement is correct and layer needsLinearEffect, it returns a linear runtime
95 // shader. Otherwise it returns the input shader.
96 sk_sp<SkShader> createRuntimeEffectShader(sk_sp<SkShader> shader, const LayerSettings* layer,
97 const DisplaySettings& display,
98 bool undoPremultipliedAlpha);
John Reck67b1e2b2020-08-26 13:17:24 -070099
100 EGLDisplay mEGLDisplay;
John Reck67b1e2b2020-08-26 13:17:24 -0700101 EGLContext mEGLContext;
102 EGLSurface mPlaceholderSurface;
103 EGLContext mProtectedEGLContext;
104 EGLSurface mProtectedPlaceholderSurface;
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700105 BlurFilter* mBlurFilter = nullptr;
John Reck67b1e2b2020-08-26 13:17:24 -0700106
Alec Mourib5777452020-09-28 11:32:42 -0700107 const bool mUseColorManagement;
108
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800109 // Cache of GL textures that we'll store per GraphicBuffer ID
110 std::unordered_map<uint64_t, std::shared_ptr<AutoBackendTexture::LocalRef>> mTextureCache
111 GUARDED_BY(mRenderingMutex);
112 std::unordered_map<uint64_t, std::shared_ptr<AutoBackendTexture::LocalRef>>
113 mProtectedTextureCache GUARDED_BY(mRenderingMutex);
Alec Mouric16a77d2020-11-13 13:20:11 -0800114 std::unordered_map<LinearEffect, sk_sp<SkRuntimeEffect>, LinearEffectHasher> mRuntimeEffects;
John Reck67b1e2b2020-08-26 13:17:24 -0700115 // Mutex guarding rendering operations, so that:
116 // 1. GL operations aren't interleaved, and
117 // 2. Internal state related to rendering that is potentially modified by
118 // multiple threads is guaranteed thread-safe.
119 std::mutex mRenderingMutex;
120
121 sp<Fence> mLastDrawFence;
122
Lucas Dupind508e472020-11-04 04:32:06 +0000123 // Graphics context used for creating surfaces and submitting commands
John Reck67b1e2b2020-08-26 13:17:24 -0700124 sk_sp<GrDirectContext> mGrContext;
Lucas Dupind508e472020-11-04 04:32:06 +0000125 // Same as above, but for protected content (eg. DRM)
126 sk_sp<GrDirectContext> mProtectedGrContext;
John Reck67b1e2b2020-08-26 13:17:24 -0700127
Lucas Dupind508e472020-11-04 04:32:06 +0000128 bool mInProtectedContext = false;
Ana Krulec70d15b1b2020-12-01 10:05:15 -0800129 // Object to capture commands send to Skia.
Alec Mouric0aae732021-01-12 13:32:18 -0800130 std::unique_ptr<SkiaCapture> mCapture;
John Reck67b1e2b2020-08-26 13:17:24 -0700131};
132
133} // namespace skia
134} // namespace renderengine
135} // namespace android
136
Galia Peycheva6c460652020-11-03 19:42:42 +0100137#endif /* SF_GLESRENDERENGINE_H_ */