blob: 76ae2fc38ce1db2f32150664aa27aaa61a0fb423 [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//#define LOG_NDEBUG 0
Ana Krulec70d15b1b2020-12-01 10:05:15 -080018#undef LOG_TAG
19#define LOG_TAG "RenderEngine"
20#define ATRACE_TAG ATRACE_TAG_GRAPHICS
21
Alec Mouri4ce5ec02021-01-07 17:33:21 -080022#include "SkiaGLRenderEngine.h"
John Reck67b1e2b2020-08-26 13:17:24 -070023
John Reck67b1e2b2020-08-26 13:17:24 -070024#include <EGL/egl.h>
25#include <EGL/eglext.h>
John Reck67b1e2b2020-08-26 13:17:24 -070026#include <GrContextOptions.h>
John Reck67b1e2b2020-08-26 13:17:24 -070027#include <SkCanvas.h>
Alec Mourib34f0b72020-10-02 13:18:34 -070028#include <SkColorFilter.h>
29#include <SkColorMatrix.h>
Alec Mourib5777452020-09-28 11:32:42 -070030#include <SkColorSpace.h>
Derek Sollenberger0e6d3562021-04-07 19:34:39 -040031#include <SkGraphics.h>
John Reck67b1e2b2020-08-26 13:17:24 -070032#include <SkImage.h>
Lucas Dupinf4cb4a02020-09-22 14:19:26 -070033#include <SkImageFilters.h>
Alec Mouric0aae732021-01-12 13:32:18 -080034#include <SkRegion.h>
Lucas Dupin3f11e922020-09-22 17:31:04 -070035#include <SkShadowUtils.h>
John Reck67b1e2b2020-08-26 13:17:24 -070036#include <SkSurface.h>
Ana Krulec1d12b3b2021-01-27 16:49:51 -080037#include <android-base/stringprintf.h>
Alec Mourib5777452020-09-28 11:32:42 -070038#include <gl/GrGLInterface.h>
Alec Mouricbd30932021-06-09 15:52:25 -070039#include <gui/TraceUtils.h>
Alec Mouri4ce5ec02021-01-07 17:33:21 -080040#include <sync/sync.h>
41#include <ui/BlurRegion.h>
Alec Mouri88acab92022-03-24 23:41:01 +000042#include <ui/DataspaceUtils.h>
Ana Krulec1d12b3b2021-01-27 16:49:51 -080043#include <ui/DebugUtils.h>
Alec Mouri4ce5ec02021-01-07 17:33:21 -080044#include <ui/GraphicBuffer.h>
45#include <utils/Trace.h>
Alec Mourib5777452020-09-28 11:32:42 -070046
47#include <cmath>
Alec Mouri4ce5ec02021-01-07 17:33:21 -080048#include <cstdint>
49#include <memory>
Alec Mouricdf6cbc2021-11-01 17:21:15 -070050#include <numeric>
Alec Mouri4ce5ec02021-01-07 17:33:21 -080051
52#include "../gl/GLExtensions.h"
Derek Sollenberger0e6d3562021-04-07 19:34:39 -040053#include "Cache.h"
Alec Mouric0aae732021-01-12 13:32:18 -080054#include "ColorSpaces.h"
Alec Mouri4ce5ec02021-01-07 17:33:21 -080055#include "SkBlendMode.h"
56#include "SkImageInfo.h"
57#include "filters/BlurFilter.h"
Robin Lee26dacab2021-08-09 14:31:01 +020058#include "filters/GaussianBlurFilter.h"
Robin Lee026680a2021-07-26 12:49:53 +020059#include "filters/KawaseBlurFilter.h"
Alec Mouri4ce5ec02021-01-07 17:33:21 -080060#include "filters/LinearEffect.h"
61#include "log/log_main.h"
62#include "skia/debug/SkiaCapture.h"
Derek Sollenberger0e6d3562021-04-07 19:34:39 -040063#include "skia/debug/SkiaMemoryReporter.h"
Nader Jawad2dfc98b2021-04-08 20:35:39 -070064#include "skia/filters/StretchShaderFactory.h"
Alec Mouri4ce5ec02021-01-07 17:33:21 -080065#include "system/graphics-base-v1.0.h"
Alec Mourib5777452020-09-28 11:32:42 -070066
Nathaniel Nifongb9f27ef2021-04-01 16:44:12 -040067namespace {
68// Debugging settings
69static const bool kPrintLayerSettings = false;
70static const bool kFlushAfterEveryLayer = false;
71} // namespace
72
John Reck67b1e2b2020-08-26 13:17:24 -070073bool checkGlError(const char* op, int lineNumber);
74
75namespace android {
76namespace renderengine {
77namespace skia {
78
Ana Krulec1d12b3b2021-01-27 16:49:51 -080079using base::StringAppendF;
80
John Reck67b1e2b2020-08-26 13:17:24 -070081static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs, EGLint attribute,
82 EGLint wanted, EGLConfig* outConfig) {
83 EGLint numConfigs = -1, n = 0;
84 eglGetConfigs(dpy, nullptr, 0, &numConfigs);
85 std::vector<EGLConfig> configs(numConfigs, EGL_NO_CONFIG_KHR);
86 eglChooseConfig(dpy, attrs, configs.data(), configs.size(), &n);
87 configs.resize(n);
88
89 if (!configs.empty()) {
90 if (attribute != EGL_NONE) {
91 for (EGLConfig config : configs) {
92 EGLint value = 0;
93 eglGetConfigAttrib(dpy, config, attribute, &value);
94 if (wanted == value) {
95 *outConfig = config;
96 return NO_ERROR;
97 }
98 }
99 } else {
100 // just pick the first one
101 *outConfig = configs[0];
102 return NO_ERROR;
103 }
104 }
105
106 return NAME_NOT_FOUND;
107}
108
109static status_t selectEGLConfig(EGLDisplay display, EGLint format, EGLint renderableType,
110 EGLConfig* config) {
111 // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if
112 // it is to be used with WIFI displays
113 status_t err;
114 EGLint wantedAttribute;
115 EGLint wantedAttributeValue;
116
117 std::vector<EGLint> attribs;
118 if (renderableType) {
119 const ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(format);
120 const bool is1010102 = pixelFormat == ui::PixelFormat::RGBA_1010102;
121
122 // Default to 8 bits per channel.
123 const EGLint tmpAttribs[] = {
124 EGL_RENDERABLE_TYPE,
125 renderableType,
126 EGL_RECORDABLE_ANDROID,
127 EGL_TRUE,
128 EGL_SURFACE_TYPE,
129 EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
130 EGL_FRAMEBUFFER_TARGET_ANDROID,
131 EGL_TRUE,
132 EGL_RED_SIZE,
133 is1010102 ? 10 : 8,
134 EGL_GREEN_SIZE,
135 is1010102 ? 10 : 8,
136 EGL_BLUE_SIZE,
137 is1010102 ? 10 : 8,
138 EGL_ALPHA_SIZE,
139 is1010102 ? 2 : 8,
140 EGL_NONE,
141 };
142 std::copy(tmpAttribs, tmpAttribs + (sizeof(tmpAttribs) / sizeof(EGLint)),
143 std::back_inserter(attribs));
144 wantedAttribute = EGL_NONE;
145 wantedAttributeValue = EGL_NONE;
146 } else {
147 // if no renderable type specified, fallback to a simplified query
148 wantedAttribute = EGL_NATIVE_VISUAL_ID;
149 wantedAttributeValue = format;
150 }
151
152 err = selectConfigForAttribute(display, attribs.data(), wantedAttribute, wantedAttributeValue,
153 config);
154 if (err == NO_ERROR) {
155 EGLint caveat;
156 if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat))
157 ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!");
158 }
159
160 return err;
161}
162
163std::unique_ptr<SkiaGLRenderEngine> SkiaGLRenderEngine::create(
164 const RenderEngineCreationArgs& args) {
165 // initialize EGL for the default display
166 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
167 if (!eglInitialize(display, nullptr, nullptr)) {
168 LOG_ALWAYS_FATAL("failed to initialize EGL");
169 }
170
Yiwei Zhange2650962020-12-01 23:27:58 +0000171 const auto eglVersion = eglQueryString(display, EGL_VERSION);
John Reck67b1e2b2020-08-26 13:17:24 -0700172 if (!eglVersion) {
173 checkGlError(__FUNCTION__, __LINE__);
Yiwei Zhange2650962020-12-01 23:27:58 +0000174 LOG_ALWAYS_FATAL("eglQueryString(EGL_VERSION) failed");
John Reck67b1e2b2020-08-26 13:17:24 -0700175 }
176
Yiwei Zhange2650962020-12-01 23:27:58 +0000177 const auto eglExtensions = eglQueryString(display, EGL_EXTENSIONS);
John Reck67b1e2b2020-08-26 13:17:24 -0700178 if (!eglExtensions) {
179 checkGlError(__FUNCTION__, __LINE__);
Yiwei Zhange2650962020-12-01 23:27:58 +0000180 LOG_ALWAYS_FATAL("eglQueryString(EGL_EXTENSIONS) failed");
John Reck67b1e2b2020-08-26 13:17:24 -0700181 }
182
183 auto& extensions = gl::GLExtensions::getInstance();
184 extensions.initWithEGLStrings(eglVersion, eglExtensions);
185
186 // The code assumes that ES2 or later is available if this extension is
187 // supported.
188 EGLConfig config = EGL_NO_CONFIG_KHR;
189 if (!extensions.hasNoConfigContext()) {
190 config = chooseEglConfig(display, args.pixelFormat, /*logConfig*/ true);
191 }
192
John Reck67b1e2b2020-08-26 13:17:24 -0700193 EGLContext protectedContext = EGL_NO_CONTEXT;
Alec Mourid6f09462020-12-07 11:18:17 -0800194 const std::optional<RenderEngine::ContextPriority> priority = createContextPriority(args);
John Reck67b1e2b2020-08-26 13:17:24 -0700195 if (args.enableProtectedContext && extensions.hasProtectedContent()) {
Alec Mourid6f09462020-12-07 11:18:17 -0800196 protectedContext =
197 createEglContext(display, config, nullptr, priority, Protection::PROTECTED);
John Reck67b1e2b2020-08-26 13:17:24 -0700198 ALOGE_IF(protectedContext == EGL_NO_CONTEXT, "Can't create protected context");
199 }
200
Alec Mourid6f09462020-12-07 11:18:17 -0800201 EGLContext ctxt =
202 createEglContext(display, config, protectedContext, priority, Protection::UNPROTECTED);
John Reck67b1e2b2020-08-26 13:17:24 -0700203
204 // if can't create a GL context, we can only abort.
205 LOG_ALWAYS_FATAL_IF(ctxt == EGL_NO_CONTEXT, "EGLContext creation failed");
206
207 EGLSurface placeholder = EGL_NO_SURFACE;
208 if (!extensions.hasSurfacelessContext()) {
209 placeholder = createPlaceholderEglPbufferSurface(display, config, args.pixelFormat,
210 Protection::UNPROTECTED);
211 LOG_ALWAYS_FATAL_IF(placeholder == EGL_NO_SURFACE, "can't create placeholder pbuffer");
212 }
213 EGLBoolean success = eglMakeCurrent(display, placeholder, placeholder, ctxt);
214 LOG_ALWAYS_FATAL_IF(!success, "can't make placeholder pbuffer current");
215 extensions.initWithGLStrings(glGetString(GL_VENDOR), glGetString(GL_RENDERER),
216 glGetString(GL_VERSION), glGetString(GL_EXTENSIONS));
217
218 EGLSurface protectedPlaceholder = EGL_NO_SURFACE;
219 if (protectedContext != EGL_NO_CONTEXT && !extensions.hasSurfacelessContext()) {
220 protectedPlaceholder = createPlaceholderEglPbufferSurface(display, config, args.pixelFormat,
221 Protection::PROTECTED);
222 ALOGE_IF(protectedPlaceholder == EGL_NO_SURFACE,
223 "can't create protected placeholder pbuffer");
224 }
225
226 // initialize the renderer while GL is current
227 std::unique_ptr<SkiaGLRenderEngine> engine =
Lucas Dupind508e472020-11-04 04:32:06 +0000228 std::make_unique<SkiaGLRenderEngine>(args, display, ctxt, placeholder, protectedContext,
229 protectedPlaceholder);
John Reck67b1e2b2020-08-26 13:17:24 -0700230
231 ALOGI("OpenGL ES informations:");
232 ALOGI("vendor : %s", extensions.getVendor());
233 ALOGI("renderer : %s", extensions.getRenderer());
234 ALOGI("version : %s", extensions.getVersion());
235 ALOGI("extensions: %s", extensions.getExtensions());
236 ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize());
237 ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims());
238
239 return engine;
240}
241
Ady Abrahamfe2a6db2021-06-09 15:41:37 -0700242std::future<void> SkiaGLRenderEngine::primeCache() {
Leon Scroggins IIIb9216dc2021-03-08 17:19:01 -0500243 Cache::primeShaderCache(this);
Ady Abrahamfe2a6db2021-06-09 15:41:37 -0700244 return {};
Leon Scroggins IIIb9216dc2021-03-08 17:19:01 -0500245}
246
John Reck67b1e2b2020-08-26 13:17:24 -0700247EGLConfig SkiaGLRenderEngine::chooseEglConfig(EGLDisplay display, int format, bool logConfig) {
248 status_t err;
249 EGLConfig config;
250
251 // First try to get an ES3 config
252 err = selectEGLConfig(display, format, EGL_OPENGL_ES3_BIT, &config);
253 if (err != NO_ERROR) {
254 // If ES3 fails, try to get an ES2 config
255 err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);
256 if (err != NO_ERROR) {
257 // If ES2 still doesn't work, probably because we're on the emulator.
258 // try a simplified query
259 ALOGW("no suitable EGLConfig found, trying a simpler query");
260 err = selectEGLConfig(display, format, 0, &config);
261 if (err != NO_ERROR) {
262 // this EGL is too lame for android
263 LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up");
264 }
265 }
266 }
267
268 if (logConfig) {
269 // print some debugging info
270 EGLint r, g, b, a;
271 eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r);
272 eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
273 eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);
274 eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);
275 ALOGI("EGL information:");
276 ALOGI("vendor : %s", eglQueryString(display, EGL_VENDOR));
277 ALOGI("version : %s", eglQueryString(display, EGL_VERSION));
278 ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS));
279 ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS) ?: "Not Supported");
280 ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);
281 }
282
283 return config;
284}
285
Leon Scroggins III9f3072c2021-03-22 10:42:47 -0400286sk_sp<SkData> SkiaGLRenderEngine::SkSLCacheMonitor::load(const SkData& key) {
287 // This "cache" does not actually cache anything. It just allows us to
288 // monitor Skia's internal cache. So this method always returns null.
289 return nullptr;
290}
291
292void SkiaGLRenderEngine::SkSLCacheMonitor::store(const SkData& key, const SkData& data,
293 const SkString& description) {
294 mShadersCachedSinceLastCall++;
295}
296
297void SkiaGLRenderEngine::assertShadersCompiled(int numShaders) {
298 const int cached = mSkSLCacheMonitor.shadersCachedSinceLastCall();
299 LOG_ALWAYS_FATAL_IF(cached != numShaders, "Attempted to cache %i shaders; cached %i",
300 numShaders, cached);
301}
302
Nathaniel Nifongb9f27ef2021-04-01 16:44:12 -0400303int SkiaGLRenderEngine::reportShadersCompiled() {
304 return mSkSLCacheMonitor.shadersCachedSinceLastCall();
305}
306
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700307SkiaGLRenderEngine::SkiaGLRenderEngine(const RenderEngineCreationArgs& args, EGLDisplay display,
Lucas Dupind508e472020-11-04 04:32:06 +0000308 EGLContext ctxt, EGLSurface placeholder,
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700309 EGLContext protectedContext, EGLSurface protectedPlaceholder)
Alec Mouri0d995102021-02-24 16:53:38 -0800310 : SkiaRenderEngine(args.renderEngineType),
311 mEGLDisplay(display),
John Reck67b1e2b2020-08-26 13:17:24 -0700312 mEGLContext(ctxt),
313 mPlaceholderSurface(placeholder),
314 mProtectedEGLContext(protectedContext),
Alec Mourib5777452020-09-28 11:32:42 -0700315 mProtectedPlaceholderSurface(protectedPlaceholder),
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -0400316 mDefaultPixelFormat(static_cast<PixelFormat>(args.pixelFormat)),
Alec Mouri0d995102021-02-24 16:53:38 -0800317 mUseColorManagement(args.useColorManagement) {
John Reck67b1e2b2020-08-26 13:17:24 -0700318 sk_sp<const GrGLInterface> glInterface(GrGLCreateNativeInterface());
319 LOG_ALWAYS_FATAL_IF(!glInterface.get());
320
321 GrContextOptions options;
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -0400322 options.fDisableDriverCorrectnessWorkarounds = true;
John Reck67b1e2b2020-08-26 13:17:24 -0700323 options.fDisableDistanceFieldPaths = true;
Nathaniel Nifongf8d35e92021-06-08 15:02:25 -0400324 options.fReducedShaderVariations = true;
Leon Scroggins III9f3072c2021-03-22 10:42:47 -0400325 options.fPersistentCache = &mSkSLCacheMonitor;
Lucas Dupind508e472020-11-04 04:32:06 +0000326 mGrContext = GrDirectContext::MakeGL(glInterface, options);
Derek Sollenberger1ec2fb52021-06-16 15:11:27 -0400327 if (supportsProtectedContent()) {
328 useProtectedContext(true);
Lucas Dupind508e472020-11-04 04:32:06 +0000329 mProtectedGrContext = GrDirectContext::MakeGL(glInterface, options);
330 useProtectedContext(false);
331 }
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700332
333 if (args.supportsBackgroundBlur) {
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500334 ALOGD("Background Blurs Enabled");
Robin Lee026680a2021-07-26 12:49:53 +0200335 mBlurFilter = new KawaseBlurFilter();
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700336 }
Alec Mouric0aae732021-01-12 13:32:18 -0800337 mCapture = std::make_unique<SkiaCapture>();
338}
339
340SkiaGLRenderEngine::~SkiaGLRenderEngine() {
Marin Shalamanovcea12ef2021-03-15 17:00:51 +0100341 std::lock_guard<std::mutex> lock(mRenderingMutex);
Alec Mouric0aae732021-01-12 13:32:18 -0800342 if (mBlurFilter) {
343 delete mBlurFilter;
344 }
345
346 mCapture = nullptr;
347
348 mGrContext->flushAndSubmit(true);
349 mGrContext->abandonContext();
350
351 if (mProtectedGrContext) {
352 mProtectedGrContext->flushAndSubmit(true);
353 mProtectedGrContext->abandonContext();
354 }
355
356 if (mPlaceholderSurface != EGL_NO_SURFACE) {
357 eglDestroySurface(mEGLDisplay, mPlaceholderSurface);
358 }
359 if (mProtectedPlaceholderSurface != EGL_NO_SURFACE) {
360 eglDestroySurface(mEGLDisplay, mProtectedPlaceholderSurface);
361 }
362 if (mEGLContext != EGL_NO_CONTEXT) {
363 eglDestroyContext(mEGLDisplay, mEGLContext);
364 }
365 if (mProtectedEGLContext != EGL_NO_CONTEXT) {
366 eglDestroyContext(mEGLDisplay, mProtectedEGLContext);
367 }
368 eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
369 eglTerminate(mEGLDisplay);
370 eglReleaseThread();
John Reck67b1e2b2020-08-26 13:17:24 -0700371}
372
Lucas Dupind508e472020-11-04 04:32:06 +0000373bool SkiaGLRenderEngine::supportsProtectedContent() const {
374 return mProtectedEGLContext != EGL_NO_CONTEXT;
375}
376
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400377GrDirectContext* SkiaGLRenderEngine::getActiveGrContext() const {
378 return mInProtectedContext ? mProtectedGrContext.get() : mGrContext.get();
379}
380
Derek Sollenberger1ec2fb52021-06-16 15:11:27 -0400381void SkiaGLRenderEngine::useProtectedContext(bool useProtectedContext) {
382 if (useProtectedContext == mInProtectedContext ||
383 (useProtectedContext && !supportsProtectedContent())) {
384 return;
Lucas Dupind508e472020-11-04 04:32:06 +0000385 }
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400386
387 // release any scratch resources before switching into a new mode
388 if (getActiveGrContext()) {
389 getActiveGrContext()->purgeUnlockedResources(true);
390 }
391
Lucas Dupind508e472020-11-04 04:32:06 +0000392 const EGLSurface surface =
393 useProtectedContext ? mProtectedPlaceholderSurface : mPlaceholderSurface;
394 const EGLContext context = useProtectedContext ? mProtectedEGLContext : mEGLContext;
Alec Mouric0aae732021-01-12 13:32:18 -0800395
Derek Sollenberger1ec2fb52021-06-16 15:11:27 -0400396 if (eglMakeCurrent(mEGLDisplay, surface, surface, context) == EGL_TRUE) {
Lucas Dupind508e472020-11-04 04:32:06 +0000397 mInProtectedContext = useProtectedContext;
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400398 // given that we are sharing the same thread between two GrContexts we need to
399 // make sure that the thread state is reset when switching between the two.
400 if (getActiveGrContext()) {
401 getActiveGrContext()->resetContext();
402 }
Lucas Dupind508e472020-11-04 04:32:06 +0000403 }
Lucas Dupind508e472020-11-04 04:32:06 +0000404}
405
John Reck67b1e2b2020-08-26 13:17:24 -0700406base::unique_fd SkiaGLRenderEngine::flush() {
407 ATRACE_CALL();
408 if (!gl::GLExtensions::getInstance().hasNativeFenceSync()) {
409 return base::unique_fd();
410 }
411
412 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
413 if (sync == EGL_NO_SYNC_KHR) {
414 ALOGW("failed to create EGL native fence sync: %#x", eglGetError());
415 return base::unique_fd();
416 }
417
418 // native fence fd will not be populated until flush() is done.
419 glFlush();
420
421 // get the fence fd
422 base::unique_fd fenceFd(eglDupNativeFenceFDANDROID(mEGLDisplay, sync));
423 eglDestroySyncKHR(mEGLDisplay, sync);
424 if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
425 ALOGW("failed to dup EGL native fence sync: %#x", eglGetError());
426 }
427
428 return fenceFd;
429}
430
Alec Mouri4ee7b492021-08-11 10:36:55 -0700431void SkiaGLRenderEngine::waitFence(base::borrowed_fd fenceFd) {
432 if (fenceFd.get() >= 0 && !waitGpuFence(fenceFd)) {
433 ATRACE_NAME("SkiaGLRenderEngine::waitFence");
434 sync_wait(fenceFd.get(), -1);
435 }
436}
437
438bool SkiaGLRenderEngine::waitGpuFence(base::borrowed_fd fenceFd) {
John Reck67b1e2b2020-08-26 13:17:24 -0700439 if (!gl::GLExtensions::getInstance().hasNativeFenceSync() ||
440 !gl::GLExtensions::getInstance().hasWaitSync()) {
441 return false;
442 }
443
Alec Mouri4ee7b492021-08-11 10:36:55 -0700444 // Duplicate the fence for passing to eglCreateSyncKHR.
445 base::unique_fd fenceDup(dup(fenceFd.get()));
446 if (fenceDup.get() < 0) {
447 ALOGE("failed to create duplicate fence fd: %d", fenceDup.get());
448 return false;
449 }
450
John Reck67b1e2b2020-08-26 13:17:24 -0700451 // release the fd and transfer the ownership to EGLSync
Alec Mouri4ee7b492021-08-11 10:36:55 -0700452 EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceDup.release(), EGL_NONE};
John Reck67b1e2b2020-08-26 13:17:24 -0700453 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
454 if (sync == EGL_NO_SYNC_KHR) {
455 ALOGE("failed to create EGL native fence sync: %#x", eglGetError());
456 return false;
457 }
458
459 // XXX: The spec draft is inconsistent as to whether this should return an
460 // EGLint or void. Ignore the return value for now, as it's not strictly
461 // needed.
462 eglWaitSyncKHR(mEGLDisplay, sync, 0);
463 EGLint error = eglGetError();
464 eglDestroySyncKHR(mEGLDisplay, sync);
465 if (error != EGL_SUCCESS) {
466 ALOGE("failed to wait for EGL native fence sync: %#x", error);
467 return false;
468 }
469
470 return true;
471}
472
Alec Mouri678245d2020-09-30 16:58:23 -0700473static float toDegrees(uint32_t transform) {
474 switch (transform) {
475 case ui::Transform::ROT_90:
476 return 90.0;
477 case ui::Transform::ROT_180:
478 return 180.0;
479 case ui::Transform::ROT_270:
480 return 270.0;
481 default:
482 return 0.0;
483 }
484}
485
Alec Mourib34f0b72020-10-02 13:18:34 -0700486static SkColorMatrix toSkColorMatrix(const mat4& matrix) {
487 return SkColorMatrix(matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0], 0, matrix[0][1],
488 matrix[1][1], matrix[2][1], matrix[3][1], 0, matrix[0][2], matrix[1][2],
489 matrix[2][2], matrix[3][2], 0, matrix[0][3], matrix[1][3], matrix[2][3],
490 matrix[3][3], 0);
491}
492
Alec Mouri029d1952020-10-12 10:37:08 -0700493static bool needsToneMapping(ui::Dataspace sourceDataspace, ui::Dataspace destinationDataspace) {
494 int64_t sourceTransfer = sourceDataspace & HAL_DATASPACE_TRANSFER_MASK;
495 int64_t destTransfer = destinationDataspace & HAL_DATASPACE_TRANSFER_MASK;
496
497 // Treat unsupported dataspaces as srgb
498 if (destTransfer != HAL_DATASPACE_TRANSFER_LINEAR &&
499 destTransfer != HAL_DATASPACE_TRANSFER_HLG &&
500 destTransfer != HAL_DATASPACE_TRANSFER_ST2084) {
501 destTransfer = HAL_DATASPACE_TRANSFER_SRGB;
502 }
503
504 if (sourceTransfer != HAL_DATASPACE_TRANSFER_LINEAR &&
505 sourceTransfer != HAL_DATASPACE_TRANSFER_HLG &&
506 sourceTransfer != HAL_DATASPACE_TRANSFER_ST2084) {
507 sourceTransfer = HAL_DATASPACE_TRANSFER_SRGB;
508 }
509
510 const bool isSourceLinear = sourceTransfer == HAL_DATASPACE_TRANSFER_LINEAR;
511 const bool isSourceSRGB = sourceTransfer == HAL_DATASPACE_TRANSFER_SRGB;
512 const bool isDestLinear = destTransfer == HAL_DATASPACE_TRANSFER_LINEAR;
513 const bool isDestSRGB = destTransfer == HAL_DATASPACE_TRANSFER_SRGB;
514
515 return !(isSourceLinear && isDestSRGB) && !(isSourceSRGB && isDestLinear) &&
516 sourceTransfer != destTransfer;
517}
518
Alec Mouria90a5702021-04-16 16:36:21 +0000519void SkiaGLRenderEngine::mapExternalTextureBuffer(const sp<GraphicBuffer>& buffer,
520 bool isRenderable) {
Ana Krulecdfec8f52021-01-13 12:51:47 -0800521 // Only run this if RE is running on its own thread. This way the access to GL
522 // operations is guaranteed to be happening on the same thread.
523 if (mRenderEngineType != RenderEngineType::SKIA_GL_THREADED) {
524 return;
525 }
Derek Sollenbergerbc14f3c2021-05-21 14:29:16 -0400526 // We currently don't attempt to map a buffer if the buffer contains protected content
Derek Sollenberger45007182021-06-10 14:47:21 -0400527 // because GPU resources for protected buffers is much more limited.
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400528 const bool isProtectedBuffer = buffer->getUsage() & GRALLOC_USAGE_PROTECTED;
Derek Sollenberger45007182021-06-10 14:47:21 -0400529 if (isProtectedBuffer) {
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400530 return;
531 }
Ana Krulecdfec8f52021-01-13 12:51:47 -0800532 ATRACE_CALL();
533
Derek Sollenberger45007182021-06-10 14:47:21 -0400534 // If we were to support caching protected buffers then we will need to switch the
535 // currently bound context if we are not already using the protected context (and subsequently
536 // switch back after the buffer is cached). However, for non-protected content we can bind
537 // the texture in either GL context because they are initialized with the same share_context
538 // which allows the texture state to be shared between them.
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400539 auto grContext = getActiveGrContext();
Derek Sollenbergerbc14f3c2021-05-21 14:29:16 -0400540 auto& cache = mTextureCache;
Derek Sollenbergereb904d42021-03-22 12:58:53 -0400541
542 std::lock_guard<std::mutex> lock(mRenderingMutex);
Alec Mouria90a5702021-04-16 16:36:21 +0000543 mGraphicBufferExternalRefs[buffer->getId()]++;
544
545 if (const auto& iter = cache.find(buffer->getId()); iter == cache.end()) {
Ana Krulecdfec8f52021-01-13 12:51:47 -0800546 std::shared_ptr<AutoBackendTexture::LocalRef> imageTextureRef =
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400547 std::make_shared<AutoBackendTexture::LocalRef>(grContext,
Derek Sollenbergerd8fdae32021-04-09 13:52:59 -0400548 buffer->toAHardwareBuffer(),
Derek Sollenbergerd3f60652021-06-11 15:34:36 -0400549 isRenderable, mTextureCleanupMgr);
Derek Sollenbergereb904d42021-03-22 12:58:53 -0400550 cache.insert({buffer->getId(), imageTextureRef});
Ana Krulecdfec8f52021-01-13 12:51:47 -0800551 }
552}
553
Alec Mouria90a5702021-04-16 16:36:21 +0000554void SkiaGLRenderEngine::unmapExternalTextureBuffer(const sp<GraphicBuffer>& buffer) {
Ana Krulecdfec8f52021-01-13 12:51:47 -0800555 ATRACE_CALL();
John Reck67b1e2b2020-08-26 13:17:24 -0700556 std::lock_guard<std::mutex> lock(mRenderingMutex);
Alec Mouria90a5702021-04-16 16:36:21 +0000557 if (const auto& iter = mGraphicBufferExternalRefs.find(buffer->getId());
558 iter != mGraphicBufferExternalRefs.end()) {
559 if (iter->second == 0) {
560 ALOGW("Attempted to unmap GraphicBuffer <id: %" PRId64
561 "> from RenderEngine texture, but the "
562 "ref count was already zero!",
563 buffer->getId());
564 mGraphicBufferExternalRefs.erase(buffer->getId());
565 return;
566 }
567
568 iter->second--;
569
Alec Mouric2ffeb42021-06-17 17:42:27 -0700570 // Swap contexts if needed prior to deleting this buffer
571 // See Issue 1 of
572 // https://www.khronos.org/registry/EGL/extensions/EXT/EGL_EXT_protected_content.txt: even
573 // when a protected context and an unprotected context are part of the same share group,
574 // protected surfaces may not be accessed by an unprotected context, implying that protected
575 // surfaces may only be freed when a protected context is active.
576 const bool inProtected = mInProtectedContext;
577 useProtectedContext(buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
578
Alec Mouria90a5702021-04-16 16:36:21 +0000579 if (iter->second == 0) {
580 mTextureCache.erase(buffer->getId());
Alec Mouria90a5702021-04-16 16:36:21 +0000581 mGraphicBufferExternalRefs.erase(buffer->getId());
582 }
Alec Mouric2ffeb42021-06-17 17:42:27 -0700583
584 // Swap back to the previous context so that cached values of isProtected in SurfaceFlinger
585 // are up-to-date.
586 if (inProtected != mInProtectedContext) {
587 useProtectedContext(inProtected);
588 }
Alec Mouria90a5702021-04-16 16:36:21 +0000589 }
John Reck67b1e2b2020-08-26 13:17:24 -0700590}
591
Derek Sollenbergerd3f60652021-06-11 15:34:36 -0400592bool SkiaGLRenderEngine::canSkipPostRenderCleanup() const {
593 std::lock_guard<std::mutex> lock(mRenderingMutex);
594 return mTextureCleanupMgr.isEmpty();
595}
596
597void SkiaGLRenderEngine::cleanupPostRender() {
598 ATRACE_CALL();
599 std::lock_guard<std::mutex> lock(mRenderingMutex);
600 mTextureCleanupMgr.cleanup();
601}
602
603// Helper class intended to be used on the stack to ensure that texture cleanup
604// is deferred until after this class goes out of scope.
605class DeferTextureCleanup final {
606public:
607 DeferTextureCleanup(AutoBackendTexture::CleanupManager& mgr) : mMgr(mgr) {
608 mMgr.setDeferredStatus(true);
609 }
610 ~DeferTextureCleanup() { mMgr.setDeferredStatus(false); }
611
612private:
613 DISALLOW_COPY_AND_ASSIGN(DeferTextureCleanup);
614 AutoBackendTexture::CleanupManager& mMgr;
615};
616
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700617sk_sp<SkShader> SkiaGLRenderEngine::createRuntimeEffectShader(
618 const RuntimeEffectShaderParameters& parameters) {
Nader Jawad63644d32021-05-07 10:44:21 -0700619 // The given surface will be stretched by HWUI via matrix transformation
620 // which gets similar results for most surfaces
621 // Determine later on if we need to leverage the stertch shader within
622 // surface flinger
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700623 const auto& stretchEffect = parameters.layer.stretchEffect;
624 auto shader = parameters.shader;
Nader Jawadc088bdc2021-05-10 13:24:46 -0700625 if (stretchEffect.hasEffect()) {
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700626 const auto targetBuffer = parameters.layer.source.buffer.buffer;
Nader Jawadc088bdc2021-05-10 13:24:46 -0700627 const auto graphicBuffer = targetBuffer ? targetBuffer->getBuffer() : nullptr;
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700628 if (graphicBuffer && parameters.shader) {
Nader Jawad2dfc98b2021-04-08 20:35:39 -0700629 shader = mStretchShaderFactory.createSkShader(shader, stretchEffect);
630 }
John Reckcdb4ed72021-02-04 13:39:33 -0500631 }
Nader Jawad2dfc98b2021-04-08 20:35:39 -0700632
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700633 if (parameters.requiresLinearEffect) {
634 const ui::Dataspace inputDataspace = mUseColorManagement ? parameters.layer.sourceDataspace
635 : ui::Dataspace::V0_SRGB_LINEAR;
636 const ui::Dataspace outputDataspace = mUseColorManagement
637 ? parameters.display.outputDataspace
638 : ui::Dataspace::V0_SRGB_LINEAR;
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500639
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700640 auto effect =
641 shaders::LinearEffect{.inputDataspace = inputDataspace,
642 .outputDataspace = outputDataspace,
643 .undoPremultipliedAlpha = parameters.undoPremultipliedAlpha};
Ana Krulec47814212021-01-06 19:00:10 -0800644
645 auto effectIter = mRuntimeEffects.find(effect);
646 sk_sp<SkRuntimeEffect> runtimeEffect = nullptr;
647 if (effectIter == mRuntimeEffects.end()) {
648 runtimeEffect = buildRuntimeEffect(effect);
649 mRuntimeEffects.insert({effect, runtimeEffect});
650 } else {
651 runtimeEffect = effectIter->second;
652 }
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700653 mat4 colorTransform = parameters.layer.colorTransform;
654
655 colorTransform *=
656 mat4::scale(vec4(parameters.layerDimmingRatio, parameters.layerDimmingRatio,
657 parameters.layerDimmingRatio, 1.f));
Alec Mouri1a3c5452022-03-04 22:44:51 +0000658 const auto targetBuffer = parameters.layer.source.buffer.buffer;
659 const auto graphicBuffer = targetBuffer ? targetBuffer->getBuffer() : nullptr;
660 const auto hardwareBuffer = graphicBuffer ? graphicBuffer->toAHardwareBuffer() : nullptr;
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700661 return createLinearEffectShader(parameters.shader, effect, runtimeEffect, colorTransform,
662 parameters.display.maxLuminance,
Alec Mourib21d94e2022-01-13 17:44:10 -0800663 parameters.display.currentLuminanceNits,
Alec Mouri1a3c5452022-03-04 22:44:51 +0000664 parameters.layer.source.buffer.maxLuminanceNits,
Alec Mourifcedb9c2022-04-11 20:02:17 +0000665 hardwareBuffer, parameters.display.renderIntent);
Ana Krulec47814212021-01-06 19:00:10 -0800666 }
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700667 return parameters.shader;
Ana Krulec47814212021-01-06 19:00:10 -0800668}
669
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500670void SkiaGLRenderEngine::initCanvas(SkCanvas* canvas, const DisplaySettings& display) {
Derek Sollenberger76664d62021-02-04 11:13:09 -0500671 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500672 // Record display settings when capture is running.
673 std::stringstream displaySettings;
674 PrintTo(display, &displaySettings);
675 // Store the DisplaySettings in additional information.
676 canvas->drawAnnotation(SkRect::MakeEmpty(), "DisplaySettings",
677 SkData::MakeWithCString(displaySettings.str().c_str()));
678 }
679
680 // Before doing any drawing, let's make sure that we'll start at the origin of the display.
681 // Some displays don't start at 0,0 for example when we're mirroring the screen. Also, virtual
682 // displays might have different scaling when compared to the physical screen.
683
684 canvas->clipRect(getSkRect(display.physicalDisplay));
685 canvas->translate(display.physicalDisplay.left, display.physicalDisplay.top);
686
687 const auto clipWidth = display.clip.width();
688 const auto clipHeight = display.clip.height();
689 auto rotatedClipWidth = clipWidth;
690 auto rotatedClipHeight = clipHeight;
691 // Scale is contingent on the rotation result.
692 if (display.orientation & ui::Transform::ROT_90) {
693 std::swap(rotatedClipWidth, rotatedClipHeight);
694 }
695 const auto scaleX = static_cast<SkScalar>(display.physicalDisplay.width()) /
696 static_cast<SkScalar>(rotatedClipWidth);
697 const auto scaleY = static_cast<SkScalar>(display.physicalDisplay.height()) /
698 static_cast<SkScalar>(rotatedClipHeight);
699 canvas->scale(scaleX, scaleY);
700
701 // Canvas rotation is done by centering the clip window at the origin, rotating, translating
702 // back so that the top left corner of the clip is at (0, 0).
703 canvas->translate(rotatedClipWidth / 2, rotatedClipHeight / 2);
704 canvas->rotate(toDegrees(display.orientation));
705 canvas->translate(-clipWidth / 2, -clipHeight / 2);
706 canvas->translate(-display.clip.left, -display.clip.top);
707}
708
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500709class AutoSaveRestore {
710public:
711 AutoSaveRestore(SkCanvas* canvas) : mCanvas(canvas) { mSaveCount = canvas->save(); }
712 ~AutoSaveRestore() { restore(); }
713 void replace(SkCanvas* canvas) {
714 mCanvas = canvas;
715 mSaveCount = canvas->save();
716 }
717 void restore() {
718 if (mCanvas) {
719 mCanvas->restoreToCount(mSaveCount);
720 mCanvas = nullptr;
721 }
722 }
723
724private:
725 SkCanvas* mCanvas;
726 int mSaveCount;
727};
728
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -0400729static SkRRect getBlurRRect(const BlurRegion& region) {
730 const auto rect = SkRect::MakeLTRB(region.left, region.top, region.right, region.bottom);
731 const SkVector radii[4] = {SkVector::Make(region.cornerRadiusTL, region.cornerRadiusTL),
732 SkVector::Make(region.cornerRadiusTR, region.cornerRadiusTR),
733 SkVector::Make(region.cornerRadiusBR, region.cornerRadiusBR),
734 SkVector::Make(region.cornerRadiusBL, region.cornerRadiusBL)};
735 SkRRect roundedRect;
736 roundedRect.setRectRadii(rect, radii);
737 return roundedRect;
738}
739
Alec Mouri85065692022-03-18 00:58:26 +0000740// Arbitrary default margin which should be close enough to zero.
741constexpr float kDefaultMargin = 0.0001f;
742static bool equalsWithinMargin(float expected, float value, float margin = kDefaultMargin) {
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700743 LOG_ALWAYS_FATAL_IF(margin < 0.f, "Margin is negative!");
744 return std::abs(expected - value) < margin;
745}
746
Sally Qi4cabdd02021-08-05 16:45:57 -0700747void SkiaGLRenderEngine::drawLayersInternal(
748 const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,
Sally Qi59a9f502021-10-12 18:53:23 +0000749 const DisplaySettings& display, const std::vector<LayerSettings>& layers,
Sally Qi4cabdd02021-08-05 16:45:57 -0700750 const std::shared_ptr<ExternalTexture>& buffer, const bool /*useFramebufferCache*/,
751 base::unique_fd&& bufferFence) {
John Reck67b1e2b2020-08-26 13:17:24 -0700752 ATRACE_NAME("SkiaGL::drawLayers");
Alec Mouric0aae732021-01-12 13:32:18 -0800753
John Reck67b1e2b2020-08-26 13:17:24 -0700754 std::lock_guard<std::mutex> lock(mRenderingMutex);
755 if (layers.empty()) {
756 ALOGV("Drawing empty layer stack");
Sally Qi4cabdd02021-08-05 16:45:57 -0700757 resultPromise->set_value({NO_ERROR, base::unique_fd()});
758 return;
John Reck67b1e2b2020-08-26 13:17:24 -0700759 }
760
John Reck67b1e2b2020-08-26 13:17:24 -0700761 if (buffer == nullptr) {
762 ALOGE("No output buffer provided. Aborting GPU composition.");
Sally Qi4cabdd02021-08-05 16:45:57 -0700763 resultPromise->set_value({BAD_VALUE, base::unique_fd()});
764 return;
John Reck67b1e2b2020-08-26 13:17:24 -0700765 }
766
Alec Mouria90a5702021-04-16 16:36:21 +0000767 validateOutputBufferUsage(buffer->getBuffer());
Ady Abraham193426d2021-02-18 14:01:53 -0800768
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400769 auto grContext = getActiveGrContext();
Derek Sollenberger45007182021-06-10 14:47:21 -0400770 auto& cache = mTextureCache;
John Reck67b1e2b2020-08-26 13:17:24 -0700771
Derek Sollenbergerd3f60652021-06-11 15:34:36 -0400772 // any AutoBackendTexture deletions will now be deferred until cleanupPostRender is called
773 DeferTextureCleanup dtc(mTextureCleanupMgr);
774
Alec Mouria90a5702021-04-16 16:36:21 +0000775 std::shared_ptr<AutoBackendTexture::LocalRef> surfaceTextureRef;
776 if (const auto& it = cache.find(buffer->getBuffer()->getId()); it != cache.end()) {
777 surfaceTextureRef = it->second;
778 } else {
Derek Sollenbergerd8fdae32021-04-09 13:52:59 -0400779 surfaceTextureRef =
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400780 std::make_shared<AutoBackendTexture::LocalRef>(grContext,
781 buffer->getBuffer()
782 ->toAHardwareBuffer(),
Derek Sollenbergerd3f60652021-06-11 15:34:36 -0400783 true, mTextureCleanupMgr);
John Reck67b1e2b2020-08-26 13:17:24 -0700784 }
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800785
Alec Mouri4ee7b492021-08-11 10:36:55 -0700786 // wait on the buffer to be ready to use prior to using it
787 waitFence(bufferFence);
788
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500789 const ui::Dataspace dstDataspace =
Alec Mourid2bcbae2021-06-28 17:02:17 -0700790 mUseColorManagement ? display.outputDataspace : ui::Dataspace::V0_SRGB_LINEAR;
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400791 sk_sp<SkSurface> dstSurface = surfaceTextureRef->getOrCreateSurface(dstDataspace, grContext);
Alec Mouri678245d2020-09-30 16:58:23 -0700792
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500793 SkCanvas* dstCanvas = mCapture->tryCapture(dstSurface.get());
794 if (dstCanvas == nullptr) {
Ana Krulec6eab17a2020-12-09 15:52:36 -0800795 ALOGE("Cannot acquire canvas from Skia.");
Sally Qi4cabdd02021-08-05 16:45:57 -0700796 resultPromise->set_value({BAD_VALUE, base::unique_fd()});
797 return;
Ana Krulec6eab17a2020-12-09 15:52:36 -0800798 }
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500799
Derek Sollenbergerc20e0802021-05-19 16:20:59 -0400800 // setup color filter if necessary
801 sk_sp<SkColorFilter> displayColorTransform;
Leon Scroggins III745dcaa2022-01-26 11:55:58 -0500802 if (display.colorTransform != mat4() && !display.deviceHandlesColorTransform) {
Derek Sollenbergerc20e0802021-05-19 16:20:59 -0400803 displayColorTransform = SkColorFilters::Matrix(toSkColorMatrix(display.colorTransform));
804 }
805 const bool ctModifiesAlpha =
806 displayColorTransform && !displayColorTransform->isAlphaUnchanged();
807
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700808 // Find the max layer white point to determine the max luminance of the scene...
809 const float maxLayerWhitePoint = std::transform_reduce(
810 layers.cbegin(), layers.cend(), 0.f,
811 [](float left, float right) { return std::max(left, right); },
812 [&](const auto& l) { return l.whitePointNits; });
813
814 // ...and compute the dimming ratio if dimming is requested
815 const float displayDimmingRatio = display.targetLuminanceNits > 0.f &&
816 maxLayerWhitePoint > 0.f && display.targetLuminanceNits > maxLayerWhitePoint
817 ? maxLayerWhitePoint / display.targetLuminanceNits
818 : 1.f;
819
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500820 // Find if any layers have requested blur, we'll use that info to decide when to render to an
821 // offscreen buffer and when to render to the native buffer.
822 sk_sp<SkSurface> activeSurface(dstSurface);
823 SkCanvas* canvas = dstCanvas;
Derek Sollenberger76664d62021-02-04 11:13:09 -0500824 SkiaCapture::OffscreenState offscreenCaptureState;
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500825 const LayerSettings* blurCompositionLayer = nullptr;
826 if (mBlurFilter) {
827 bool requiresCompositionLayer = false;
828 for (const auto& layer : layers) {
Derek Sollenbergerc20e0802021-05-19 16:20:59 -0400829 // if the layer doesn't have blur or it is not visible then continue
830 if (!layerHasBlur(layer, ctModifiesAlpha)) {
831 continue;
832 }
Sally Qi59a9f502021-10-12 18:53:23 +0000833 if (layer.backgroundBlurRadius > 0 &&
Robin Lee26dacab2021-08-09 14:31:01 +0200834 layer.backgroundBlurRadius < mBlurFilter->getMaxCrossFadeRadius()) {
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500835 requiresCompositionLayer = true;
836 }
Sally Qi59a9f502021-10-12 18:53:23 +0000837 for (auto region : layer.blurRegions) {
Robin Lee26dacab2021-08-09 14:31:01 +0200838 if (region.blurRadius < mBlurFilter->getMaxCrossFadeRadius()) {
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500839 requiresCompositionLayer = true;
840 }
841 }
842 if (requiresCompositionLayer) {
843 activeSurface = dstSurface->makeSurface(dstSurface->imageInfo());
Derek Sollenberger76664d62021-02-04 11:13:09 -0500844 canvas = mCapture->tryOffscreenCapture(activeSurface.get(), &offscreenCaptureState);
Sally Qi59a9f502021-10-12 18:53:23 +0000845 blurCompositionLayer = &layer;
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500846 break;
847 }
848 }
849 }
850
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500851 AutoSaveRestore surfaceAutoSaveRestore(canvas);
Alec Mouri678245d2020-09-30 16:58:23 -0700852 // Clear the entire canvas with a transparent black to prevent ghost images.
853 canvas->clear(SK_ColorTRANSPARENT);
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500854 initCanvas(canvas, display);
Alec Mouric0aae732021-01-12 13:32:18 -0800855
John Reck67b1e2b2020-08-26 13:17:24 -0700856 for (const auto& layer : layers) {
Sally Qi59a9f502021-10-12 18:53:23 +0000857 ATRACE_FORMAT("DrawLayer: %s", layer.name.c_str());
Galia Peychevaf7889b32020-11-25 22:22:40 +0100858
Nathaniel Nifongb9f27ef2021-04-01 16:44:12 -0400859 if (kPrintLayerSettings) {
860 std::stringstream ls;
Sally Qi59a9f502021-10-12 18:53:23 +0000861 PrintTo(layer, &ls);
Nathaniel Nifongb9f27ef2021-04-01 16:44:12 -0400862 auto debugs = ls.str();
863 int pos = 0;
864 while (pos < debugs.size()) {
865 ALOGD("cache_debug %s", debugs.substr(pos, 1000).c_str());
866 pos += 1000;
867 }
868 }
869
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500870 sk_sp<SkImage> blurInput;
Sally Qi59a9f502021-10-12 18:53:23 +0000871 if (blurCompositionLayer == &layer) {
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500872 LOG_ALWAYS_FATAL_IF(activeSurface == dstSurface);
873 LOG_ALWAYS_FATAL_IF(canvas == dstCanvas);
874
875 // save a snapshot of the activeSurface to use as input to the blur shaders
876 blurInput = activeSurface->makeImageSnapshot();
877
Leon Scroggins III55bf4742022-03-17 14:11:17 -0400878 // blit the offscreen framebuffer into the destination AHB, but only
879 // if there are blur regions. backgroundBlurRadius blurs the entire
880 // image below, so it can skip this step.
881 if (layer.blurRegions.size()) {
882 SkPaint paint;
883 paint.setBlendMode(SkBlendMode::kSrc);
884 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
885 uint64_t id = mCapture->endOffscreenCapture(&offscreenCaptureState);
886 dstCanvas->drawAnnotation(SkRect::Make(dstCanvas->imageInfo().dimensions()),
887 String8::format("SurfaceID|%" PRId64, id).c_str(),
888 nullptr);
889 dstCanvas->drawImage(blurInput, 0, 0, SkSamplingOptions(), &paint);
890 } else {
891 activeSurface->draw(dstCanvas, 0, 0, SkSamplingOptions(), &paint);
892 }
Derek Sollenberger76664d62021-02-04 11:13:09 -0500893 }
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500894
895 // assign dstCanvas to canvas and ensure that the canvas state is up to date
896 canvas = dstCanvas;
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500897 surfaceAutoSaveRestore.replace(canvas);
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500898 initCanvas(canvas, display);
899
900 LOG_ALWAYS_FATAL_IF(activeSurface->getCanvas()->getSaveCount() !=
901 dstSurface->getCanvas()->getSaveCount());
902 LOG_ALWAYS_FATAL_IF(activeSurface->getCanvas()->getTotalMatrix() !=
903 dstSurface->getCanvas()->getTotalMatrix());
904
905 // assign dstSurface to activeSurface
906 activeSurface = dstSurface;
907 }
908
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500909 SkAutoCanvasRestore layerAutoSaveRestore(canvas, true);
Derek Sollenberger76664d62021-02-04 11:13:09 -0500910 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
Ana Krulec6eab17a2020-12-09 15:52:36 -0800911 // Record the name of the layer if the capture is running.
912 std::stringstream layerSettings;
Sally Qi59a9f502021-10-12 18:53:23 +0000913 PrintTo(layer, &layerSettings);
Ana Krulec6eab17a2020-12-09 15:52:36 -0800914 // Store the LayerSettings in additional information.
Sally Qi59a9f502021-10-12 18:53:23 +0000915 canvas->drawAnnotation(SkRect::MakeEmpty(), layer.name.c_str(),
Ana Krulec6eab17a2020-12-09 15:52:36 -0800916 SkData::MakeWithCString(layerSettings.str().c_str()));
917 }
Galia Peychevaf7889b32020-11-25 22:22:40 +0100918 // Layers have a local transform that should be applied to them
Sally Qi59a9f502021-10-12 18:53:23 +0000919 canvas->concat(getSkM44(layer.geometry.positionTransform).asM33());
Galia Peycheva6c460652020-11-03 19:42:42 +0100920
Derek Sollenbergerc31985e2021-05-18 16:38:17 -0400921 const auto [bounds, roundRectClip] =
Sally Qi59a9f502021-10-12 18:53:23 +0000922 getBoundsAndClip(layer.geometry.boundaries, layer.geometry.roundedCornersCrop,
923 layer.geometry.roundedCornersRadius);
Derek Sollenbergerc20e0802021-05-19 16:20:59 -0400924 if (mBlurFilter && layerHasBlur(layer, ctModifiesAlpha)) {
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500925 std::unordered_map<uint32_t, sk_sp<SkImage>> cachedBlurs;
926
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500927 // if multiple layers have blur, then we need to take a snapshot now because
928 // only the lowest layer will have blurImage populated earlier
929 if (!blurInput) {
930 blurInput = activeSurface->makeImageSnapshot();
931 }
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500932 // rect to be blurred in the coordinate space of blurInput
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -0400933 const auto blurRect = canvas->getTotalMatrix().mapRect(bounds.rect());
934
935 // if the clip needs to be applied then apply it now and make sure
936 // it is restored before we attempt to draw any shadows.
937 SkAutoCanvasRestore acr(canvas, true);
938 if (!roundRectClip.isEmpty()) {
939 canvas->clipRRect(roundRectClip, true);
940 }
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500941
Galia Peychevae425ac82021-03-15 17:12:03 +0100942 // TODO(b/182216890): Filter out empty layers earlier
943 if (blurRect.width() > 0 && blurRect.height() > 0) {
Sally Qi59a9f502021-10-12 18:53:23 +0000944 if (layer.backgroundBlurRadius > 0) {
Galia Peychevae425ac82021-03-15 17:12:03 +0100945 ATRACE_NAME("BackgroundBlur");
Sally Qi59a9f502021-10-12 18:53:23 +0000946 auto blurredImage = mBlurFilter->generate(grContext, layer.backgroundBlurRadius,
947 blurInput, blurRect);
Galia Peycheva80116e52020-11-06 11:57:25 +0100948
Sally Qi59a9f502021-10-12 18:53:23 +0000949 cachedBlurs[layer.backgroundBlurRadius] = blurredImage;
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500950
Sally Qi59a9f502021-10-12 18:53:23 +0000951 mBlurFilter->drawBlurRegion(canvas, bounds, layer.backgroundBlurRadius, 1.0f,
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -0400952 blurRect, blurredImage, blurInput);
Lucas Dupinc3800b82020-10-02 16:24:48 -0700953 }
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -0400954
Sally Qi59a9f502021-10-12 18:53:23 +0000955 canvas->concat(getSkM44(layer.blurRegionTransform).asM33());
956 for (auto region : layer.blurRegions) {
Galia Peychevae425ac82021-03-15 17:12:03 +0100957 if (cachedBlurs[region.blurRadius] == nullptr) {
958 ATRACE_NAME("BlurRegion");
959 cachedBlurs[region.blurRadius] =
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400960 mBlurFilter->generate(grContext, region.blurRadius, blurInput,
Galia Peychevae425ac82021-03-15 17:12:03 +0100961 blurRect);
962 }
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500963
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -0400964 mBlurFilter->drawBlurRegion(canvas, getBlurRRect(region), region.blurRadius,
965 region.alpha, blurRect,
Galia Peychevae425ac82021-03-15 17:12:03 +0100966 cachedBlurs[region.blurRadius], blurInput);
967 }
Lucas Dupinc3800b82020-10-02 16:24:48 -0700968 }
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700969 }
970
Sally Qi59a9f502021-10-12 18:53:23 +0000971 if (layer.shadow.length > 0) {
Leon Scroggins IIIcf3d95c2021-03-19 13:06:32 -0400972 // This would require a new parameter/flag to SkShadowUtils::DrawShadow
Sally Qi59a9f502021-10-12 18:53:23 +0000973 LOG_ALWAYS_FATAL_IF(layer.disableBlending, "Cannot disableBlending with a shadow");
Leon Scroggins III63e86952021-05-12 10:45:08 -0400974
Derek Sollenbergerc31985e2021-05-18 16:38:17 -0400975 SkRRect shadowBounds, shadowClip;
Sally Qi59a9f502021-10-12 18:53:23 +0000976 if (layer.geometry.boundaries == layer.shadow.boundaries) {
Derek Sollenbergerc31985e2021-05-18 16:38:17 -0400977 shadowBounds = bounds;
978 shadowClip = roundRectClip;
979 } else {
980 std::tie(shadowBounds, shadowClip) =
Sally Qi59a9f502021-10-12 18:53:23 +0000981 getBoundsAndClip(layer.shadow.boundaries, layer.geometry.roundedCornersCrop,
982 layer.geometry.roundedCornersRadius);
Derek Sollenbergerc31985e2021-05-18 16:38:17 -0400983 }
984
Leon Scroggins III63e86952021-05-12 10:45:08 -0400985 // Technically, if bounds is a rect and roundRectClip is not empty,
986 // it means that the bounds and roundedCornersCrop were different
987 // enough that we should intersect them to find the proper shadow.
988 // In practice, this often happens when the two rectangles appear to
989 // not match due to rounding errors. Draw the rounded version, which
990 // looks more like the intent.
991 const auto& rrect =
Derek Sollenbergerc31985e2021-05-18 16:38:17 -0400992 shadowBounds.isRect() && !shadowClip.isEmpty() ? shadowClip : shadowBounds;
Sally Qi59a9f502021-10-12 18:53:23 +0000993 drawShadow(canvas, rrect, layer.shadow);
Derek Sollenberger4c331c82021-02-23 13:09:50 -0500994 }
995
Alec Mouricdf6cbc2021-11-01 17:21:15 -0700996 const float layerDimmingRatio = layer.whitePointNits <= 0.f
997 ? displayDimmingRatio
998 : (layer.whitePointNits / maxLayerWhitePoint) * displayDimmingRatio;
999
Alec Mouri85065692022-03-18 00:58:26 +00001000 const bool dimInLinearSpace = display.dimmingStage !=
1001 aidl::android::hardware::graphics::composer3::DimmingStage::GAMMA_OETF;
1002
Sally Qi59a9f502021-10-12 18:53:23 +00001003 const bool requiresLinearEffect = layer.colorTransform != mat4() ||
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -05001004 (mUseColorManagement &&
Sally Qi59a9f502021-10-12 18:53:23 +00001005 needsToneMapping(layer.sourceDataspace, display.outputDataspace)) ||
Alec Mouri85065692022-03-18 00:58:26 +00001006 (dimInLinearSpace && !equalsWithinMargin(1.f, layerDimmingRatio));
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -05001007
1008 // quick abort from drawing the remaining portion of the layer
Sally Qi59a9f502021-10-12 18:53:23 +00001009 if (layer.skipContentDraw ||
1010 (layer.alpha == 0 && !requiresLinearEffect && !layer.disableBlending &&
Derek Sollenbergerc31985e2021-05-18 16:38:17 -04001011 (!displayColorTransform || displayColorTransform->isAlphaUnchanged()))) {
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -05001012 continue;
1013 }
1014
1015 // If we need to map to linear space or color management is disabled, then mark the source
1016 // image with the same colorspace as the destination surface so that Skia's color
1017 // management is a no-op.
1018 const ui::Dataspace layerDataspace = (!mUseColorManagement || requiresLinearEffect)
1019 ? dstDataspace
Sally Qi59a9f502021-10-12 18:53:23 +00001020 : layer.sourceDataspace;
Alec Mouric0aae732021-01-12 13:32:18 -08001021
Derek Sollenbergerecb21462021-01-29 16:53:49 -05001022 SkPaint paint;
Sally Qi59a9f502021-10-12 18:53:23 +00001023 if (layer.source.buffer.buffer) {
John Reck67b1e2b2020-08-26 13:17:24 -07001024 ATRACE_NAME("DrawImage");
Sally Qi59a9f502021-10-12 18:53:23 +00001025 validateInputBufferUsage(layer.source.buffer.buffer->getBuffer());
1026 const auto& item = layer.source.buffer;
Alec Mouric7f6c8b2020-11-09 18:35:20 -08001027 std::shared_ptr<AutoBackendTexture::LocalRef> imageTextureRef = nullptr;
Alec Mouria90a5702021-04-16 16:36:21 +00001028
1029 if (const auto& iter = cache.find(item.buffer->getBuffer()->getId());
1030 iter != cache.end()) {
Alec Mouric7f6c8b2020-11-09 18:35:20 -08001031 imageTextureRef = iter->second;
John Reck67b1e2b2020-08-26 13:17:24 -07001032 } else {
Alec Mouria90a5702021-04-16 16:36:21 +00001033 // If we didn't find the image in the cache, then create a local ref but don't cache
1034 // it. If we're using skia, we're guaranteed to run on a dedicated GPU thread so if
1035 // we didn't find anything in the cache then we intentionally did not cache this
1036 // buffer's resources.
Derek Sollenbergerd8fdae32021-04-09 13:52:59 -04001037 imageTextureRef = std::make_shared<
Derek Sollenbergerb24258c2021-05-04 13:47:34 -04001038 AutoBackendTexture::LocalRef>(grContext,
Derek Sollenbergerd8fdae32021-04-09 13:52:59 -04001039 item.buffer->getBuffer()->toAHardwareBuffer(),
Derek Sollenbergerd3f60652021-06-11 15:34:36 -04001040 false, mTextureCleanupMgr);
John Reck67b1e2b2020-08-26 13:17:24 -07001041 }
Alec Mouri1a4d0642020-11-13 17:42:01 -08001042
Alec Mouri4ee7b492021-08-11 10:36:55 -07001043 // if the layer's buffer has a fence, then we must must respect the fence prior to using
1044 // the buffer.
Sally Qi59a9f502021-10-12 18:53:23 +00001045 if (layer.source.buffer.fence != nullptr) {
1046 waitFence(layer.source.buffer.fence->get());
Alec Mouri4ee7b492021-08-11 10:36:55 -07001047 }
1048
Leon Scroggins IIIc4e0cbd2021-05-25 10:25:20 -04001049 // isOpaque means we need to ignore the alpha in the image,
1050 // replacing it with the alpha specified by the LayerSettings. See
1051 // https://developer.android.com/reference/android/view/SurfaceControl.Builder#setOpaque(boolean)
1052 // The proper way to do this is to use an SkColorType that ignores
1053 // alpha, like kRGB_888x_SkColorType, and that is used if the
1054 // incoming image is kRGBA_8888_SkColorType. However, the incoming
1055 // image may be kRGBA_F16_SkColorType, for which there is no RGBX
1056 // SkColorType, or kRGBA_1010102_SkColorType, for which we have
1057 // kRGB_101010x_SkColorType, but it is not yet supported as a source
1058 // on the GPU. (Adding both is tracked in skbug.com/12048.) In the
1059 // meantime, we'll use a workaround that works unless we need to do
1060 // any color conversion. The workaround requires that we pretend the
1061 // image is already premultiplied, so that we do not premultiply it
1062 // before applying SkBlendMode::kPlus.
1063 const bool useIsOpaqueWorkaround = item.isOpaque &&
1064 (imageTextureRef->colorType() == kRGBA_1010102_SkColorType ||
1065 imageTextureRef->colorType() == kRGBA_F16_SkColorType);
1066 const auto alphaType = useIsOpaqueWorkaround ? kPremul_SkAlphaType
1067 : item.isOpaque ? kOpaque_SkAlphaType
1068 : item.usePremultipliedAlpha ? kPremul_SkAlphaType
1069 : kUnpremul_SkAlphaType;
1070 sk_sp<SkImage> image = imageTextureRef->makeImage(layerDataspace, alphaType, grContext);
Alec Mouri678245d2020-09-30 16:58:23 -07001071
1072 auto texMatrix = getSkM44(item.textureTransform).asM33();
1073 // textureTansform was intended to be passed directly into a shader, so when
1074 // building the total matrix with the textureTransform we need to first
1075 // normalize it, then apply the textureTransform, then scale back up.
Derek Sollenbergerecb21462021-01-29 16:53:49 -05001076 texMatrix.preScale(1.0f / bounds.width(), 1.0f / bounds.height());
Huihong Luo3a3cf3c2020-12-07 17:05:41 -08001077 texMatrix.postScale(image->width(), image->height());
Alec Mouri678245d2020-09-30 16:58:23 -07001078
Huihong Luo3a3cf3c2020-12-07 17:05:41 -08001079 SkMatrix matrix;
1080 if (!texMatrix.invert(&matrix)) {
1081 matrix = texMatrix;
Alec Mouri678245d2020-09-30 16:58:23 -07001082 }
Ana Krulecf9a15d92020-12-11 08:35:00 -08001083 // The shader does not respect the translation, so we add it to the texture
1084 // transform for the SkImage. This will make sure that the correct layer contents
1085 // are drawn in the correct part of the screen.
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001086 matrix.postTranslate(bounds.rect().fLeft, bounds.rect().fTop);
Alec Mouri678245d2020-09-30 16:58:23 -07001087
Ana Krulecb7b28b22020-11-23 14:48:58 -08001088 sk_sp<SkShader> shader;
1089
Sally Qi59a9f502021-10-12 18:53:23 +00001090 if (layer.source.buffer.useTextureFiltering) {
Ana Krulecb7b28b22020-11-23 14:48:58 -08001091 shader = image->makeShader(SkTileMode::kClamp, SkTileMode::kClamp,
1092 SkSamplingOptions(
1093 {SkFilterMode::kLinear, SkMipmapMode::kNone}),
1094 &matrix);
1095 } else {
Mike Reed711e1f02020-12-11 13:06:19 -05001096 shader = image->makeShader(SkSamplingOptions(), matrix);
Ana Krulecb7b28b22020-11-23 14:48:58 -08001097 }
Alec Mouri029d1952020-10-12 10:37:08 -07001098
Leon Scroggins IIIc4e0cbd2021-05-25 10:25:20 -04001099 if (useIsOpaqueWorkaround) {
Alec Mouric0aae732021-01-12 13:32:18 -08001100 shader = SkShaders::Blend(SkBlendMode::kPlus, shader,
1101 SkShaders::Color(SkColors::kBlack,
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -05001102 toSkColorSpace(layerDataspace)));
Alec Mouric0aae732021-01-12 13:32:18 -08001103 }
1104
Alec Mouricdf6cbc2021-11-01 17:21:15 -07001105 paint.setShader(createRuntimeEffectShader(
1106 RuntimeEffectShaderParameters{.shader = shader,
1107 .layer = layer,
1108 .display = display,
1109 .undoPremultipliedAlpha = !item.isOpaque &&
1110 item.usePremultipliedAlpha,
1111 .requiresLinearEffect = requiresLinearEffect,
Alec Mouri85065692022-03-18 00:58:26 +00001112 .layerDimmingRatio = dimInLinearSpace
1113 ? layerDimmingRatio
1114 : 1.f}));
Alec Mouricdf6cbc2021-11-01 17:21:15 -07001115
Alec Mouri88acab92022-03-24 23:41:01 +00001116 // Turn on dithering when dimming beyond this (arbitrary) threshold...
Alec Mouricdf6cbc2021-11-01 17:21:15 -07001117 static constexpr float kDimmingThreshold = 0.2f;
Alec Mouri88acab92022-03-24 23:41:01 +00001118 // ...or we're rendering an HDR layer down to an 8-bit target
1119 // Most HDR standards require at least 10-bits of color depth for source content, so we
1120 // can just extract the transfer function rather than dig into precise gralloc layout.
1121 // Furthermore, we can assume that the only 8-bit target we support is RGBA8888.
1122 const bool requiresDownsample = isHdrDataspace(layer.sourceDataspace) &&
1123 buffer->getPixelFormat() == PIXEL_FORMAT_RGBA_8888;
1124 if (layerDimmingRatio <= kDimmingThreshold || requiresDownsample) {
Alec Mouricdf6cbc2021-11-01 17:21:15 -07001125 paint.setDither(true);
1126 }
Sally Qi59a9f502021-10-12 18:53:23 +00001127 paint.setAlphaf(layer.alpha);
Leon Scroggins III2c1d9ef2022-01-21 13:46:56 -05001128
1129 if (imageTextureRef->colorType() == kAlpha_8_SkColorType) {
1130 LOG_ALWAYS_FATAL_IF(layer.disableBlending, "Cannot disableBlending with A8");
Leon Scroggins III745dcaa2022-01-26 11:55:58 -05001131
1132 // SysUI creates the alpha layer as a coverage layer, which is
1133 // appropriate for the DPU. Use a color matrix to convert it to
1134 // a mask.
1135 // TODO (b/219525258): Handle input as a mask.
1136 //
1137 // The color matrix will convert A8 pixels with no alpha to
1138 // black, as described by this vector. If the display handles
1139 // the color transform, we need to invert it to find the color
1140 // that will result in black after the DPU applies the transform.
1141 SkV4 black{0.0f, 0.0f, 0.0f, 1.0f}; // r, g, b, a
1142 if (display.colorTransform != mat4() && display.deviceHandlesColorTransform) {
1143 SkM44 colorSpaceMatrix = getSkM44(display.colorTransform);
1144 if (colorSpaceMatrix.invert(&colorSpaceMatrix)) {
1145 black = colorSpaceMatrix * black;
1146 } else {
1147 // We'll just have to use 0,0,0 as black, which should
1148 // be close to correct.
1149 ALOGI("Could not invert colorTransform!");
1150 }
1151 }
1152 SkColorMatrix colorMatrix(0, 0, 0, 0, black[0],
1153 0, 0, 0, 0, black[1],
1154 0, 0, 0, 0, black[2],
1155 0, 0, 0, -1, 1);
1156 if (display.colorTransform != mat4() && !display.deviceHandlesColorTransform) {
1157 // On the other hand, if the device doesn't handle it, we
1158 // have to apply it ourselves.
1159 colorMatrix.postConcat(toSkColorMatrix(display.colorTransform));
1160 }
1161 paint.setColorFilter(SkColorFilters::Matrix(colorMatrix));
Leon Scroggins III2c1d9ef2022-01-21 13:46:56 -05001162 }
John Reck67b1e2b2020-08-26 13:17:24 -07001163 } else {
1164 ATRACE_NAME("DrawColor");
Sally Qi59a9f502021-10-12 18:53:23 +00001165 const auto color = layer.source.solidColor;
Ana Krulec47814212021-01-06 19:00:10 -08001166 sk_sp<SkShader> shader = SkShaders::Color(SkColor4f{.fR = color.r,
1167 .fG = color.g,
1168 .fB = color.b,
Sally Qi59a9f502021-10-12 18:53:23 +00001169 .fA = layer.alpha},
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -05001170 toSkColorSpace(layerDataspace));
Alec Mouricdf6cbc2021-11-01 17:21:15 -07001171 paint.setShader(createRuntimeEffectShader(
1172 RuntimeEffectShaderParameters{.shader = shader,
1173 .layer = layer,
1174 .display = display,
1175 .undoPremultipliedAlpha = false,
1176 .requiresLinearEffect = requiresLinearEffect,
1177 .layerDimmingRatio = layerDimmingRatio}));
John Reck67b1e2b2020-08-26 13:17:24 -07001178 }
Lucas Dupin21f348e2020-09-16 17:31:26 -07001179
Sally Qi59a9f502021-10-12 18:53:23 +00001180 if (layer.disableBlending) {
Leon Scroggins IIIcf3d95c2021-03-19 13:06:32 -04001181 paint.setBlendMode(SkBlendMode::kSrc);
1182 }
1183
Leon Scroggins III745dcaa2022-01-26 11:55:58 -05001184 // An A8 buffer will already have the proper color filter attached to
1185 // its paint, including the displayColorTransform as needed.
Leon Scroggins III2c1d9ef2022-01-21 13:46:56 -05001186 if (!paint.getColorFilter()) {
Alec Mouri85065692022-03-18 00:58:26 +00001187 if (!dimInLinearSpace && !equalsWithinMargin(1.0, layerDimmingRatio)) {
1188 // If we don't dim in linear space, then when we gamma correct the dimming ratio we
1189 // can assume a gamma 2.2 transfer function.
1190 static constexpr float kInverseGamma22 = 1.f / 2.2f;
1191 const auto gammaCorrectedDimmingRatio =
1192 std::pow(layerDimmingRatio, kInverseGamma22);
1193 const auto dimmingMatrix =
1194 mat4::scale(vec4(gammaCorrectedDimmingRatio, gammaCorrectedDimmingRatio,
1195 gammaCorrectedDimmingRatio, 1.f));
1196 paint.setColorFilter(SkColorFilters::Matrix(
1197 toSkColorMatrix(display.colorTransform * dimmingMatrix)));
1198 } else {
1199 paint.setColorFilter(displayColorTransform);
1200 }
Leon Scroggins III2c1d9ef2022-01-21 13:46:56 -05001201 }
Alec Mourib34f0b72020-10-02 13:18:34 -07001202
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001203 if (!roundRectClip.isEmpty()) {
1204 canvas->clipRRect(roundRectClip, true);
1205 }
1206
1207 if (!bounds.isRect()) {
Derek Sollenberger4c331c82021-02-23 13:09:50 -05001208 paint.setAntiAlias(true);
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001209 canvas->drawRRect(bounds, paint);
Alec Mouribd17b3b2020-12-17 11:08:30 -08001210 } else {
Nader Jawad63644d32021-05-07 10:44:21 -07001211 canvas->drawRect(bounds.rect(), paint);
Lucas Dupin3f11e922020-09-22 17:31:04 -07001212 }
Nathaniel Nifongb9f27ef2021-04-01 16:44:12 -04001213 if (kFlushAfterEveryLayer) {
1214 ATRACE_NAME("flush surface");
1215 activeSurface->flush();
1216 }
John Reck67b1e2b2020-08-26 13:17:24 -07001217 }
Derek Sollenberger7c42bef2021-02-23 13:01:39 -05001218 surfaceAutoSaveRestore.restore();
Alec Mouric0aae732021-01-12 13:32:18 -08001219 mCapture->endCapture();
John Reck67b1e2b2020-08-26 13:17:24 -07001220 {
1221 ATRACE_NAME("flush surface");
Derek Sollenberger3f77aa42021-02-04 11:06:34 -05001222 LOG_ALWAYS_FATAL_IF(activeSurface != dstSurface);
1223 activeSurface->flush();
John Reck67b1e2b2020-08-26 13:17:24 -07001224 }
1225
Sally Qi4cabdd02021-08-05 16:45:57 -07001226 base::unique_fd drawFence = flush();
John Reck67b1e2b2020-08-26 13:17:24 -07001227
1228 // If flush failed or we don't support native fences, we need to force the
1229 // gl command stream to be executed.
Sally Qi4cabdd02021-08-05 16:45:57 -07001230 bool requireSync = drawFence.get() < 0;
John Reck67b1e2b2020-08-26 13:17:24 -07001231 if (requireSync) {
1232 ATRACE_BEGIN("Submit(sync=true)");
1233 } else {
1234 ATRACE_BEGIN("Submit(sync=false)");
1235 }
Lucas Dupind508e472020-11-04 04:32:06 +00001236 bool success = grContext->submit(requireSync);
John Reck67b1e2b2020-08-26 13:17:24 -07001237 ATRACE_END();
1238 if (!success) {
1239 ALOGE("Failed to flush RenderEngine commands");
1240 // Chances are, something illegal happened (either the caller passed
1241 // us bad parameters, or we messed up our shader generation).
Sally Qi4cabdd02021-08-05 16:45:57 -07001242 resultPromise->set_value({INVALID_OPERATION, std::move(drawFence)});
1243 return;
John Reck67b1e2b2020-08-26 13:17:24 -07001244 }
1245
1246 // checkErrors();
Sally Qi4cabdd02021-08-05 16:45:57 -07001247 resultPromise->set_value({NO_ERROR, std::move(drawFence)});
1248 return;
John Reck67b1e2b2020-08-26 13:17:24 -07001249}
1250
Lucas Dupin3f11e922020-09-22 17:31:04 -07001251inline SkRect SkiaGLRenderEngine::getSkRect(const FloatRect& rect) {
1252 return SkRect::MakeLTRB(rect.left, rect.top, rect.right, rect.bottom);
1253}
1254
1255inline SkRect SkiaGLRenderEngine::getSkRect(const Rect& rect) {
1256 return SkRect::MakeLTRB(rect.left, rect.top, rect.right, rect.bottom);
1257}
1258
Derek Sollenberger547d0a62021-07-27 14:09:17 -04001259/**
1260 * Verifies that common, simple bounds + clip combinations can be converted into
1261 * a single RRect draw call returning true if possible. If true the radii parameter
1262 * will be filled with the correct radii values that combined with bounds param will
1263 * produce the insected roundRect. If false, the returned state of the radii param is undefined.
1264 */
1265static bool intersectionIsRoundRect(const SkRect& bounds, const SkRect& crop,
1266 const SkRect& insetCrop, float cornerRadius,
1267 SkVector radii[4]) {
1268 const bool leftEqual = bounds.fLeft == crop.fLeft;
1269 const bool topEqual = bounds.fTop == crop.fTop;
1270 const bool rightEqual = bounds.fRight == crop.fRight;
1271 const bool bottomEqual = bounds.fBottom == crop.fBottom;
1272
1273 // In the event that the corners of the bounds only partially align with the crop we
1274 // need to ensure that the resulting shape can still be represented as a round rect.
1275 // In particular the round rect implementation will scale the value of all corner radii
1276 // if the sum of the radius along any edge is greater than the length of that edge.
1277 // See https://www.w3.org/TR/css-backgrounds-3/#corner-overlap
1278 const bool requiredWidth = bounds.width() > (cornerRadius * 2);
1279 const bool requiredHeight = bounds.height() > (cornerRadius * 2);
1280 if (!requiredWidth || !requiredHeight) {
1281 return false;
1282 }
1283
1284 // Check each cropped corner to ensure that it exactly matches the crop or its corner is
1285 // contained within the cropped shape and does not need rounded.
1286 // compute the UpperLeft corner radius
1287 if (leftEqual && topEqual) {
1288 radii[0].set(cornerRadius, cornerRadius);
1289 } else if ((leftEqual && bounds.fTop >= insetCrop.fTop) ||
1290 (topEqual && bounds.fLeft >= insetCrop.fLeft)) {
1291 radii[0].set(0, 0);
1292 } else {
1293 return false;
1294 }
1295 // compute the UpperRight corner radius
1296 if (rightEqual && topEqual) {
1297 radii[1].set(cornerRadius, cornerRadius);
1298 } else if ((rightEqual && bounds.fTop >= insetCrop.fTop) ||
1299 (topEqual && bounds.fRight <= insetCrop.fRight)) {
1300 radii[1].set(0, 0);
1301 } else {
1302 return false;
1303 }
1304 // compute the BottomRight corner radius
1305 if (rightEqual && bottomEqual) {
1306 radii[2].set(cornerRadius, cornerRadius);
1307 } else if ((rightEqual && bounds.fBottom <= insetCrop.fBottom) ||
1308 (bottomEqual && bounds.fRight <= insetCrop.fRight)) {
1309 radii[2].set(0, 0);
1310 } else {
1311 return false;
1312 }
1313 // compute the BottomLeft corner radius
1314 if (leftEqual && bottomEqual) {
1315 radii[3].set(cornerRadius, cornerRadius);
1316 } else if ((leftEqual && bounds.fBottom <= insetCrop.fBottom) ||
1317 (bottomEqual && bounds.fLeft >= insetCrop.fLeft)) {
1318 radii[3].set(0, 0);
1319 } else {
1320 return false;
1321 }
1322
1323 return true;
1324}
1325
Derek Sollenbergerc31985e2021-05-18 16:38:17 -04001326inline std::pair<SkRRect, SkRRect> SkiaGLRenderEngine::getBoundsAndClip(const FloatRect& boundsRect,
1327 const FloatRect& cropRect,
1328 const float cornerRadius) {
1329 const SkRect bounds = getSkRect(boundsRect);
1330 const SkRect crop = getSkRect(cropRect);
Lucas Dupin21f348e2020-09-16 17:31:26 -07001331
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001332 SkRRect clip;
1333 if (cornerRadius > 0) {
Derek Sollenberger4f9959f2021-05-12 16:47:37 -04001334 // it the crop and the bounds are equivalent or there is no crop then we don't need a clip
1335 if (bounds == crop || crop.isEmpty()) {
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001336 return {SkRRect::MakeRectXY(bounds, cornerRadius, cornerRadius), clip};
1337 }
1338
1339 // This makes an effort to speed up common, simple bounds + clip combinations by
1340 // converting them to a single RRect draw. It is possible there are other cases
1341 // that can be converted.
1342 if (crop.contains(bounds)) {
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001343 const auto insetCrop = crop.makeInset(cornerRadius, cornerRadius);
Derek Sollenberger547d0a62021-07-27 14:09:17 -04001344 if (insetCrop.contains(bounds)) {
1345 return {SkRRect::MakeRect(bounds), clip}; // clip is empty - no rounding required
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001346 }
1347
Derek Sollenberger547d0a62021-07-27 14:09:17 -04001348 SkVector radii[4];
1349 if (intersectionIsRoundRect(bounds, crop, insetCrop, cornerRadius, radii)) {
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001350 SkRRect intersectionBounds;
1351 intersectionBounds.setRectRadii(bounds, radii);
1352 return {intersectionBounds, clip};
1353 }
1354 }
1355
Derek Sollenberger547d0a62021-07-27 14:09:17 -04001356 // we didn't hit any of our fast paths so set the clip to the cropRect
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001357 clip.setRectXY(crop, cornerRadius, cornerRadius);
1358 }
1359
1360 // if we hit this point then we either don't have rounded corners or we are going to rely
1361 // on the clip to round the corners for us
1362 return {SkRRect::MakeRect(bounds), clip};
Galia Peycheva80116e52020-11-06 11:57:25 +01001363}
1364
Sally Qi59a9f502021-10-12 18:53:23 +00001365inline bool SkiaGLRenderEngine::layerHasBlur(const LayerSettings& layer,
Derek Sollenbergerc20e0802021-05-19 16:20:59 -04001366 bool colorTransformModifiesAlpha) {
Sally Qi59a9f502021-10-12 18:53:23 +00001367 if (layer.backgroundBlurRadius > 0 || layer.blurRegions.size()) {
Derek Sollenbergerc20e0802021-05-19 16:20:59 -04001368 // return false if the content is opaque and would therefore occlude the blur
Sally Qi59a9f502021-10-12 18:53:23 +00001369 const bool opaqueContent = !layer.source.buffer.buffer || layer.source.buffer.isOpaque;
1370 const bool opaqueAlpha = layer.alpha == 1.0f && !colorTransformModifiesAlpha;
1371 return layer.skipContentDraw || !(opaqueContent && opaqueAlpha);
Derek Sollenbergerc20e0802021-05-19 16:20:59 -04001372 }
1373 return false;
Derek Sollenbergerecb21462021-01-29 16:53:49 -05001374}
1375
Lucas Dupin3f11e922020-09-22 17:31:04 -07001376inline SkColor SkiaGLRenderEngine::getSkColor(const vec4& color) {
1377 return SkColorSetARGB(color.a * 255, color.r * 255, color.g * 255, color.b * 255);
1378}
1379
Lucas Dupinbb1a1d42020-09-18 15:17:02 -07001380inline SkM44 SkiaGLRenderEngine::getSkM44(const mat4& matrix) {
1381 return SkM44(matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0],
1382 matrix[0][1], matrix[1][1], matrix[2][1], matrix[3][1],
1383 matrix[0][2], matrix[1][2], matrix[2][2], matrix[3][2],
1384 matrix[0][3], matrix[1][3], matrix[2][3], matrix[3][3]);
1385}
1386
Lucas Dupin3f11e922020-09-22 17:31:04 -07001387inline SkPoint3 SkiaGLRenderEngine::getSkPoint3(const vec3& vector) {
1388 return SkPoint3::Make(vector.x, vector.y, vector.z);
1389}
1390
John Reck67b1e2b2020-08-26 13:17:24 -07001391size_t SkiaGLRenderEngine::getMaxTextureSize() const {
1392 return mGrContext->maxTextureSize();
1393}
1394
1395size_t SkiaGLRenderEngine::getMaxViewportDims() const {
1396 return mGrContext->maxRenderTargetSize();
1397}
1398
Derek Sollenbergerb0e764c2021-05-04 14:31:37 -04001399void SkiaGLRenderEngine::drawShadow(SkCanvas* canvas, const SkRRect& casterRRect,
Lucas Dupin3f11e922020-09-22 17:31:04 -07001400 const ShadowSettings& settings) {
1401 ATRACE_CALL();
1402 const float casterZ = settings.length / 2.0f;
Lucas Dupin3f11e922020-09-22 17:31:04 -07001403 const auto flags =
1404 settings.casterIsTranslucent ? kTransparentOccluder_ShadowFlag : kNone_ShadowFlag;
1405
Derek Sollenbergerb0e764c2021-05-04 14:31:37 -04001406 SkShadowUtils::DrawShadow(canvas, SkPath::RRect(casterRRect), SkPoint3::Make(0, 0, casterZ),
Lucas Dupin3f11e922020-09-22 17:31:04 -07001407 getSkPoint3(settings.lightPos), settings.lightRadius,
1408 getSkColor(settings.ambientColor), getSkColor(settings.spotColor),
1409 flags);
1410}
1411
John Reck67b1e2b2020-08-26 13:17:24 -07001412EGLContext SkiaGLRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,
Alec Mourid6f09462020-12-07 11:18:17 -08001413 EGLContext shareContext,
1414 std::optional<ContextPriority> contextPriority,
John Reck67b1e2b2020-08-26 13:17:24 -07001415 Protection protection) {
1416 EGLint renderableType = 0;
1417 if (config == EGL_NO_CONFIG_KHR) {
1418 renderableType = EGL_OPENGL_ES3_BIT;
1419 } else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) {
1420 LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");
1421 }
1422 EGLint contextClientVersion = 0;
1423 if (renderableType & EGL_OPENGL_ES3_BIT) {
1424 contextClientVersion = 3;
1425 } else if (renderableType & EGL_OPENGL_ES2_BIT) {
1426 contextClientVersion = 2;
1427 } else if (renderableType & EGL_OPENGL_ES_BIT) {
1428 contextClientVersion = 1;
1429 } else {
1430 LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs");
1431 }
1432
1433 std::vector<EGLint> contextAttributes;
1434 contextAttributes.reserve(7);
1435 contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
1436 contextAttributes.push_back(contextClientVersion);
Alec Mourid6f09462020-12-07 11:18:17 -08001437 if (contextPriority) {
John Reck67b1e2b2020-08-26 13:17:24 -07001438 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG);
Alec Mourid6f09462020-12-07 11:18:17 -08001439 switch (*contextPriority) {
1440 case ContextPriority::REALTIME:
1441 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_REALTIME_NV);
1442 break;
1443 case ContextPriority::MEDIUM:
1444 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_MEDIUM_IMG);
1445 break;
1446 case ContextPriority::LOW:
1447 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LOW_IMG);
1448 break;
1449 case ContextPriority::HIGH:
1450 default:
1451 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG);
1452 break;
1453 }
John Reck67b1e2b2020-08-26 13:17:24 -07001454 }
1455 if (protection == Protection::PROTECTED) {
1456 contextAttributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1457 contextAttributes.push_back(EGL_TRUE);
1458 }
1459 contextAttributes.push_back(EGL_NONE);
1460
1461 EGLContext context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1462
1463 if (contextClientVersion == 3 && context == EGL_NO_CONTEXT) {
1464 // eglGetConfigAttrib indicated we can create GLES 3 context, but we failed, thus
1465 // EGL_NO_CONTEXT so that we can abort.
1466 if (config != EGL_NO_CONFIG_KHR) {
1467 return context;
1468 }
1469 // If |config| is EGL_NO_CONFIG_KHR, we speculatively try to create GLES 3 context, so we
1470 // should try to fall back to GLES 2.
1471 contextAttributes[1] = 2;
1472 context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1473 }
1474
1475 return context;
1476}
1477
Alec Mourid6f09462020-12-07 11:18:17 -08001478std::optional<RenderEngine::ContextPriority> SkiaGLRenderEngine::createContextPriority(
1479 const RenderEngineCreationArgs& args) {
1480 if (!gl::GLExtensions::getInstance().hasContextPriority()) {
1481 return std::nullopt;
1482 }
1483
1484 switch (args.contextPriority) {
1485 case RenderEngine::ContextPriority::REALTIME:
1486 if (gl::GLExtensions::getInstance().hasRealtimePriority()) {
1487 return RenderEngine::ContextPriority::REALTIME;
1488 } else {
1489 ALOGI("Realtime priority unsupported, degrading gracefully to high priority");
1490 return RenderEngine::ContextPriority::HIGH;
1491 }
1492 case RenderEngine::ContextPriority::HIGH:
1493 case RenderEngine::ContextPriority::MEDIUM:
1494 case RenderEngine::ContextPriority::LOW:
1495 return args.contextPriority;
1496 default:
1497 return std::nullopt;
1498 }
1499}
1500
John Reck67b1e2b2020-08-26 13:17:24 -07001501EGLSurface SkiaGLRenderEngine::createPlaceholderEglPbufferSurface(EGLDisplay display,
1502 EGLConfig config, int hwcFormat,
1503 Protection protection) {
1504 EGLConfig placeholderConfig = config;
1505 if (placeholderConfig == EGL_NO_CONFIG_KHR) {
1506 placeholderConfig = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);
1507 }
1508 std::vector<EGLint> attributes;
1509 attributes.reserve(7);
1510 attributes.push_back(EGL_WIDTH);
1511 attributes.push_back(1);
1512 attributes.push_back(EGL_HEIGHT);
1513 attributes.push_back(1);
1514 if (protection == Protection::PROTECTED) {
1515 attributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1516 attributes.push_back(EGL_TRUE);
1517 }
1518 attributes.push_back(EGL_NONE);
1519
1520 return eglCreatePbufferSurface(display, placeholderConfig, attributes.data());
1521}
1522
Alec Mourid6f09462020-12-07 11:18:17 -08001523int SkiaGLRenderEngine::getContextPriority() {
1524 int value;
1525 eglQueryContext(mEGLDisplay, mEGLContext, EGL_CONTEXT_PRIORITY_LEVEL_IMG, &value);
1526 return value;
1527}
1528
Ady Abrahamed3290f2021-05-17 15:12:14 -07001529void SkiaGLRenderEngine::onActiveDisplaySizeChanged(ui::Size size) {
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -04001530 // This cache multiplier was selected based on review of cache sizes relative
1531 // to the screen resolution. Looking at the worst case memory needed by blur (~1.5x),
1532 // shadows (~1x), and general data structures (e.g. vertex buffers) we selected this as a
1533 // conservative default based on that analysis.
1534 const float SURFACE_SIZE_MULTIPLIER = 3.5f * bytesPerPixel(mDefaultPixelFormat);
1535 const int maxResourceBytes = size.width * size.height * SURFACE_SIZE_MULTIPLIER;
1536
1537 // start by resizing the current context
Derek Sollenbergerb24258c2021-05-04 13:47:34 -04001538 getActiveGrContext()->setResourceCacheLimit(maxResourceBytes);
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -04001539
1540 // if it is possible to switch contexts then we will resize the other context
Derek Sollenberger1ec2fb52021-06-16 15:11:27 -04001541 const bool originalProtectedState = mInProtectedContext;
1542 useProtectedContext(!mInProtectedContext);
1543 if (mInProtectedContext != originalProtectedState) {
Derek Sollenbergerb24258c2021-05-04 13:47:34 -04001544 getActiveGrContext()->setResourceCacheLimit(maxResourceBytes);
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -04001545 // reset back to the initial context that was active when this method was called
Derek Sollenberger1ec2fb52021-06-16 15:11:27 -04001546 useProtectedContext(originalProtectedState);
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -04001547 }
1548}
1549
Ana Krulec1d12b3b2021-01-27 16:49:51 -08001550void SkiaGLRenderEngine::dump(std::string& result) {
1551 const gl::GLExtensions& extensions = gl::GLExtensions::getInstance();
1552
1553 StringAppendF(&result, "\n ------------RE-----------------\n");
1554 StringAppendF(&result, "EGL implementation : %s\n", extensions.getEGLVersion());
1555 StringAppendF(&result, "%s\n", extensions.getEGLExtensions());
1556 StringAppendF(&result, "GLES: %s, %s, %s\n", extensions.getVendor(), extensions.getRenderer(),
1557 extensions.getVersion());
1558 StringAppendF(&result, "%s\n", extensions.getExtensions());
1559 StringAppendF(&result, "RenderEngine supports protected context: %d\n",
1560 supportsProtectedContent());
1561 StringAppendF(&result, "RenderEngine is in protected context: %d\n", mInProtectedContext);
Leon Scroggins III9f3072c2021-03-22 10:42:47 -04001562 StringAppendF(&result, "RenderEngine shaders cached since last dump/primeCache: %d\n",
1563 mSkSLCacheMonitor.shadersCachedSinceLastCall());
Ana Krulec1d12b3b2021-01-27 16:49:51 -08001564
Derek Sollenberger0e6d3562021-04-07 19:34:39 -04001565 std::vector<ResourcePair> cpuResourceMap = {
1566 {"skia/sk_resource_cache/bitmap_", "Bitmaps"},
1567 {"skia/sk_resource_cache/rrect-blur_", "Masks"},
1568 {"skia/sk_resource_cache/rects-blur_", "Masks"},
1569 {"skia/sk_resource_cache/tessellated", "Shadows"},
1570 {"skia", "Other"},
1571 };
1572 SkiaMemoryReporter cpuReporter(cpuResourceMap, false);
1573 SkGraphics::DumpMemoryStatistics(&cpuReporter);
1574 StringAppendF(&result, "Skia CPU Caches: ");
1575 cpuReporter.logTotals(result);
1576 cpuReporter.logOutput(result);
1577
Ana Krulec1d12b3b2021-01-27 16:49:51 -08001578 {
1579 std::lock_guard<std::mutex> lock(mRenderingMutex);
Derek Sollenberger0e6d3562021-04-07 19:34:39 -04001580
1581 std::vector<ResourcePair> gpuResourceMap = {
1582 {"texture_renderbuffer", "Texture/RenderBuffer"},
1583 {"texture", "Texture"},
1584 {"gr_text_blob_cache", "Text"},
1585 {"skia", "Other"},
1586 };
1587 SkiaMemoryReporter gpuReporter(gpuResourceMap, true);
1588 mGrContext->dumpMemoryStatistics(&gpuReporter);
1589 StringAppendF(&result, "Skia's GPU Caches: ");
1590 gpuReporter.logTotals(result);
1591 gpuReporter.logOutput(result);
1592 StringAppendF(&result, "Skia's Wrapped Objects:\n");
1593 gpuReporter.logOutput(result, true);
1594
Alec Mouria90a5702021-04-16 16:36:21 +00001595 StringAppendF(&result, "RenderEngine tracked buffers: %zu\n",
1596 mGraphicBufferExternalRefs.size());
1597 StringAppendF(&result, "Dumping buffer ids...\n");
1598 for (const auto& [id, refCounts] : mGraphicBufferExternalRefs) {
1599 StringAppendF(&result, "- 0x%" PRIx64 " - %d refs \n", id, refCounts);
1600 }
Derek Sollenberger0e6d3562021-04-07 19:34:39 -04001601 StringAppendF(&result, "RenderEngine AHB/BackendTexture cache size: %zu\n",
1602 mTextureCache.size());
Ana Krulec1d12b3b2021-01-27 16:49:51 -08001603 StringAppendF(&result, "Dumping buffer ids...\n");
1604 // TODO(178539829): It would be nice to know which layer these are coming from and what
1605 // the texture sizes are.
1606 for (const auto& [id, unused] : mTextureCache) {
1607 StringAppendF(&result, "- 0x%" PRIx64 "\n", id);
1608 }
1609 StringAppendF(&result, "\n");
Derek Sollenberger0e6d3562021-04-07 19:34:39 -04001610
1611 SkiaMemoryReporter gpuProtectedReporter(gpuResourceMap, true);
Derek Sollenberger80a7a762021-04-14 10:22:58 -04001612 if (mProtectedGrContext) {
1613 mProtectedGrContext->dumpMemoryStatistics(&gpuProtectedReporter);
1614 }
Derek Sollenberger0e6d3562021-04-07 19:34:39 -04001615 StringAppendF(&result, "Skia's GPU Protected Caches: ");
1616 gpuProtectedReporter.logTotals(result);
1617 gpuProtectedReporter.logOutput(result);
1618 StringAppendF(&result, "Skia's Protected Wrapped Objects:\n");
1619 gpuProtectedReporter.logOutput(result, true);
1620
Ana Krulec1d12b3b2021-01-27 16:49:51 -08001621 StringAppendF(&result, "\n");
1622 StringAppendF(&result, "RenderEngine runtime effects: %zu\n", mRuntimeEffects.size());
1623 for (const auto& [linearEffect, unused] : mRuntimeEffects) {
1624 StringAppendF(&result, "- inputDataspace: %s\n",
1625 dataspaceDetails(
1626 static_cast<android_dataspace>(linearEffect.inputDataspace))
1627 .c_str());
1628 StringAppendF(&result, "- outputDataspace: %s\n",
1629 dataspaceDetails(
1630 static_cast<android_dataspace>(linearEffect.outputDataspace))
1631 .c_str());
1632 StringAppendF(&result, "undoPremultipliedAlpha: %s\n",
1633 linearEffect.undoPremultipliedAlpha ? "true" : "false");
1634 }
1635 }
1636 StringAppendF(&result, "\n");
1637}
1638
John Reck67b1e2b2020-08-26 13:17:24 -07001639} // namespace skia
1640} // namespace renderengine
Galia Peycheva6c460652020-11-03 19:42:42 +01001641} // namespace android