blob: 6cc3d37abad2fde65f65d69a8bfc70da8103e85a [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 Mouri4ce5ec02021-01-07 17:33:21 -080039#include <sync/sync.h>
40#include <ui/BlurRegion.h>
Ana Krulec1d12b3b2021-01-27 16:49:51 -080041#include <ui/DebugUtils.h>
Alec Mouri4ce5ec02021-01-07 17:33:21 -080042#include <ui/GraphicBuffer.h>
43#include <utils/Trace.h>
Alec Mourib5777452020-09-28 11:32:42 -070044
45#include <cmath>
Alec Mouri4ce5ec02021-01-07 17:33:21 -080046#include <cstdint>
47#include <memory>
48
49#include "../gl/GLExtensions.h"
Derek Sollenberger0e6d3562021-04-07 19:34:39 -040050#include "Cache.h"
Alec Mouric0aae732021-01-12 13:32:18 -080051#include "ColorSpaces.h"
Alec Mouri4ce5ec02021-01-07 17:33:21 -080052#include "SkBlendMode.h"
53#include "SkImageInfo.h"
54#include "filters/BlurFilter.h"
55#include "filters/LinearEffect.h"
56#include "log/log_main.h"
57#include "skia/debug/SkiaCapture.h"
Derek Sollenberger0e6d3562021-04-07 19:34:39 -040058#include "skia/debug/SkiaMemoryReporter.h"
Nader Jawad2dfc98b2021-04-08 20:35:39 -070059#include "skia/filters/StretchShaderFactory.h"
Alec Mouri4ce5ec02021-01-07 17:33:21 -080060#include "system/graphics-base-v1.0.h"
Alec Mourib5777452020-09-28 11:32:42 -070061
Nathaniel Nifongb9f27ef2021-04-01 16:44:12 -040062namespace {
63// Debugging settings
64static const bool kPrintLayerSettings = false;
65static const bool kFlushAfterEveryLayer = false;
66} // namespace
67
John Reck67b1e2b2020-08-26 13:17:24 -070068bool checkGlError(const char* op, int lineNumber);
69
70namespace android {
71namespace renderengine {
72namespace skia {
73
Ana Krulec1d12b3b2021-01-27 16:49:51 -080074using base::StringAppendF;
75
John Reck67b1e2b2020-08-26 13:17:24 -070076static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs, EGLint attribute,
77 EGLint wanted, EGLConfig* outConfig) {
78 EGLint numConfigs = -1, n = 0;
79 eglGetConfigs(dpy, nullptr, 0, &numConfigs);
80 std::vector<EGLConfig> configs(numConfigs, EGL_NO_CONFIG_KHR);
81 eglChooseConfig(dpy, attrs, configs.data(), configs.size(), &n);
82 configs.resize(n);
83
84 if (!configs.empty()) {
85 if (attribute != EGL_NONE) {
86 for (EGLConfig config : configs) {
87 EGLint value = 0;
88 eglGetConfigAttrib(dpy, config, attribute, &value);
89 if (wanted == value) {
90 *outConfig = config;
91 return NO_ERROR;
92 }
93 }
94 } else {
95 // just pick the first one
96 *outConfig = configs[0];
97 return NO_ERROR;
98 }
99 }
100
101 return NAME_NOT_FOUND;
102}
103
104static status_t selectEGLConfig(EGLDisplay display, EGLint format, EGLint renderableType,
105 EGLConfig* config) {
106 // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if
107 // it is to be used with WIFI displays
108 status_t err;
109 EGLint wantedAttribute;
110 EGLint wantedAttributeValue;
111
112 std::vector<EGLint> attribs;
113 if (renderableType) {
114 const ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(format);
115 const bool is1010102 = pixelFormat == ui::PixelFormat::RGBA_1010102;
116
117 // Default to 8 bits per channel.
118 const EGLint tmpAttribs[] = {
119 EGL_RENDERABLE_TYPE,
120 renderableType,
121 EGL_RECORDABLE_ANDROID,
122 EGL_TRUE,
123 EGL_SURFACE_TYPE,
124 EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
125 EGL_FRAMEBUFFER_TARGET_ANDROID,
126 EGL_TRUE,
127 EGL_RED_SIZE,
128 is1010102 ? 10 : 8,
129 EGL_GREEN_SIZE,
130 is1010102 ? 10 : 8,
131 EGL_BLUE_SIZE,
132 is1010102 ? 10 : 8,
133 EGL_ALPHA_SIZE,
134 is1010102 ? 2 : 8,
135 EGL_NONE,
136 };
137 std::copy(tmpAttribs, tmpAttribs + (sizeof(tmpAttribs) / sizeof(EGLint)),
138 std::back_inserter(attribs));
139 wantedAttribute = EGL_NONE;
140 wantedAttributeValue = EGL_NONE;
141 } else {
142 // if no renderable type specified, fallback to a simplified query
143 wantedAttribute = EGL_NATIVE_VISUAL_ID;
144 wantedAttributeValue = format;
145 }
146
147 err = selectConfigForAttribute(display, attribs.data(), wantedAttribute, wantedAttributeValue,
148 config);
149 if (err == NO_ERROR) {
150 EGLint caveat;
151 if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat))
152 ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!");
153 }
154
155 return err;
156}
157
158std::unique_ptr<SkiaGLRenderEngine> SkiaGLRenderEngine::create(
159 const RenderEngineCreationArgs& args) {
160 // initialize EGL for the default display
161 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
162 if (!eglInitialize(display, nullptr, nullptr)) {
163 LOG_ALWAYS_FATAL("failed to initialize EGL");
164 }
165
Yiwei Zhange2650962020-12-01 23:27:58 +0000166 const auto eglVersion = eglQueryString(display, EGL_VERSION);
John Reck67b1e2b2020-08-26 13:17:24 -0700167 if (!eglVersion) {
168 checkGlError(__FUNCTION__, __LINE__);
Yiwei Zhange2650962020-12-01 23:27:58 +0000169 LOG_ALWAYS_FATAL("eglQueryString(EGL_VERSION) failed");
John Reck67b1e2b2020-08-26 13:17:24 -0700170 }
171
Yiwei Zhange2650962020-12-01 23:27:58 +0000172 const auto eglExtensions = eglQueryString(display, EGL_EXTENSIONS);
John Reck67b1e2b2020-08-26 13:17:24 -0700173 if (!eglExtensions) {
174 checkGlError(__FUNCTION__, __LINE__);
Yiwei Zhange2650962020-12-01 23:27:58 +0000175 LOG_ALWAYS_FATAL("eglQueryString(EGL_EXTENSIONS) failed");
John Reck67b1e2b2020-08-26 13:17:24 -0700176 }
177
178 auto& extensions = gl::GLExtensions::getInstance();
179 extensions.initWithEGLStrings(eglVersion, eglExtensions);
180
181 // The code assumes that ES2 or later is available if this extension is
182 // supported.
183 EGLConfig config = EGL_NO_CONFIG_KHR;
184 if (!extensions.hasNoConfigContext()) {
185 config = chooseEglConfig(display, args.pixelFormat, /*logConfig*/ true);
186 }
187
John Reck67b1e2b2020-08-26 13:17:24 -0700188 EGLContext protectedContext = EGL_NO_CONTEXT;
Alec Mourid6f09462020-12-07 11:18:17 -0800189 const std::optional<RenderEngine::ContextPriority> priority = createContextPriority(args);
John Reck67b1e2b2020-08-26 13:17:24 -0700190 if (args.enableProtectedContext && extensions.hasProtectedContent()) {
Alec Mourid6f09462020-12-07 11:18:17 -0800191 protectedContext =
192 createEglContext(display, config, nullptr, priority, Protection::PROTECTED);
John Reck67b1e2b2020-08-26 13:17:24 -0700193 ALOGE_IF(protectedContext == EGL_NO_CONTEXT, "Can't create protected context");
194 }
195
Alec Mourid6f09462020-12-07 11:18:17 -0800196 EGLContext ctxt =
197 createEglContext(display, config, protectedContext, priority, Protection::UNPROTECTED);
John Reck67b1e2b2020-08-26 13:17:24 -0700198
199 // if can't create a GL context, we can only abort.
200 LOG_ALWAYS_FATAL_IF(ctxt == EGL_NO_CONTEXT, "EGLContext creation failed");
201
202 EGLSurface placeholder = EGL_NO_SURFACE;
203 if (!extensions.hasSurfacelessContext()) {
204 placeholder = createPlaceholderEglPbufferSurface(display, config, args.pixelFormat,
205 Protection::UNPROTECTED);
206 LOG_ALWAYS_FATAL_IF(placeholder == EGL_NO_SURFACE, "can't create placeholder pbuffer");
207 }
208 EGLBoolean success = eglMakeCurrent(display, placeholder, placeholder, ctxt);
209 LOG_ALWAYS_FATAL_IF(!success, "can't make placeholder pbuffer current");
210 extensions.initWithGLStrings(glGetString(GL_VENDOR), glGetString(GL_RENDERER),
211 glGetString(GL_VERSION), glGetString(GL_EXTENSIONS));
212
213 EGLSurface protectedPlaceholder = EGL_NO_SURFACE;
214 if (protectedContext != EGL_NO_CONTEXT && !extensions.hasSurfacelessContext()) {
215 protectedPlaceholder = createPlaceholderEglPbufferSurface(display, config, args.pixelFormat,
216 Protection::PROTECTED);
217 ALOGE_IF(protectedPlaceholder == EGL_NO_SURFACE,
218 "can't create protected placeholder pbuffer");
219 }
220
221 // initialize the renderer while GL is current
222 std::unique_ptr<SkiaGLRenderEngine> engine =
Lucas Dupind508e472020-11-04 04:32:06 +0000223 std::make_unique<SkiaGLRenderEngine>(args, display, ctxt, placeholder, protectedContext,
224 protectedPlaceholder);
John Reck67b1e2b2020-08-26 13:17:24 -0700225
226 ALOGI("OpenGL ES informations:");
227 ALOGI("vendor : %s", extensions.getVendor());
228 ALOGI("renderer : %s", extensions.getRenderer());
229 ALOGI("version : %s", extensions.getVersion());
230 ALOGI("extensions: %s", extensions.getExtensions());
231 ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize());
232 ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims());
233
234 return engine;
235}
236
Leon Scroggins IIIb9216dc2021-03-08 17:19:01 -0500237void SkiaGLRenderEngine::primeCache() {
238 Cache::primeShaderCache(this);
239}
240
John Reck67b1e2b2020-08-26 13:17:24 -0700241EGLConfig SkiaGLRenderEngine::chooseEglConfig(EGLDisplay display, int format, bool logConfig) {
242 status_t err;
243 EGLConfig config;
244
245 // First try to get an ES3 config
246 err = selectEGLConfig(display, format, EGL_OPENGL_ES3_BIT, &config);
247 if (err != NO_ERROR) {
248 // If ES3 fails, try to get an ES2 config
249 err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);
250 if (err != NO_ERROR) {
251 // If ES2 still doesn't work, probably because we're on the emulator.
252 // try a simplified query
253 ALOGW("no suitable EGLConfig found, trying a simpler query");
254 err = selectEGLConfig(display, format, 0, &config);
255 if (err != NO_ERROR) {
256 // this EGL is too lame for android
257 LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up");
258 }
259 }
260 }
261
262 if (logConfig) {
263 // print some debugging info
264 EGLint r, g, b, a;
265 eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r);
266 eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
267 eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);
268 eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);
269 ALOGI("EGL information:");
270 ALOGI("vendor : %s", eglQueryString(display, EGL_VENDOR));
271 ALOGI("version : %s", eglQueryString(display, EGL_VERSION));
272 ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS));
273 ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS) ?: "Not Supported");
274 ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);
275 }
276
277 return config;
278}
279
Leon Scroggins III9f3072c2021-03-22 10:42:47 -0400280sk_sp<SkData> SkiaGLRenderEngine::SkSLCacheMonitor::load(const SkData& key) {
281 // This "cache" does not actually cache anything. It just allows us to
282 // monitor Skia's internal cache. So this method always returns null.
283 return nullptr;
284}
285
286void SkiaGLRenderEngine::SkSLCacheMonitor::store(const SkData& key, const SkData& data,
287 const SkString& description) {
288 mShadersCachedSinceLastCall++;
289}
290
291void SkiaGLRenderEngine::assertShadersCompiled(int numShaders) {
292 const int cached = mSkSLCacheMonitor.shadersCachedSinceLastCall();
293 LOG_ALWAYS_FATAL_IF(cached != numShaders, "Attempted to cache %i shaders; cached %i",
294 numShaders, cached);
295}
296
Nathaniel Nifongb9f27ef2021-04-01 16:44:12 -0400297int SkiaGLRenderEngine::reportShadersCompiled() {
298 return mSkSLCacheMonitor.shadersCachedSinceLastCall();
299}
300
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700301SkiaGLRenderEngine::SkiaGLRenderEngine(const RenderEngineCreationArgs& args, EGLDisplay display,
Lucas Dupind508e472020-11-04 04:32:06 +0000302 EGLContext ctxt, EGLSurface placeholder,
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700303 EGLContext protectedContext, EGLSurface protectedPlaceholder)
Alec Mouri0d995102021-02-24 16:53:38 -0800304 : SkiaRenderEngine(args.renderEngineType),
305 mEGLDisplay(display),
John Reck67b1e2b2020-08-26 13:17:24 -0700306 mEGLContext(ctxt),
307 mPlaceholderSurface(placeholder),
308 mProtectedEGLContext(protectedContext),
Alec Mourib5777452020-09-28 11:32:42 -0700309 mProtectedPlaceholderSurface(protectedPlaceholder),
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -0400310 mDefaultPixelFormat(static_cast<PixelFormat>(args.pixelFormat)),
Alec Mouri0d995102021-02-24 16:53:38 -0800311 mUseColorManagement(args.useColorManagement) {
John Reck67b1e2b2020-08-26 13:17:24 -0700312 sk_sp<const GrGLInterface> glInterface(GrGLCreateNativeInterface());
313 LOG_ALWAYS_FATAL_IF(!glInterface.get());
314
315 GrContextOptions options;
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -0400316 options.fDisableDriverCorrectnessWorkarounds = true;
John Reck67b1e2b2020-08-26 13:17:24 -0700317 options.fDisableDistanceFieldPaths = true;
Leon Scroggins III9f3072c2021-03-22 10:42:47 -0400318 options.fPersistentCache = &mSkSLCacheMonitor;
Lucas Dupind508e472020-11-04 04:32:06 +0000319 mGrContext = GrDirectContext::MakeGL(glInterface, options);
320 if (useProtectedContext(true)) {
321 mProtectedGrContext = GrDirectContext::MakeGL(glInterface, options);
322 useProtectedContext(false);
323 }
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700324
325 if (args.supportsBackgroundBlur) {
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500326 ALOGD("Background Blurs Enabled");
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700327 mBlurFilter = new BlurFilter();
328 }
Alec Mouric0aae732021-01-12 13:32:18 -0800329 mCapture = std::make_unique<SkiaCapture>();
330}
331
332SkiaGLRenderEngine::~SkiaGLRenderEngine() {
Marin Shalamanovcea12ef2021-03-15 17:00:51 +0100333 std::lock_guard<std::mutex> lock(mRenderingMutex);
Alec Mouric0aae732021-01-12 13:32:18 -0800334 if (mBlurFilter) {
335 delete mBlurFilter;
336 }
337
338 mCapture = nullptr;
339
340 mGrContext->flushAndSubmit(true);
341 mGrContext->abandonContext();
342
343 if (mProtectedGrContext) {
344 mProtectedGrContext->flushAndSubmit(true);
345 mProtectedGrContext->abandonContext();
346 }
347
348 if (mPlaceholderSurface != EGL_NO_SURFACE) {
349 eglDestroySurface(mEGLDisplay, mPlaceholderSurface);
350 }
351 if (mProtectedPlaceholderSurface != EGL_NO_SURFACE) {
352 eglDestroySurface(mEGLDisplay, mProtectedPlaceholderSurface);
353 }
354 if (mEGLContext != EGL_NO_CONTEXT) {
355 eglDestroyContext(mEGLDisplay, mEGLContext);
356 }
357 if (mProtectedEGLContext != EGL_NO_CONTEXT) {
358 eglDestroyContext(mEGLDisplay, mProtectedEGLContext);
359 }
360 eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
361 eglTerminate(mEGLDisplay);
362 eglReleaseThread();
John Reck67b1e2b2020-08-26 13:17:24 -0700363}
364
Lucas Dupind508e472020-11-04 04:32:06 +0000365bool SkiaGLRenderEngine::supportsProtectedContent() const {
366 return mProtectedEGLContext != EGL_NO_CONTEXT;
367}
368
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400369GrDirectContext* SkiaGLRenderEngine::getActiveGrContext() const {
370 return mInProtectedContext ? mProtectedGrContext.get() : mGrContext.get();
371}
372
Lucas Dupind508e472020-11-04 04:32:06 +0000373bool SkiaGLRenderEngine::useProtectedContext(bool useProtectedContext) {
374 if (useProtectedContext == mInProtectedContext) {
375 return true;
376 }
Alec Mourif6a07812021-02-11 21:07:55 -0800377 if (useProtectedContext && !supportsProtectedContent()) {
Lucas Dupind508e472020-11-04 04:32:06 +0000378 return false;
379 }
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400380
381 // release any scratch resources before switching into a new mode
382 if (getActiveGrContext()) {
383 getActiveGrContext()->purgeUnlockedResources(true);
384 }
385
Lucas Dupind508e472020-11-04 04:32:06 +0000386 const EGLSurface surface =
387 useProtectedContext ? mProtectedPlaceholderSurface : mPlaceholderSurface;
388 const EGLContext context = useProtectedContext ? mProtectedEGLContext : mEGLContext;
389 const bool success = eglMakeCurrent(mEGLDisplay, surface, surface, context) == EGL_TRUE;
Alec Mouric0aae732021-01-12 13:32:18 -0800390
Lucas Dupind508e472020-11-04 04:32:06 +0000391 if (success) {
392 mInProtectedContext = useProtectedContext;
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400393 // given that we are sharing the same thread between two GrContexts we need to
394 // make sure that the thread state is reset when switching between the two.
395 if (getActiveGrContext()) {
396 getActiveGrContext()->resetContext();
397 }
Lucas Dupind508e472020-11-04 04:32:06 +0000398 }
399 return success;
400}
401
John Reck67b1e2b2020-08-26 13:17:24 -0700402base::unique_fd SkiaGLRenderEngine::flush() {
403 ATRACE_CALL();
404 if (!gl::GLExtensions::getInstance().hasNativeFenceSync()) {
405 return base::unique_fd();
406 }
407
408 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
409 if (sync == EGL_NO_SYNC_KHR) {
410 ALOGW("failed to create EGL native fence sync: %#x", eglGetError());
411 return base::unique_fd();
412 }
413
414 // native fence fd will not be populated until flush() is done.
415 glFlush();
416
417 // get the fence fd
418 base::unique_fd fenceFd(eglDupNativeFenceFDANDROID(mEGLDisplay, sync));
419 eglDestroySyncKHR(mEGLDisplay, sync);
420 if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
421 ALOGW("failed to dup EGL native fence sync: %#x", eglGetError());
422 }
423
424 return fenceFd;
425}
426
427bool SkiaGLRenderEngine::waitFence(base::unique_fd fenceFd) {
428 if (!gl::GLExtensions::getInstance().hasNativeFenceSync() ||
429 !gl::GLExtensions::getInstance().hasWaitSync()) {
430 return false;
431 }
432
433 // release the fd and transfer the ownership to EGLSync
434 EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceFd.release(), EGL_NONE};
435 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
436 if (sync == EGL_NO_SYNC_KHR) {
437 ALOGE("failed to create EGL native fence sync: %#x", eglGetError());
438 return false;
439 }
440
441 // XXX: The spec draft is inconsistent as to whether this should return an
442 // EGLint or void. Ignore the return value for now, as it's not strictly
443 // needed.
444 eglWaitSyncKHR(mEGLDisplay, sync, 0);
445 EGLint error = eglGetError();
446 eglDestroySyncKHR(mEGLDisplay, sync);
447 if (error != EGL_SUCCESS) {
448 ALOGE("failed to wait for EGL native fence sync: %#x", error);
449 return false;
450 }
451
452 return true;
453}
454
Alec Mouri678245d2020-09-30 16:58:23 -0700455static float toDegrees(uint32_t transform) {
456 switch (transform) {
457 case ui::Transform::ROT_90:
458 return 90.0;
459 case ui::Transform::ROT_180:
460 return 180.0;
461 case ui::Transform::ROT_270:
462 return 270.0;
463 default:
464 return 0.0;
465 }
466}
467
Alec Mourib34f0b72020-10-02 13:18:34 -0700468static SkColorMatrix toSkColorMatrix(const mat4& matrix) {
469 return SkColorMatrix(matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0], 0, matrix[0][1],
470 matrix[1][1], matrix[2][1], matrix[3][1], 0, matrix[0][2], matrix[1][2],
471 matrix[2][2], matrix[3][2], 0, matrix[0][3], matrix[1][3], matrix[2][3],
472 matrix[3][3], 0);
473}
474
Alec Mouri029d1952020-10-12 10:37:08 -0700475static bool needsToneMapping(ui::Dataspace sourceDataspace, ui::Dataspace destinationDataspace) {
476 int64_t sourceTransfer = sourceDataspace & HAL_DATASPACE_TRANSFER_MASK;
477 int64_t destTransfer = destinationDataspace & HAL_DATASPACE_TRANSFER_MASK;
478
479 // Treat unsupported dataspaces as srgb
480 if (destTransfer != HAL_DATASPACE_TRANSFER_LINEAR &&
481 destTransfer != HAL_DATASPACE_TRANSFER_HLG &&
482 destTransfer != HAL_DATASPACE_TRANSFER_ST2084) {
483 destTransfer = HAL_DATASPACE_TRANSFER_SRGB;
484 }
485
486 if (sourceTransfer != HAL_DATASPACE_TRANSFER_LINEAR &&
487 sourceTransfer != HAL_DATASPACE_TRANSFER_HLG &&
488 sourceTransfer != HAL_DATASPACE_TRANSFER_ST2084) {
489 sourceTransfer = HAL_DATASPACE_TRANSFER_SRGB;
490 }
491
492 const bool isSourceLinear = sourceTransfer == HAL_DATASPACE_TRANSFER_LINEAR;
493 const bool isSourceSRGB = sourceTransfer == HAL_DATASPACE_TRANSFER_SRGB;
494 const bool isDestLinear = destTransfer == HAL_DATASPACE_TRANSFER_LINEAR;
495 const bool isDestSRGB = destTransfer == HAL_DATASPACE_TRANSFER_SRGB;
496
497 return !(isSourceLinear && isDestSRGB) && !(isSourceSRGB && isDestLinear) &&
498 sourceTransfer != destTransfer;
499}
500
Alec Mouria90a5702021-04-16 16:36:21 +0000501void SkiaGLRenderEngine::mapExternalTextureBuffer(const sp<GraphicBuffer>& buffer,
502 bool isRenderable) {
Ana Krulecdfec8f52021-01-13 12:51:47 -0800503 // Only run this if RE is running on its own thread. This way the access to GL
504 // operations is guaranteed to be happening on the same thread.
505 if (mRenderEngineType != RenderEngineType::SKIA_GL_THREADED) {
506 return;
507 }
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400508 // we currently don't attempt to map a buffer if the buffer contains protected content
509 // because GPU resources for protected buffers is much more limited.
510 const bool isProtectedBuffer = buffer->getUsage() & GRALLOC_USAGE_PROTECTED;
511 if (isProtectedBuffer) {
512 return;
513 }
Ana Krulecdfec8f52021-01-13 12:51:47 -0800514 ATRACE_CALL();
515
Derek Sollenberger0ad873b2021-05-05 11:35:52 -0400516 // If we were to support caching protected buffers then we will need to switch the currently
517 // bound context if we are not already using the protected context (and subsequently switch
518 // back after the buffer is cached).
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400519 auto grContext = getActiveGrContext();
Derek Sollenbergereb904d42021-03-22 12:58:53 -0400520 auto& cache = mInProtectedContext ? mProtectedTextureCache : mTextureCache;
521
522 std::lock_guard<std::mutex> lock(mRenderingMutex);
Alec Mouria90a5702021-04-16 16:36:21 +0000523 mGraphicBufferExternalRefs[buffer->getId()]++;
524
525 if (const auto& iter = cache.find(buffer->getId()); iter == cache.end()) {
Ana Krulecdfec8f52021-01-13 12:51:47 -0800526 std::shared_ptr<AutoBackendTexture::LocalRef> imageTextureRef =
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400527 std::make_shared<AutoBackendTexture::LocalRef>(grContext,
Derek Sollenbergerd8fdae32021-04-09 13:52:59 -0400528 buffer->toAHardwareBuffer(),
529 isRenderable);
Derek Sollenbergereb904d42021-03-22 12:58:53 -0400530 cache.insert({buffer->getId(), imageTextureRef});
Ana Krulecdfec8f52021-01-13 12:51:47 -0800531 }
532}
533
Alec Mouria90a5702021-04-16 16:36:21 +0000534void SkiaGLRenderEngine::unmapExternalTextureBuffer(const sp<GraphicBuffer>& buffer) {
Ana Krulecdfec8f52021-01-13 12:51:47 -0800535 ATRACE_CALL();
John Reck67b1e2b2020-08-26 13:17:24 -0700536 std::lock_guard<std::mutex> lock(mRenderingMutex);
Alec Mouria90a5702021-04-16 16:36:21 +0000537 if (const auto& iter = mGraphicBufferExternalRefs.find(buffer->getId());
538 iter != mGraphicBufferExternalRefs.end()) {
539 if (iter->second == 0) {
540 ALOGW("Attempted to unmap GraphicBuffer <id: %" PRId64
541 "> from RenderEngine texture, but the "
542 "ref count was already zero!",
543 buffer->getId());
544 mGraphicBufferExternalRefs.erase(buffer->getId());
545 return;
546 }
547
548 iter->second--;
549
550 if (iter->second == 0) {
551 mTextureCache.erase(buffer->getId());
552 mProtectedTextureCache.erase(buffer->getId());
553 mGraphicBufferExternalRefs.erase(buffer->getId());
554 }
555 }
John Reck67b1e2b2020-08-26 13:17:24 -0700556}
557
Nader Jawad2dfc98b2021-04-08 20:35:39 -0700558sk_sp<SkShader> SkiaGLRenderEngine::createRuntimeEffectShader(
559 sk_sp<SkShader> shader,
560 const LayerSettings* layer, const DisplaySettings& display, bool undoPremultipliedAlpha,
561 bool requiresLinearEffect) {
562 const auto stretchEffect = layer->stretchEffect;
Nader Jawad63644d32021-05-07 10:44:21 -0700563 // The given surface will be stretched by HWUI via matrix transformation
564 // which gets similar results for most surfaces
565 // Determine later on if we need to leverage the stertch shader within
566 // surface flinger
Nader Jawadc088bdc2021-05-10 13:24:46 -0700567 if (stretchEffect.hasEffect()) {
Nader Jawad2dfc98b2021-04-08 20:35:39 -0700568 const auto targetBuffer = layer->source.buffer.buffer;
Nader Jawadc088bdc2021-05-10 13:24:46 -0700569 const auto graphicBuffer = targetBuffer ? targetBuffer->getBuffer() : nullptr;
570 if (graphicBuffer && shader) {
Nader Jawad2dfc98b2021-04-08 20:35:39 -0700571 shader = mStretchShaderFactory.createSkShader(shader, stretchEffect);
572 }
John Reckcdb4ed72021-02-04 13:39:33 -0500573 }
Nader Jawad2dfc98b2021-04-08 20:35:39 -0700574
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500575 if (requiresLinearEffect) {
576 const ui::Dataspace inputDataspace =
577 mUseColorManagement ? layer->sourceDataspace : ui::Dataspace::UNKNOWN;
578 const ui::Dataspace outputDataspace =
579 mUseColorManagement ? display.outputDataspace : ui::Dataspace::UNKNOWN;
580
581 LinearEffect effect = LinearEffect{.inputDataspace = inputDataspace,
582 .outputDataspace = outputDataspace,
Ana Krulec47814212021-01-06 19:00:10 -0800583 .undoPremultipliedAlpha = undoPremultipliedAlpha};
584
585 auto effectIter = mRuntimeEffects.find(effect);
586 sk_sp<SkRuntimeEffect> runtimeEffect = nullptr;
587 if (effectIter == mRuntimeEffects.end()) {
588 runtimeEffect = buildRuntimeEffect(effect);
589 mRuntimeEffects.insert({effect, runtimeEffect});
590 } else {
591 runtimeEffect = effectIter->second;
592 }
John Reckac09e452021-04-07 16:35:37 -0400593 float maxLuminance = layer->source.buffer.maxLuminanceNits;
594 // If the buffer doesn't have a max luminance, treat it as SDR & use the display's SDR
595 // white point
596 if (maxLuminance <= 0.f) {
597 maxLuminance = display.sdrWhitePointNits;
598 }
Ana Krulec47814212021-01-06 19:00:10 -0800599 return createLinearEffectShader(shader, effect, runtimeEffect, layer->colorTransform,
John Reckac09e452021-04-07 16:35:37 -0400600 display.maxLuminance, maxLuminance);
Ana Krulec47814212021-01-06 19:00:10 -0800601 }
602 return shader;
603}
604
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500605void SkiaGLRenderEngine::initCanvas(SkCanvas* canvas, const DisplaySettings& display) {
Derek Sollenberger76664d62021-02-04 11:13:09 -0500606 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500607 // Record display settings when capture is running.
608 std::stringstream displaySettings;
609 PrintTo(display, &displaySettings);
610 // Store the DisplaySettings in additional information.
611 canvas->drawAnnotation(SkRect::MakeEmpty(), "DisplaySettings",
612 SkData::MakeWithCString(displaySettings.str().c_str()));
613 }
614
615 // Before doing any drawing, let's make sure that we'll start at the origin of the display.
616 // Some displays don't start at 0,0 for example when we're mirroring the screen. Also, virtual
617 // displays might have different scaling when compared to the physical screen.
618
619 canvas->clipRect(getSkRect(display.physicalDisplay));
620 canvas->translate(display.physicalDisplay.left, display.physicalDisplay.top);
621
622 const auto clipWidth = display.clip.width();
623 const auto clipHeight = display.clip.height();
624 auto rotatedClipWidth = clipWidth;
625 auto rotatedClipHeight = clipHeight;
626 // Scale is contingent on the rotation result.
627 if (display.orientation & ui::Transform::ROT_90) {
628 std::swap(rotatedClipWidth, rotatedClipHeight);
629 }
630 const auto scaleX = static_cast<SkScalar>(display.physicalDisplay.width()) /
631 static_cast<SkScalar>(rotatedClipWidth);
632 const auto scaleY = static_cast<SkScalar>(display.physicalDisplay.height()) /
633 static_cast<SkScalar>(rotatedClipHeight);
634 canvas->scale(scaleX, scaleY);
635
636 // Canvas rotation is done by centering the clip window at the origin, rotating, translating
637 // back so that the top left corner of the clip is at (0, 0).
638 canvas->translate(rotatedClipWidth / 2, rotatedClipHeight / 2);
639 canvas->rotate(toDegrees(display.orientation));
640 canvas->translate(-clipWidth / 2, -clipHeight / 2);
641 canvas->translate(-display.clip.left, -display.clip.top);
642}
643
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500644class AutoSaveRestore {
645public:
646 AutoSaveRestore(SkCanvas* canvas) : mCanvas(canvas) { mSaveCount = canvas->save(); }
647 ~AutoSaveRestore() { restore(); }
648 void replace(SkCanvas* canvas) {
649 mCanvas = canvas;
650 mSaveCount = canvas->save();
651 }
652 void restore() {
653 if (mCanvas) {
654 mCanvas->restoreToCount(mSaveCount);
655 mCanvas = nullptr;
656 }
657 }
658
659private:
660 SkCanvas* mCanvas;
661 int mSaveCount;
662};
663
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -0400664static SkRRect getBlurRRect(const BlurRegion& region) {
665 const auto rect = SkRect::MakeLTRB(region.left, region.top, region.right, region.bottom);
666 const SkVector radii[4] = {SkVector::Make(region.cornerRadiusTL, region.cornerRadiusTL),
667 SkVector::Make(region.cornerRadiusTR, region.cornerRadiusTR),
668 SkVector::Make(region.cornerRadiusBR, region.cornerRadiusBR),
669 SkVector::Make(region.cornerRadiusBL, region.cornerRadiusBL)};
670 SkRRect roundedRect;
671 roundedRect.setRectRadii(rect, radii);
672 return roundedRect;
673}
674
John Reck67b1e2b2020-08-26 13:17:24 -0700675status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display,
676 const std::vector<const LayerSettings*>& layers,
Alec Mouria90a5702021-04-16 16:36:21 +0000677 const std::shared_ptr<ExternalTexture>& buffer,
678 const bool /*useFramebufferCache*/,
John Reck67b1e2b2020-08-26 13:17:24 -0700679 base::unique_fd&& bufferFence, base::unique_fd* drawFence) {
680 ATRACE_NAME("SkiaGL::drawLayers");
Alec Mouric0aae732021-01-12 13:32:18 -0800681
John Reck67b1e2b2020-08-26 13:17:24 -0700682 std::lock_guard<std::mutex> lock(mRenderingMutex);
683 if (layers.empty()) {
684 ALOGV("Drawing empty layer stack");
685 return NO_ERROR;
686 }
687
688 if (bufferFence.get() >= 0) {
689 // Duplicate the fence for passing to waitFence.
690 base::unique_fd bufferFenceDup(dup(bufferFence.get()));
691 if (bufferFenceDup < 0 || !waitFence(std::move(bufferFenceDup))) {
692 ATRACE_NAME("Waiting before draw");
693 sync_wait(bufferFence.get(), -1);
694 }
695 }
696 if (buffer == nullptr) {
697 ALOGE("No output buffer provided. Aborting GPU composition.");
698 return BAD_VALUE;
699 }
700
Alec Mouria90a5702021-04-16 16:36:21 +0000701 validateOutputBufferUsage(buffer->getBuffer());
Ady Abraham193426d2021-02-18 14:01:53 -0800702
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400703 auto grContext = getActiveGrContext();
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800704 auto& cache = mInProtectedContext ? mProtectedTextureCache : mTextureCache;
John Reck67b1e2b2020-08-26 13:17:24 -0700705
Alec Mouria90a5702021-04-16 16:36:21 +0000706 std::shared_ptr<AutoBackendTexture::LocalRef> surfaceTextureRef;
707 if (const auto& it = cache.find(buffer->getBuffer()->getId()); it != cache.end()) {
708 surfaceTextureRef = it->second;
709 } else {
Derek Sollenbergerd8fdae32021-04-09 13:52:59 -0400710 surfaceTextureRef =
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400711 std::make_shared<AutoBackendTexture::LocalRef>(grContext,
712 buffer->getBuffer()
713 ->toAHardwareBuffer(),
714 true);
John Reck67b1e2b2020-08-26 13:17:24 -0700715 }
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800716
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500717 const ui::Dataspace dstDataspace =
718 mUseColorManagement ? display.outputDataspace : ui::Dataspace::UNKNOWN;
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400719 sk_sp<SkSurface> dstSurface = surfaceTextureRef->getOrCreateSurface(dstDataspace, grContext);
Alec Mouri678245d2020-09-30 16:58:23 -0700720
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500721 SkCanvas* dstCanvas = mCapture->tryCapture(dstSurface.get());
722 if (dstCanvas == nullptr) {
Ana Krulec6eab17a2020-12-09 15:52:36 -0800723 ALOGE("Cannot acquire canvas from Skia.");
724 return BAD_VALUE;
725 }
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500726
727 // Find if any layers have requested blur, we'll use that info to decide when to render to an
728 // offscreen buffer and when to render to the native buffer.
729 sk_sp<SkSurface> activeSurface(dstSurface);
730 SkCanvas* canvas = dstCanvas;
Derek Sollenberger76664d62021-02-04 11:13:09 -0500731 SkiaCapture::OffscreenState offscreenCaptureState;
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500732 const LayerSettings* blurCompositionLayer = nullptr;
733 if (mBlurFilter) {
734 bool requiresCompositionLayer = false;
735 for (const auto& layer : layers) {
Derek Sollenberger3134ec32021-02-12 11:26:23 -0500736 if (layer->backgroundBlurRadius > 0 &&
737 layer->backgroundBlurRadius < BlurFilter::kMaxCrossFadeRadius) {
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500738 requiresCompositionLayer = true;
739 }
740 for (auto region : layer->blurRegions) {
741 if (region.blurRadius < BlurFilter::kMaxCrossFadeRadius) {
742 requiresCompositionLayer = true;
743 }
744 }
745 if (requiresCompositionLayer) {
746 activeSurface = dstSurface->makeSurface(dstSurface->imageInfo());
Derek Sollenberger76664d62021-02-04 11:13:09 -0500747 canvas = mCapture->tryOffscreenCapture(activeSurface.get(), &offscreenCaptureState);
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500748 blurCompositionLayer = layer;
749 break;
750 }
751 }
752 }
753
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500754 AutoSaveRestore surfaceAutoSaveRestore(canvas);
Alec Mouri678245d2020-09-30 16:58:23 -0700755 // Clear the entire canvas with a transparent black to prevent ghost images.
756 canvas->clear(SK_ColorTRANSPARENT);
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500757 initCanvas(canvas, display);
Alec Mouric0aae732021-01-12 13:32:18 -0800758
759 // TODO: clearRegion was required for SurfaceView when a buffer is not yet available but the
760 // view is still on-screen. The clear region could be re-specified as a black color layer,
761 // however.
762 if (!display.clearRegion.isEmpty()) {
Derek Sollenberger545ec442021-01-25 10:02:23 -0500763 ATRACE_NAME("ClearRegion");
Alec Mouric0aae732021-01-12 13:32:18 -0800764 size_t numRects = 0;
765 Rect const* rects = display.clearRegion.getArray(&numRects);
766 SkIRect skRects[numRects];
767 for (int i = 0; i < numRects; ++i) {
768 skRects[i] =
769 SkIRect::MakeLTRB(rects[i].left, rects[i].top, rects[i].right, rects[i].bottom);
770 }
771 SkRegion clearRegion;
772 SkPaint paint;
773 sk_sp<SkShader> shader =
774 SkShaders::Color(SkColor4f{.fR = 0., .fG = 0., .fB = 0., .fA = 1.0},
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500775 toSkColorSpace(dstDataspace));
Alec Mouric0aae732021-01-12 13:32:18 -0800776 paint.setShader(shader);
777 clearRegion.setRects(skRects, numRects);
778 canvas->drawRegion(clearRegion, paint);
779 }
780
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500781 // setup color filter if necessary
782 sk_sp<SkColorFilter> displayColorTransform;
783 if (display.colorTransform != mat4()) {
784 displayColorTransform = SkColorFilters::Matrix(toSkColorMatrix(display.colorTransform));
785 }
786
John Reck67b1e2b2020-08-26 13:17:24 -0700787 for (const auto& layer : layers) {
Derek Sollenberger545ec442021-01-25 10:02:23 -0500788 ATRACE_NAME("DrawLayer");
Galia Peychevaf7889b32020-11-25 22:22:40 +0100789
Nathaniel Nifongb9f27ef2021-04-01 16:44:12 -0400790 if (kPrintLayerSettings) {
791 std::stringstream ls;
792 PrintTo(*layer, &ls);
793 auto debugs = ls.str();
794 int pos = 0;
795 while (pos < debugs.size()) {
796 ALOGD("cache_debug %s", debugs.substr(pos, 1000).c_str());
797 pos += 1000;
798 }
799 }
800
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500801 sk_sp<SkImage> blurInput;
802 if (blurCompositionLayer == layer) {
803 LOG_ALWAYS_FATAL_IF(activeSurface == dstSurface);
804 LOG_ALWAYS_FATAL_IF(canvas == dstCanvas);
805
806 // save a snapshot of the activeSurface to use as input to the blur shaders
807 blurInput = activeSurface->makeImageSnapshot();
808
809 // TODO we could skip this step if we know the blur will cover the entire image
810 // blit the offscreen framebuffer into the destination AHB
811 SkPaint paint;
812 paint.setBlendMode(SkBlendMode::kSrc);
Derek Sollenberger76664d62021-02-04 11:13:09 -0500813 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
814 uint64_t id = mCapture->endOffscreenCapture(&offscreenCaptureState);
815 dstCanvas->drawAnnotation(SkRect::Make(dstCanvas->imageInfo().dimensions()),
816 String8::format("SurfaceID|%" PRId64, id).c_str(),
817 nullptr);
818 dstCanvas->drawImage(blurInput, 0, 0, SkSamplingOptions(), &paint);
819 } else {
820 activeSurface->draw(dstCanvas, 0, 0, SkSamplingOptions(), &paint);
821 }
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500822
823 // assign dstCanvas to canvas and ensure that the canvas state is up to date
824 canvas = dstCanvas;
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500825 surfaceAutoSaveRestore.replace(canvas);
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500826 initCanvas(canvas, display);
827
828 LOG_ALWAYS_FATAL_IF(activeSurface->getCanvas()->getSaveCount() !=
829 dstSurface->getCanvas()->getSaveCount());
830 LOG_ALWAYS_FATAL_IF(activeSurface->getCanvas()->getTotalMatrix() !=
831 dstSurface->getCanvas()->getTotalMatrix());
832
833 // assign dstSurface to activeSurface
834 activeSurface = dstSurface;
835 }
836
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500837 SkAutoCanvasRestore layerAutoSaveRestore(canvas, true);
Derek Sollenberger76664d62021-02-04 11:13:09 -0500838 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
Ana Krulec6eab17a2020-12-09 15:52:36 -0800839 // Record the name of the layer if the capture is running.
840 std::stringstream layerSettings;
841 PrintTo(*layer, &layerSettings);
842 // Store the LayerSettings in additional information.
843 canvas->drawAnnotation(SkRect::MakeEmpty(), layer->name.c_str(),
844 SkData::MakeWithCString(layerSettings.str().c_str()));
845 }
Galia Peychevaf7889b32020-11-25 22:22:40 +0100846 // Layers have a local transform that should be applied to them
847 canvas->concat(getSkM44(layer->geometry.positionTransform).asM33());
Galia Peycheva6c460652020-11-03 19:42:42 +0100848
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -0400849 const auto [bounds, roundRectClip] = getBoundsAndClip(layer);
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500850 if (mBlurFilter && layerHasBlur(layer)) {
851 std::unordered_map<uint32_t, sk_sp<SkImage>> cachedBlurs;
852
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500853 // if multiple layers have blur, then we need to take a snapshot now because
854 // only the lowest layer will have blurImage populated earlier
855 if (!blurInput) {
856 blurInput = activeSurface->makeImageSnapshot();
857 }
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500858 // rect to be blurred in the coordinate space of blurInput
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -0400859 const auto blurRect = canvas->getTotalMatrix().mapRect(bounds.rect());
860
861 // if the clip needs to be applied then apply it now and make sure
862 // it is restored before we attempt to draw any shadows.
863 SkAutoCanvasRestore acr(canvas, true);
864 if (!roundRectClip.isEmpty()) {
865 canvas->clipRRect(roundRectClip, true);
866 }
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500867
Galia Peychevae425ac82021-03-15 17:12:03 +0100868 // TODO(b/182216890): Filter out empty layers earlier
869 if (blurRect.width() > 0 && blurRect.height() > 0) {
870 if (layer->backgroundBlurRadius > 0) {
871 ATRACE_NAME("BackgroundBlur");
872 auto blurredImage =
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400873 mBlurFilter->generate(grContext, layer->backgroundBlurRadius, blurInput,
874 blurRect);
Galia Peycheva80116e52020-11-06 11:57:25 +0100875
Galia Peychevae425ac82021-03-15 17:12:03 +0100876 cachedBlurs[layer->backgroundBlurRadius] = blurredImage;
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500877
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -0400878 mBlurFilter->drawBlurRegion(canvas, bounds, layer->backgroundBlurRadius, 1.0f,
879 blurRect, blurredImage, blurInput);
Lucas Dupinc3800b82020-10-02 16:24:48 -0700880 }
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -0400881
Derek Sollenberger39feade2021-04-27 16:08:40 -0400882 canvas->concat(getSkM44(layer->blurRegionTransform).asM33());
Galia Peychevae425ac82021-03-15 17:12:03 +0100883 for (auto region : layer->blurRegions) {
884 if (cachedBlurs[region.blurRadius] == nullptr) {
885 ATRACE_NAME("BlurRegion");
886 cachedBlurs[region.blurRadius] =
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400887 mBlurFilter->generate(grContext, region.blurRadius, blurInput,
Galia Peychevae425ac82021-03-15 17:12:03 +0100888 blurRect);
889 }
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500890
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -0400891 mBlurFilter->drawBlurRegion(canvas, getBlurRRect(region), region.blurRadius,
892 region.alpha, blurRect,
Galia Peychevae425ac82021-03-15 17:12:03 +0100893 cachedBlurs[region.blurRadius], blurInput);
894 }
Lucas Dupinc3800b82020-10-02 16:24:48 -0700895 }
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700896 }
897
Derek Sollenberger4c331c82021-02-23 13:09:50 -0500898 // Shadows are assumed to live only on their own layer - it's not valid
899 // to draw the boundary rectangles when there is already a caster shadow
900 // TODO(b/175915334): consider relaxing this restriction to enable more flexible
901 // composition - using a well-defined invalid color is long-term less error-prone.
902 if (layer->shadow.length > 0) {
Leon Scroggins IIIcf3d95c2021-03-19 13:06:32 -0400903 // This would require a new parameter/flag to SkShadowUtils::DrawShadow
904 LOG_ALWAYS_FATAL_IF(layer->disableBlending, "Cannot disableBlending with a shadow");
Leon Scroggins III63e86952021-05-12 10:45:08 -0400905
906 // Technically, if bounds is a rect and roundRectClip is not empty,
907 // it means that the bounds and roundedCornersCrop were different
908 // enough that we should intersect them to find the proper shadow.
909 // In practice, this often happens when the two rectangles appear to
910 // not match due to rounding errors. Draw the rounded version, which
911 // looks more like the intent.
912 const auto& rrect =
913 bounds.isRect() && !roundRectClip.isEmpty() ? roundRectClip : bounds;
914 drawShadow(canvas, rrect, layer->shadow);
Derek Sollenberger4c331c82021-02-23 13:09:50 -0500915 continue;
916 }
917
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500918 const bool requiresLinearEffect = layer->colorTransform != mat4() ||
919 (mUseColorManagement &&
John Reckac09e452021-04-07 16:35:37 -0400920 needsToneMapping(layer->sourceDataspace, display.outputDataspace)) ||
921 (display.sdrWhitePointNits > 0.f &&
922 display.sdrWhitePointNits != display.maxLuminance);
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500923
924 // quick abort from drawing the remaining portion of the layer
Leon Scroggins IIIcf3d95c2021-03-19 13:06:32 -0400925 if (layer->alpha == 0 && !requiresLinearEffect && !layer->disableBlending &&
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500926 (!displayColorTransform || displayColorTransform->isAlphaUnchanged())) {
927 continue;
928 }
929
930 // If we need to map to linear space or color management is disabled, then mark the source
931 // image with the same colorspace as the destination surface so that Skia's color
932 // management is a no-op.
933 const ui::Dataspace layerDataspace = (!mUseColorManagement || requiresLinearEffect)
934 ? dstDataspace
935 : layer->sourceDataspace;
Alec Mouric0aae732021-01-12 13:32:18 -0800936
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500937 SkPaint paint;
John Reck67b1e2b2020-08-26 13:17:24 -0700938 if (layer->source.buffer.buffer) {
939 ATRACE_NAME("DrawImage");
Alec Mouria90a5702021-04-16 16:36:21 +0000940 validateInputBufferUsage(layer->source.buffer.buffer->getBuffer());
John Reck67b1e2b2020-08-26 13:17:24 -0700941 const auto& item = layer->source.buffer;
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800942 std::shared_ptr<AutoBackendTexture::LocalRef> imageTextureRef = nullptr;
Alec Mouria90a5702021-04-16 16:36:21 +0000943
944 if (const auto& iter = cache.find(item.buffer->getBuffer()->getId());
945 iter != cache.end()) {
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800946 imageTextureRef = iter->second;
John Reck67b1e2b2020-08-26 13:17:24 -0700947 } else {
Alec Mouria90a5702021-04-16 16:36:21 +0000948 // If we didn't find the image in the cache, then create a local ref but don't cache
949 // it. If we're using skia, we're guaranteed to run on a dedicated GPU thread so if
950 // we didn't find anything in the cache then we intentionally did not cache this
951 // buffer's resources.
Derek Sollenbergerd8fdae32021-04-09 13:52:59 -0400952 imageTextureRef = std::make_shared<
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400953 AutoBackendTexture::LocalRef>(grContext,
Derek Sollenbergerd8fdae32021-04-09 13:52:59 -0400954 item.buffer->getBuffer()->toAHardwareBuffer(),
955 false);
John Reck67b1e2b2020-08-26 13:17:24 -0700956 }
Alec Mouri1a4d0642020-11-13 17:42:01 -0800957
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800958 sk_sp<SkImage> image =
Derek Sollenbergerd8fdae32021-04-09 13:52:59 -0400959 imageTextureRef->makeImage(layerDataspace,
960 item.usePremultipliedAlpha ? kPremul_SkAlphaType
961 : kUnpremul_SkAlphaType,
Derek Sollenbergerb24258c2021-05-04 13:47:34 -0400962 grContext);
Alec Mouri678245d2020-09-30 16:58:23 -0700963
964 auto texMatrix = getSkM44(item.textureTransform).asM33();
965 // textureTansform was intended to be passed directly into a shader, so when
966 // building the total matrix with the textureTransform we need to first
967 // normalize it, then apply the textureTransform, then scale back up.
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500968 texMatrix.preScale(1.0f / bounds.width(), 1.0f / bounds.height());
Huihong Luo3a3cf3c2020-12-07 17:05:41 -0800969 texMatrix.postScale(image->width(), image->height());
Alec Mouri678245d2020-09-30 16:58:23 -0700970
Huihong Luo3a3cf3c2020-12-07 17:05:41 -0800971 SkMatrix matrix;
972 if (!texMatrix.invert(&matrix)) {
973 matrix = texMatrix;
Alec Mouri678245d2020-09-30 16:58:23 -0700974 }
Ana Krulecf9a15d92020-12-11 08:35:00 -0800975 // The shader does not respect the translation, so we add it to the texture
976 // transform for the SkImage. This will make sure that the correct layer contents
977 // are drawn in the correct part of the screen.
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -0400978 matrix.postTranslate(bounds.rect().fLeft, bounds.rect().fTop);
Alec Mouri678245d2020-09-30 16:58:23 -0700979
Ana Krulecb7b28b22020-11-23 14:48:58 -0800980 sk_sp<SkShader> shader;
981
982 if (layer->source.buffer.useTextureFiltering) {
983 shader = image->makeShader(SkTileMode::kClamp, SkTileMode::kClamp,
984 SkSamplingOptions(
985 {SkFilterMode::kLinear, SkMipmapMode::kNone}),
986 &matrix);
987 } else {
Mike Reed711e1f02020-12-11 13:06:19 -0500988 shader = image->makeShader(SkSamplingOptions(), matrix);
Ana Krulecb7b28b22020-11-23 14:48:58 -0800989 }
Alec Mouri029d1952020-10-12 10:37:08 -0700990
Alec Mouric0aae732021-01-12 13:32:18 -0800991 // Handle opaque images - it's a little nonstandard how we do this.
992 // Fundamentally we need to support SurfaceControl.Builder#setOpaque:
993 // https://developer.android.com/reference/android/view/SurfaceControl.Builder#setOpaque(boolean)
994 // The important language is that when isOpaque is set, opacity is not sampled from the
995 // alpha channel, but blending may still be supported on a transaction via setAlpha. So,
996 // here's the conundrum:
997 // 1. We can't force the SkImage alpha type to kOpaque_SkAlphaType, because it's treated
998 // as an internal hint - composition is undefined when there are alpha bits present.
999 // 2. We can try to lie about the pixel layout, but that only works for RGBA8888
1000 // buffers, i.e., treating them as RGBx8888 instead. But we can't do the same for
1001 // RGBA1010102 because RGBx1010102 is not supported as a pixel layout for SkImages. It's
1002 // also not clear what to use for F16 either, and lying about the pixel layout is a bit
1003 // of a hack anyways.
1004 // 3. We can't change the blendmode to src, because while this satisfies the requirement
1005 // for ignoring the alpha channel, it doesn't quite satisfy the blending requirement
1006 // because src always clobbers the destination content.
1007 //
1008 // So, what we do here instead is an additive blend mode where we compose the input
1009 // image with a solid black. This might need to be reassess if this does not support
1010 // FP16 incredibly well, but FP16 end-to-end isn't well supported anyway at the moment.
1011 if (item.isOpaque) {
1012 shader = SkShaders::Blend(SkBlendMode::kPlus, shader,
1013 SkShaders::Color(SkColors::kBlack,
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -05001014 toSkColorSpace(layerDataspace)));
Alec Mouric0aae732021-01-12 13:32:18 -08001015 }
1016
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -05001017 paint.setShader(createRuntimeEffectShader(shader, layer, display,
1018 !item.isOpaque && item.usePremultipliedAlpha,
1019 requiresLinearEffect));
Ana Krulec1768bd22020-11-23 14:51:31 -08001020 paint.setAlphaf(layer->alpha);
John Reck67b1e2b2020-08-26 13:17:24 -07001021 } else {
1022 ATRACE_NAME("DrawColor");
John Reck67b1e2b2020-08-26 13:17:24 -07001023 const auto color = layer->source.solidColor;
Ana Krulec47814212021-01-06 19:00:10 -08001024 sk_sp<SkShader> shader = SkShaders::Color(SkColor4f{.fR = color.r,
1025 .fG = color.g,
1026 .fB = color.b,
Alec Mouric0aae732021-01-12 13:32:18 -08001027 .fA = layer->alpha},
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -05001028 toSkColorSpace(layerDataspace));
Ana Krulec47814212021-01-06 19:00:10 -08001029 paint.setShader(createRuntimeEffectShader(shader, layer, display,
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -05001030 /* undoPremultipliedAlpha */ false,
1031 requiresLinearEffect));
John Reck67b1e2b2020-08-26 13:17:24 -07001032 }
Lucas Dupin21f348e2020-09-16 17:31:26 -07001033
Leon Scroggins IIIcf3d95c2021-03-19 13:06:32 -04001034 if (layer->disableBlending) {
1035 paint.setBlendMode(SkBlendMode::kSrc);
1036 }
1037
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -05001038 paint.setColorFilter(displayColorTransform);
Alec Mourib34f0b72020-10-02 13:18:34 -07001039
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001040 if (!roundRectClip.isEmpty()) {
1041 canvas->clipRRect(roundRectClip, true);
1042 }
1043
1044 if (!bounds.isRect()) {
Derek Sollenberger4c331c82021-02-23 13:09:50 -05001045 paint.setAntiAlias(true);
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001046 canvas->drawRRect(bounds, paint);
Alec Mouribd17b3b2020-12-17 11:08:30 -08001047 } else {
Nader Jawad63644d32021-05-07 10:44:21 -07001048 canvas->drawRect(bounds.rect(), paint);
Lucas Dupin3f11e922020-09-22 17:31:04 -07001049 }
Nathaniel Nifongb9f27ef2021-04-01 16:44:12 -04001050 if (kFlushAfterEveryLayer) {
1051 ATRACE_NAME("flush surface");
1052 activeSurface->flush();
1053 }
John Reck67b1e2b2020-08-26 13:17:24 -07001054 }
Derek Sollenberger7c42bef2021-02-23 13:01:39 -05001055 surfaceAutoSaveRestore.restore();
Alec Mouric0aae732021-01-12 13:32:18 -08001056 mCapture->endCapture();
John Reck67b1e2b2020-08-26 13:17:24 -07001057 {
1058 ATRACE_NAME("flush surface");
Derek Sollenberger3f77aa42021-02-04 11:06:34 -05001059 LOG_ALWAYS_FATAL_IF(activeSurface != dstSurface);
1060 activeSurface->flush();
John Reck67b1e2b2020-08-26 13:17:24 -07001061 }
1062
1063 if (drawFence != nullptr) {
1064 *drawFence = flush();
1065 }
1066
1067 // If flush failed or we don't support native fences, we need to force the
1068 // gl command stream to be executed.
1069 bool requireSync = drawFence == nullptr || drawFence->get() < 0;
1070 if (requireSync) {
1071 ATRACE_BEGIN("Submit(sync=true)");
1072 } else {
1073 ATRACE_BEGIN("Submit(sync=false)");
1074 }
Lucas Dupind508e472020-11-04 04:32:06 +00001075 bool success = grContext->submit(requireSync);
John Reck67b1e2b2020-08-26 13:17:24 -07001076 ATRACE_END();
1077 if (!success) {
1078 ALOGE("Failed to flush RenderEngine commands");
1079 // Chances are, something illegal happened (either the caller passed
1080 // us bad parameters, or we messed up our shader generation).
1081 return INVALID_OPERATION;
1082 }
1083
1084 // checkErrors();
1085 return NO_ERROR;
1086}
1087
Lucas Dupin3f11e922020-09-22 17:31:04 -07001088inline SkRect SkiaGLRenderEngine::getSkRect(const FloatRect& rect) {
1089 return SkRect::MakeLTRB(rect.left, rect.top, rect.right, rect.bottom);
1090}
1091
1092inline SkRect SkiaGLRenderEngine::getSkRect(const Rect& rect) {
1093 return SkRect::MakeLTRB(rect.left, rect.top, rect.right, rect.bottom);
1094}
1095
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001096inline std::pair<SkRRect, SkRRect> SkiaGLRenderEngine::getBoundsAndClip(
1097 const LayerSettings* layer) {
1098 const auto bounds = getSkRect(layer->geometry.boundaries);
1099 const auto crop = getSkRect(layer->geometry.roundedCornersCrop);
Lucas Dupin21f348e2020-09-16 17:31:26 -07001100 const auto cornerRadius = layer->geometry.roundedCornersRadius;
Lucas Dupin21f348e2020-09-16 17:31:26 -07001101
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001102 SkRRect clip;
1103 if (cornerRadius > 0) {
Derek Sollenberger4f9959f2021-05-12 16:47:37 -04001104 // it the crop and the bounds are equivalent or there is no crop then we don't need a clip
1105 if (bounds == crop || crop.isEmpty()) {
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001106 return {SkRRect::MakeRectXY(bounds, cornerRadius, cornerRadius), clip};
1107 }
1108
1109 // This makes an effort to speed up common, simple bounds + clip combinations by
1110 // converting them to a single RRect draw. It is possible there are other cases
1111 // that can be converted.
1112 if (crop.contains(bounds)) {
1113 bool intersectionIsRoundRect = true;
1114 // check each cropped corner to ensure that it exactly matches the crop or is full
1115 SkVector radii[4];
1116
1117 const auto insetCrop = crop.makeInset(cornerRadius, cornerRadius);
1118
Derek Sollenberger4f9959f2021-05-12 16:47:37 -04001119 const bool leftEqual = bounds.fLeft == crop.fLeft;
1120 const bool topEqual = bounds.fTop == crop.fTop;
1121 const bool rightEqual = bounds.fRight == crop.fRight;
1122 const bool bottomEqual = bounds.fBottom == crop.fBottom;
1123
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001124 // compute the UpperLeft corner radius
Derek Sollenberger4f9959f2021-05-12 16:47:37 -04001125 if (leftEqual && topEqual) {
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001126 radii[0].set(cornerRadius, cornerRadius);
Derek Sollenberger4f9959f2021-05-12 16:47:37 -04001127 } else if ((leftEqual && bounds.fTop >= insetCrop.fTop) ||
1128 (topEqual && bounds.fLeft >= insetCrop.fLeft) ||
1129 insetCrop.contains(bounds.fLeft, bounds.fTop)) {
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001130 radii[0].set(0, 0);
1131 } else {
1132 intersectionIsRoundRect = false;
1133 }
1134 // compute the UpperRight corner radius
Derek Sollenberger4f9959f2021-05-12 16:47:37 -04001135 if (rightEqual && topEqual) {
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001136 radii[1].set(cornerRadius, cornerRadius);
Derek Sollenberger4f9959f2021-05-12 16:47:37 -04001137 } else if ((rightEqual && bounds.fTop >= insetCrop.fTop) ||
1138 (topEqual && bounds.fRight <= insetCrop.fRight) ||
1139 insetCrop.contains(bounds.fRight, bounds.fTop)) {
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001140 radii[1].set(0, 0);
1141 } else {
1142 intersectionIsRoundRect = false;
1143 }
1144 // compute the BottomRight corner radius
Derek Sollenberger4f9959f2021-05-12 16:47:37 -04001145 if (rightEqual && bottomEqual) {
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001146 radii[2].set(cornerRadius, cornerRadius);
Derek Sollenberger4f9959f2021-05-12 16:47:37 -04001147 } else if ((rightEqual && bounds.fBottom <= insetCrop.fBottom) ||
1148 (bottomEqual && bounds.fRight <= insetCrop.fRight) ||
1149 insetCrop.contains(bounds.fRight, bounds.fBottom)) {
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001150 radii[2].set(0, 0);
1151 } else {
1152 intersectionIsRoundRect = false;
1153 }
1154 // compute the BottomLeft corner radius
Derek Sollenberger4f9959f2021-05-12 16:47:37 -04001155 if (leftEqual && bottomEqual) {
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001156 radii[3].set(cornerRadius, cornerRadius);
Derek Sollenberger4f9959f2021-05-12 16:47:37 -04001157 } else if ((leftEqual && bounds.fBottom <= insetCrop.fBottom) ||
1158 (bottomEqual && bounds.fLeft >= insetCrop.fLeft) ||
1159 insetCrop.contains(bounds.fLeft, bounds.fBottom)) {
Derek Sollenberger8e8b3bf2021-04-29 15:35:28 -04001160 radii[3].set(0, 0);
1161 } else {
1162 intersectionIsRoundRect = false;
1163 }
1164
1165 if (intersectionIsRoundRect) {
1166 SkRRect intersectionBounds;
1167 intersectionBounds.setRectRadii(bounds, radii);
1168 return {intersectionBounds, clip};
1169 }
1170 }
1171
1172 // we didn't it any of our fast paths so set the clip to the cropRect
1173 clip.setRectXY(crop, cornerRadius, cornerRadius);
1174 }
1175
1176 // if we hit this point then we either don't have rounded corners or we are going to rely
1177 // on the clip to round the corners for us
1178 return {SkRRect::MakeRect(bounds), clip};
Galia Peycheva80116e52020-11-06 11:57:25 +01001179}
1180
Derek Sollenbergerecb21462021-01-29 16:53:49 -05001181inline bool SkiaGLRenderEngine::layerHasBlur(const LayerSettings* layer) {
1182 return layer->backgroundBlurRadius > 0 || layer->blurRegions.size();
1183}
1184
Lucas Dupin3f11e922020-09-22 17:31:04 -07001185inline SkColor SkiaGLRenderEngine::getSkColor(const vec4& color) {
1186 return SkColorSetARGB(color.a * 255, color.r * 255, color.g * 255, color.b * 255);
1187}
1188
Lucas Dupinbb1a1d42020-09-18 15:17:02 -07001189inline SkM44 SkiaGLRenderEngine::getSkM44(const mat4& matrix) {
1190 return SkM44(matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0],
1191 matrix[0][1], matrix[1][1], matrix[2][1], matrix[3][1],
1192 matrix[0][2], matrix[1][2], matrix[2][2], matrix[3][2],
1193 matrix[0][3], matrix[1][3], matrix[2][3], matrix[3][3]);
1194}
1195
Lucas Dupin3f11e922020-09-22 17:31:04 -07001196inline SkPoint3 SkiaGLRenderEngine::getSkPoint3(const vec3& vector) {
1197 return SkPoint3::Make(vector.x, vector.y, vector.z);
1198}
1199
John Reck67b1e2b2020-08-26 13:17:24 -07001200size_t SkiaGLRenderEngine::getMaxTextureSize() const {
1201 return mGrContext->maxTextureSize();
1202}
1203
1204size_t SkiaGLRenderEngine::getMaxViewportDims() const {
1205 return mGrContext->maxRenderTargetSize();
1206}
1207
Derek Sollenbergerb0e764c2021-05-04 14:31:37 -04001208void SkiaGLRenderEngine::drawShadow(SkCanvas* canvas, const SkRRect& casterRRect,
Lucas Dupin3f11e922020-09-22 17:31:04 -07001209 const ShadowSettings& settings) {
1210 ATRACE_CALL();
1211 const float casterZ = settings.length / 2.0f;
Lucas Dupin3f11e922020-09-22 17:31:04 -07001212 const auto flags =
1213 settings.casterIsTranslucent ? kTransparentOccluder_ShadowFlag : kNone_ShadowFlag;
1214
Derek Sollenbergerb0e764c2021-05-04 14:31:37 -04001215 SkShadowUtils::DrawShadow(canvas, SkPath::RRect(casterRRect), SkPoint3::Make(0, 0, casterZ),
Lucas Dupin3f11e922020-09-22 17:31:04 -07001216 getSkPoint3(settings.lightPos), settings.lightRadius,
1217 getSkColor(settings.ambientColor), getSkColor(settings.spotColor),
1218 flags);
1219}
1220
John Reck67b1e2b2020-08-26 13:17:24 -07001221EGLContext SkiaGLRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,
Alec Mourid6f09462020-12-07 11:18:17 -08001222 EGLContext shareContext,
1223 std::optional<ContextPriority> contextPriority,
John Reck67b1e2b2020-08-26 13:17:24 -07001224 Protection protection) {
1225 EGLint renderableType = 0;
1226 if (config == EGL_NO_CONFIG_KHR) {
1227 renderableType = EGL_OPENGL_ES3_BIT;
1228 } else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) {
1229 LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");
1230 }
1231 EGLint contextClientVersion = 0;
1232 if (renderableType & EGL_OPENGL_ES3_BIT) {
1233 contextClientVersion = 3;
1234 } else if (renderableType & EGL_OPENGL_ES2_BIT) {
1235 contextClientVersion = 2;
1236 } else if (renderableType & EGL_OPENGL_ES_BIT) {
1237 contextClientVersion = 1;
1238 } else {
1239 LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs");
1240 }
1241
1242 std::vector<EGLint> contextAttributes;
1243 contextAttributes.reserve(7);
1244 contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
1245 contextAttributes.push_back(contextClientVersion);
Alec Mourid6f09462020-12-07 11:18:17 -08001246 if (contextPriority) {
John Reck67b1e2b2020-08-26 13:17:24 -07001247 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG);
Alec Mourid6f09462020-12-07 11:18:17 -08001248 switch (*contextPriority) {
1249 case ContextPriority::REALTIME:
1250 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_REALTIME_NV);
1251 break;
1252 case ContextPriority::MEDIUM:
1253 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_MEDIUM_IMG);
1254 break;
1255 case ContextPriority::LOW:
1256 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LOW_IMG);
1257 break;
1258 case ContextPriority::HIGH:
1259 default:
1260 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG);
1261 break;
1262 }
John Reck67b1e2b2020-08-26 13:17:24 -07001263 }
1264 if (protection == Protection::PROTECTED) {
1265 contextAttributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1266 contextAttributes.push_back(EGL_TRUE);
1267 }
1268 contextAttributes.push_back(EGL_NONE);
1269
1270 EGLContext context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1271
1272 if (contextClientVersion == 3 && context == EGL_NO_CONTEXT) {
1273 // eglGetConfigAttrib indicated we can create GLES 3 context, but we failed, thus
1274 // EGL_NO_CONTEXT so that we can abort.
1275 if (config != EGL_NO_CONFIG_KHR) {
1276 return context;
1277 }
1278 // If |config| is EGL_NO_CONFIG_KHR, we speculatively try to create GLES 3 context, so we
1279 // should try to fall back to GLES 2.
1280 contextAttributes[1] = 2;
1281 context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1282 }
1283
1284 return context;
1285}
1286
Alec Mourid6f09462020-12-07 11:18:17 -08001287std::optional<RenderEngine::ContextPriority> SkiaGLRenderEngine::createContextPriority(
1288 const RenderEngineCreationArgs& args) {
1289 if (!gl::GLExtensions::getInstance().hasContextPriority()) {
1290 return std::nullopt;
1291 }
1292
1293 switch (args.contextPriority) {
1294 case RenderEngine::ContextPriority::REALTIME:
1295 if (gl::GLExtensions::getInstance().hasRealtimePriority()) {
1296 return RenderEngine::ContextPriority::REALTIME;
1297 } else {
1298 ALOGI("Realtime priority unsupported, degrading gracefully to high priority");
1299 return RenderEngine::ContextPriority::HIGH;
1300 }
1301 case RenderEngine::ContextPriority::HIGH:
1302 case RenderEngine::ContextPriority::MEDIUM:
1303 case RenderEngine::ContextPriority::LOW:
1304 return args.contextPriority;
1305 default:
1306 return std::nullopt;
1307 }
1308}
1309
John Reck67b1e2b2020-08-26 13:17:24 -07001310EGLSurface SkiaGLRenderEngine::createPlaceholderEglPbufferSurface(EGLDisplay display,
1311 EGLConfig config, int hwcFormat,
1312 Protection protection) {
1313 EGLConfig placeholderConfig = config;
1314 if (placeholderConfig == EGL_NO_CONFIG_KHR) {
1315 placeholderConfig = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);
1316 }
1317 std::vector<EGLint> attributes;
1318 attributes.reserve(7);
1319 attributes.push_back(EGL_WIDTH);
1320 attributes.push_back(1);
1321 attributes.push_back(EGL_HEIGHT);
1322 attributes.push_back(1);
1323 if (protection == Protection::PROTECTED) {
1324 attributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1325 attributes.push_back(EGL_TRUE);
1326 }
1327 attributes.push_back(EGL_NONE);
1328
1329 return eglCreatePbufferSurface(display, placeholderConfig, attributes.data());
1330}
1331
Alec Mourid6f09462020-12-07 11:18:17 -08001332int SkiaGLRenderEngine::getContextPriority() {
1333 int value;
1334 eglQueryContext(mEGLDisplay, mEGLContext, EGL_CONTEXT_PRIORITY_LEVEL_IMG, &value);
1335 return value;
1336}
1337
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -04001338void SkiaGLRenderEngine::onPrimaryDisplaySizeChanged(ui::Size size) {
1339 // This cache multiplier was selected based on review of cache sizes relative
1340 // to the screen resolution. Looking at the worst case memory needed by blur (~1.5x),
1341 // shadows (~1x), and general data structures (e.g. vertex buffers) we selected this as a
1342 // conservative default based on that analysis.
1343 const float SURFACE_SIZE_MULTIPLIER = 3.5f * bytesPerPixel(mDefaultPixelFormat);
1344 const int maxResourceBytes = size.width * size.height * SURFACE_SIZE_MULTIPLIER;
1345
1346 // start by resizing the current context
Derek Sollenbergerb24258c2021-05-04 13:47:34 -04001347 getActiveGrContext()->setResourceCacheLimit(maxResourceBytes);
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -04001348
1349 // if it is possible to switch contexts then we will resize the other context
1350 if (useProtectedContext(!mInProtectedContext)) {
Derek Sollenbergerb24258c2021-05-04 13:47:34 -04001351 getActiveGrContext()->setResourceCacheLimit(maxResourceBytes);
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -04001352 // reset back to the initial context that was active when this method was called
1353 useProtectedContext(!mInProtectedContext);
1354 }
1355}
1356
Ana Krulec1d12b3b2021-01-27 16:49:51 -08001357void SkiaGLRenderEngine::dump(std::string& result) {
1358 const gl::GLExtensions& extensions = gl::GLExtensions::getInstance();
1359
1360 StringAppendF(&result, "\n ------------RE-----------------\n");
1361 StringAppendF(&result, "EGL implementation : %s\n", extensions.getEGLVersion());
1362 StringAppendF(&result, "%s\n", extensions.getEGLExtensions());
1363 StringAppendF(&result, "GLES: %s, %s, %s\n", extensions.getVendor(), extensions.getRenderer(),
1364 extensions.getVersion());
1365 StringAppendF(&result, "%s\n", extensions.getExtensions());
1366 StringAppendF(&result, "RenderEngine supports protected context: %d\n",
1367 supportsProtectedContent());
1368 StringAppendF(&result, "RenderEngine is in protected context: %d\n", mInProtectedContext);
Leon Scroggins III9f3072c2021-03-22 10:42:47 -04001369 StringAppendF(&result, "RenderEngine shaders cached since last dump/primeCache: %d\n",
1370 mSkSLCacheMonitor.shadersCachedSinceLastCall());
Ana Krulec1d12b3b2021-01-27 16:49:51 -08001371
Derek Sollenberger0e6d3562021-04-07 19:34:39 -04001372 std::vector<ResourcePair> cpuResourceMap = {
1373 {"skia/sk_resource_cache/bitmap_", "Bitmaps"},
1374 {"skia/sk_resource_cache/rrect-blur_", "Masks"},
1375 {"skia/sk_resource_cache/rects-blur_", "Masks"},
1376 {"skia/sk_resource_cache/tessellated", "Shadows"},
1377 {"skia", "Other"},
1378 };
1379 SkiaMemoryReporter cpuReporter(cpuResourceMap, false);
1380 SkGraphics::DumpMemoryStatistics(&cpuReporter);
1381 StringAppendF(&result, "Skia CPU Caches: ");
1382 cpuReporter.logTotals(result);
1383 cpuReporter.logOutput(result);
1384
Ana Krulec1d12b3b2021-01-27 16:49:51 -08001385 {
1386 std::lock_guard<std::mutex> lock(mRenderingMutex);
Derek Sollenberger0e6d3562021-04-07 19:34:39 -04001387
1388 std::vector<ResourcePair> gpuResourceMap = {
1389 {"texture_renderbuffer", "Texture/RenderBuffer"},
1390 {"texture", "Texture"},
1391 {"gr_text_blob_cache", "Text"},
1392 {"skia", "Other"},
1393 };
1394 SkiaMemoryReporter gpuReporter(gpuResourceMap, true);
1395 mGrContext->dumpMemoryStatistics(&gpuReporter);
1396 StringAppendF(&result, "Skia's GPU Caches: ");
1397 gpuReporter.logTotals(result);
1398 gpuReporter.logOutput(result);
1399 StringAppendF(&result, "Skia's Wrapped Objects:\n");
1400 gpuReporter.logOutput(result, true);
1401
Alec Mouria90a5702021-04-16 16:36:21 +00001402 StringAppendF(&result, "RenderEngine tracked buffers: %zu\n",
1403 mGraphicBufferExternalRefs.size());
1404 StringAppendF(&result, "Dumping buffer ids...\n");
1405 for (const auto& [id, refCounts] : mGraphicBufferExternalRefs) {
1406 StringAppendF(&result, "- 0x%" PRIx64 " - %d refs \n", id, refCounts);
1407 }
Derek Sollenberger0e6d3562021-04-07 19:34:39 -04001408 StringAppendF(&result, "RenderEngine AHB/BackendTexture cache size: %zu\n",
1409 mTextureCache.size());
Ana Krulec1d12b3b2021-01-27 16:49:51 -08001410 StringAppendF(&result, "Dumping buffer ids...\n");
1411 // TODO(178539829): It would be nice to know which layer these are coming from and what
1412 // the texture sizes are.
1413 for (const auto& [id, unused] : mTextureCache) {
1414 StringAppendF(&result, "- 0x%" PRIx64 "\n", id);
1415 }
1416 StringAppendF(&result, "\n");
Derek Sollenberger0e6d3562021-04-07 19:34:39 -04001417
1418 SkiaMemoryReporter gpuProtectedReporter(gpuResourceMap, true);
Derek Sollenberger80a7a762021-04-14 10:22:58 -04001419 if (mProtectedGrContext) {
1420 mProtectedGrContext->dumpMemoryStatistics(&gpuProtectedReporter);
1421 }
Derek Sollenberger0e6d3562021-04-07 19:34:39 -04001422 StringAppendF(&result, "Skia's GPU Protected Caches: ");
1423 gpuProtectedReporter.logTotals(result);
1424 gpuProtectedReporter.logOutput(result);
1425 StringAppendF(&result, "Skia's Protected Wrapped Objects:\n");
1426 gpuProtectedReporter.logOutput(result, true);
1427
1428 StringAppendF(&result, "RenderEngine protected AHB/BackendTexture cache size: %zu\n",
Ana Krulec1d12b3b2021-01-27 16:49:51 -08001429 mProtectedTextureCache.size());
1430 StringAppendF(&result, "Dumping buffer ids...\n");
1431 for (const auto& [id, unused] : mProtectedTextureCache) {
1432 StringAppendF(&result, "- 0x%" PRIx64 "\n", id);
1433 }
1434 StringAppendF(&result, "\n");
1435 StringAppendF(&result, "RenderEngine runtime effects: %zu\n", mRuntimeEffects.size());
1436 for (const auto& [linearEffect, unused] : mRuntimeEffects) {
1437 StringAppendF(&result, "- inputDataspace: %s\n",
1438 dataspaceDetails(
1439 static_cast<android_dataspace>(linearEffect.inputDataspace))
1440 .c_str());
1441 StringAppendF(&result, "- outputDataspace: %s\n",
1442 dataspaceDetails(
1443 static_cast<android_dataspace>(linearEffect.outputDataspace))
1444 .c_str());
1445 StringAppendF(&result, "undoPremultipliedAlpha: %s\n",
1446 linearEffect.undoPremultipliedAlpha ? "true" : "false");
1447 }
1448 }
1449 StringAppendF(&result, "\n");
1450}
1451
John Reck67b1e2b2020-08-26 13:17:24 -07001452} // namespace skia
1453} // namespace renderengine
Galia Peycheva6c460652020-11-03 19:42:42 +01001454} // namespace android