blob: 769951f00fe818360babcdf4053509b6006d5ed7 [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>
John Reck67b1e2b2020-08-26 13:17:24 -070031#include <SkImage.h>
Lucas Dupinf4cb4a02020-09-22 14:19:26 -070032#include <SkImageFilters.h>
Alec Mouric0aae732021-01-12 13:32:18 -080033#include <SkRegion.h>
Lucas Dupin3f11e922020-09-22 17:31:04 -070034#include <SkShadowUtils.h>
John Reck67b1e2b2020-08-26 13:17:24 -070035#include <SkSurface.h>
Ana Krulec1d12b3b2021-01-27 16:49:51 -080036#include <android-base/stringprintf.h>
Alec Mourib5777452020-09-28 11:32:42 -070037#include <gl/GrGLInterface.h>
Alec Mouri4ce5ec02021-01-07 17:33:21 -080038#include <sync/sync.h>
39#include <ui/BlurRegion.h>
Ana Krulec1d12b3b2021-01-27 16:49:51 -080040#include <ui/DebugUtils.h>
Alec Mouri4ce5ec02021-01-07 17:33:21 -080041#include <ui/GraphicBuffer.h>
42#include <utils/Trace.h>
Alec Mourib5777452020-09-28 11:32:42 -070043
44#include <cmath>
Alec Mouri4ce5ec02021-01-07 17:33:21 -080045#include <cstdint>
46#include <memory>
47
48#include "../gl/GLExtensions.h"
Alec Mouric0aae732021-01-12 13:32:18 -080049#include "ColorSpaces.h"
Alec Mouri4ce5ec02021-01-07 17:33:21 -080050#include "SkBlendMode.h"
51#include "SkImageInfo.h"
52#include "filters/BlurFilter.h"
53#include "filters/LinearEffect.h"
54#include "log/log_main.h"
55#include "skia/debug/SkiaCapture.h"
56#include "system/graphics-base-v1.0.h"
Alec Mourib5777452020-09-28 11:32:42 -070057
John Reck67b1e2b2020-08-26 13:17:24 -070058bool checkGlError(const char* op, int lineNumber);
59
60namespace android {
61namespace renderengine {
62namespace skia {
63
Ana Krulec1d12b3b2021-01-27 16:49:51 -080064using base::StringAppendF;
65
John Reck67b1e2b2020-08-26 13:17:24 -070066static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs, EGLint attribute,
67 EGLint wanted, EGLConfig* outConfig) {
68 EGLint numConfigs = -1, n = 0;
69 eglGetConfigs(dpy, nullptr, 0, &numConfigs);
70 std::vector<EGLConfig> configs(numConfigs, EGL_NO_CONFIG_KHR);
71 eglChooseConfig(dpy, attrs, configs.data(), configs.size(), &n);
72 configs.resize(n);
73
74 if (!configs.empty()) {
75 if (attribute != EGL_NONE) {
76 for (EGLConfig config : configs) {
77 EGLint value = 0;
78 eglGetConfigAttrib(dpy, config, attribute, &value);
79 if (wanted == value) {
80 *outConfig = config;
81 return NO_ERROR;
82 }
83 }
84 } else {
85 // just pick the first one
86 *outConfig = configs[0];
87 return NO_ERROR;
88 }
89 }
90
91 return NAME_NOT_FOUND;
92}
93
94static status_t selectEGLConfig(EGLDisplay display, EGLint format, EGLint renderableType,
95 EGLConfig* config) {
96 // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if
97 // it is to be used with WIFI displays
98 status_t err;
99 EGLint wantedAttribute;
100 EGLint wantedAttributeValue;
101
102 std::vector<EGLint> attribs;
103 if (renderableType) {
104 const ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(format);
105 const bool is1010102 = pixelFormat == ui::PixelFormat::RGBA_1010102;
106
107 // Default to 8 bits per channel.
108 const EGLint tmpAttribs[] = {
109 EGL_RENDERABLE_TYPE,
110 renderableType,
111 EGL_RECORDABLE_ANDROID,
112 EGL_TRUE,
113 EGL_SURFACE_TYPE,
114 EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
115 EGL_FRAMEBUFFER_TARGET_ANDROID,
116 EGL_TRUE,
117 EGL_RED_SIZE,
118 is1010102 ? 10 : 8,
119 EGL_GREEN_SIZE,
120 is1010102 ? 10 : 8,
121 EGL_BLUE_SIZE,
122 is1010102 ? 10 : 8,
123 EGL_ALPHA_SIZE,
124 is1010102 ? 2 : 8,
125 EGL_NONE,
126 };
127 std::copy(tmpAttribs, tmpAttribs + (sizeof(tmpAttribs) / sizeof(EGLint)),
128 std::back_inserter(attribs));
129 wantedAttribute = EGL_NONE;
130 wantedAttributeValue = EGL_NONE;
131 } else {
132 // if no renderable type specified, fallback to a simplified query
133 wantedAttribute = EGL_NATIVE_VISUAL_ID;
134 wantedAttributeValue = format;
135 }
136
137 err = selectConfigForAttribute(display, attribs.data(), wantedAttribute, wantedAttributeValue,
138 config);
139 if (err == NO_ERROR) {
140 EGLint caveat;
141 if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat))
142 ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!");
143 }
144
145 return err;
146}
147
148std::unique_ptr<SkiaGLRenderEngine> SkiaGLRenderEngine::create(
149 const RenderEngineCreationArgs& args) {
150 // initialize EGL for the default display
151 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
152 if (!eglInitialize(display, nullptr, nullptr)) {
153 LOG_ALWAYS_FATAL("failed to initialize EGL");
154 }
155
Yiwei Zhange2650962020-12-01 23:27:58 +0000156 const auto eglVersion = eglQueryString(display, EGL_VERSION);
John Reck67b1e2b2020-08-26 13:17:24 -0700157 if (!eglVersion) {
158 checkGlError(__FUNCTION__, __LINE__);
Yiwei Zhange2650962020-12-01 23:27:58 +0000159 LOG_ALWAYS_FATAL("eglQueryString(EGL_VERSION) failed");
John Reck67b1e2b2020-08-26 13:17:24 -0700160 }
161
Yiwei Zhange2650962020-12-01 23:27:58 +0000162 const auto eglExtensions = eglQueryString(display, EGL_EXTENSIONS);
John Reck67b1e2b2020-08-26 13:17:24 -0700163 if (!eglExtensions) {
164 checkGlError(__FUNCTION__, __LINE__);
Yiwei Zhange2650962020-12-01 23:27:58 +0000165 LOG_ALWAYS_FATAL("eglQueryString(EGL_EXTENSIONS) failed");
John Reck67b1e2b2020-08-26 13:17:24 -0700166 }
167
168 auto& extensions = gl::GLExtensions::getInstance();
169 extensions.initWithEGLStrings(eglVersion, eglExtensions);
170
171 // The code assumes that ES2 or later is available if this extension is
172 // supported.
173 EGLConfig config = EGL_NO_CONFIG_KHR;
174 if (!extensions.hasNoConfigContext()) {
175 config = chooseEglConfig(display, args.pixelFormat, /*logConfig*/ true);
176 }
177
John Reck67b1e2b2020-08-26 13:17:24 -0700178 EGLContext protectedContext = EGL_NO_CONTEXT;
Alec Mourid6f09462020-12-07 11:18:17 -0800179 const std::optional<RenderEngine::ContextPriority> priority = createContextPriority(args);
John Reck67b1e2b2020-08-26 13:17:24 -0700180 if (args.enableProtectedContext && extensions.hasProtectedContent()) {
Alec Mourid6f09462020-12-07 11:18:17 -0800181 protectedContext =
182 createEglContext(display, config, nullptr, priority, Protection::PROTECTED);
John Reck67b1e2b2020-08-26 13:17:24 -0700183 ALOGE_IF(protectedContext == EGL_NO_CONTEXT, "Can't create protected context");
184 }
185
Alec Mourid6f09462020-12-07 11:18:17 -0800186 EGLContext ctxt =
187 createEglContext(display, config, protectedContext, priority, Protection::UNPROTECTED);
John Reck67b1e2b2020-08-26 13:17:24 -0700188
189 // if can't create a GL context, we can only abort.
190 LOG_ALWAYS_FATAL_IF(ctxt == EGL_NO_CONTEXT, "EGLContext creation failed");
191
192 EGLSurface placeholder = EGL_NO_SURFACE;
193 if (!extensions.hasSurfacelessContext()) {
194 placeholder = createPlaceholderEglPbufferSurface(display, config, args.pixelFormat,
195 Protection::UNPROTECTED);
196 LOG_ALWAYS_FATAL_IF(placeholder == EGL_NO_SURFACE, "can't create placeholder pbuffer");
197 }
198 EGLBoolean success = eglMakeCurrent(display, placeholder, placeholder, ctxt);
199 LOG_ALWAYS_FATAL_IF(!success, "can't make placeholder pbuffer current");
200 extensions.initWithGLStrings(glGetString(GL_VENDOR), glGetString(GL_RENDERER),
201 glGetString(GL_VERSION), glGetString(GL_EXTENSIONS));
202
203 EGLSurface protectedPlaceholder = EGL_NO_SURFACE;
204 if (protectedContext != EGL_NO_CONTEXT && !extensions.hasSurfacelessContext()) {
205 protectedPlaceholder = createPlaceholderEglPbufferSurface(display, config, args.pixelFormat,
206 Protection::PROTECTED);
207 ALOGE_IF(protectedPlaceholder == EGL_NO_SURFACE,
208 "can't create protected placeholder pbuffer");
209 }
210
211 // initialize the renderer while GL is current
212 std::unique_ptr<SkiaGLRenderEngine> engine =
Lucas Dupind508e472020-11-04 04:32:06 +0000213 std::make_unique<SkiaGLRenderEngine>(args, display, ctxt, placeholder, protectedContext,
214 protectedPlaceholder);
John Reck67b1e2b2020-08-26 13:17:24 -0700215
216 ALOGI("OpenGL ES informations:");
217 ALOGI("vendor : %s", extensions.getVendor());
218 ALOGI("renderer : %s", extensions.getRenderer());
219 ALOGI("version : %s", extensions.getVersion());
220 ALOGI("extensions: %s", extensions.getExtensions());
221 ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize());
222 ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims());
223
224 return engine;
225}
226
227EGLConfig SkiaGLRenderEngine::chooseEglConfig(EGLDisplay display, int format, bool logConfig) {
228 status_t err;
229 EGLConfig config;
230
231 // First try to get an ES3 config
232 err = selectEGLConfig(display, format, EGL_OPENGL_ES3_BIT, &config);
233 if (err != NO_ERROR) {
234 // If ES3 fails, try to get an ES2 config
235 err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);
236 if (err != NO_ERROR) {
237 // If ES2 still doesn't work, probably because we're on the emulator.
238 // try a simplified query
239 ALOGW("no suitable EGLConfig found, trying a simpler query");
240 err = selectEGLConfig(display, format, 0, &config);
241 if (err != NO_ERROR) {
242 // this EGL is too lame for android
243 LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up");
244 }
245 }
246 }
247
248 if (logConfig) {
249 // print some debugging info
250 EGLint r, g, b, a;
251 eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r);
252 eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
253 eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);
254 eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);
255 ALOGI("EGL information:");
256 ALOGI("vendor : %s", eglQueryString(display, EGL_VENDOR));
257 ALOGI("version : %s", eglQueryString(display, EGL_VERSION));
258 ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS));
259 ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS) ?: "Not Supported");
260 ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);
261 }
262
263 return config;
264}
265
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700266SkiaGLRenderEngine::SkiaGLRenderEngine(const RenderEngineCreationArgs& args, EGLDisplay display,
Lucas Dupind508e472020-11-04 04:32:06 +0000267 EGLContext ctxt, EGLSurface placeholder,
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700268 EGLContext protectedContext, EGLSurface protectedPlaceholder)
Alec Mouri081be4c2020-09-16 10:24:47 -0700269 : mEGLDisplay(display),
John Reck67b1e2b2020-08-26 13:17:24 -0700270 mEGLContext(ctxt),
271 mPlaceholderSurface(placeholder),
272 mProtectedEGLContext(protectedContext),
Alec Mourib5777452020-09-28 11:32:42 -0700273 mProtectedPlaceholderSurface(protectedPlaceholder),
Ana Krulecdfec8f52021-01-13 12:51:47 -0800274 mUseColorManagement(args.useColorManagement),
275 mRenderEngineType(args.renderEngineType) {
John Reck67b1e2b2020-08-26 13:17:24 -0700276 sk_sp<const GrGLInterface> glInterface(GrGLCreateNativeInterface());
277 LOG_ALWAYS_FATAL_IF(!glInterface.get());
278
279 GrContextOptions options;
280 options.fPreferExternalImagesOverES3 = true;
281 options.fDisableDistanceFieldPaths = true;
Lucas Dupind508e472020-11-04 04:32:06 +0000282 mGrContext = GrDirectContext::MakeGL(glInterface, options);
283 if (useProtectedContext(true)) {
284 mProtectedGrContext = GrDirectContext::MakeGL(glInterface, options);
285 useProtectedContext(false);
286 }
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700287
288 if (args.supportsBackgroundBlur) {
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500289 ALOGD("Background Blurs Enabled");
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700290 mBlurFilter = new BlurFilter();
291 }
Alec Mouric0aae732021-01-12 13:32:18 -0800292 mCapture = std::make_unique<SkiaCapture>();
293}
294
295SkiaGLRenderEngine::~SkiaGLRenderEngine() {
296 std::lock_guard<std::mutex> lock(mRenderingMutex);
297 mRuntimeEffects.clear();
298 mProtectedTextureCache.clear();
299 mTextureCache.clear();
300
301 if (mBlurFilter) {
302 delete mBlurFilter;
303 }
304
305 mCapture = nullptr;
306
307 mGrContext->flushAndSubmit(true);
308 mGrContext->abandonContext();
309
310 if (mProtectedGrContext) {
311 mProtectedGrContext->flushAndSubmit(true);
312 mProtectedGrContext->abandonContext();
313 }
314
315 if (mPlaceholderSurface != EGL_NO_SURFACE) {
316 eglDestroySurface(mEGLDisplay, mPlaceholderSurface);
317 }
318 if (mProtectedPlaceholderSurface != EGL_NO_SURFACE) {
319 eglDestroySurface(mEGLDisplay, mProtectedPlaceholderSurface);
320 }
321 if (mEGLContext != EGL_NO_CONTEXT) {
322 eglDestroyContext(mEGLDisplay, mEGLContext);
323 }
324 if (mProtectedEGLContext != EGL_NO_CONTEXT) {
325 eglDestroyContext(mEGLDisplay, mProtectedEGLContext);
326 }
327 eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
328 eglTerminate(mEGLDisplay);
329 eglReleaseThread();
John Reck67b1e2b2020-08-26 13:17:24 -0700330}
331
Lucas Dupind508e472020-11-04 04:32:06 +0000332bool SkiaGLRenderEngine::supportsProtectedContent() const {
333 return mProtectedEGLContext != EGL_NO_CONTEXT;
334}
335
336bool SkiaGLRenderEngine::useProtectedContext(bool useProtectedContext) {
337 if (useProtectedContext == mInProtectedContext) {
338 return true;
339 }
Alec Mourif6a07812021-02-11 21:07:55 -0800340 if (useProtectedContext && !supportsProtectedContent()) {
Lucas Dupind508e472020-11-04 04:32:06 +0000341 return false;
342 }
343 const EGLSurface surface =
344 useProtectedContext ? mProtectedPlaceholderSurface : mPlaceholderSurface;
345 const EGLContext context = useProtectedContext ? mProtectedEGLContext : mEGLContext;
346 const bool success = eglMakeCurrent(mEGLDisplay, surface, surface, context) == EGL_TRUE;
Alec Mouric0aae732021-01-12 13:32:18 -0800347
Lucas Dupind508e472020-11-04 04:32:06 +0000348 if (success) {
349 mInProtectedContext = useProtectedContext;
350 }
351 return success;
352}
353
John Reck67b1e2b2020-08-26 13:17:24 -0700354base::unique_fd SkiaGLRenderEngine::flush() {
355 ATRACE_CALL();
356 if (!gl::GLExtensions::getInstance().hasNativeFenceSync()) {
357 return base::unique_fd();
358 }
359
360 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
361 if (sync == EGL_NO_SYNC_KHR) {
362 ALOGW("failed to create EGL native fence sync: %#x", eglGetError());
363 return base::unique_fd();
364 }
365
366 // native fence fd will not be populated until flush() is done.
367 glFlush();
368
369 // get the fence fd
370 base::unique_fd fenceFd(eglDupNativeFenceFDANDROID(mEGLDisplay, sync));
371 eglDestroySyncKHR(mEGLDisplay, sync);
372 if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
373 ALOGW("failed to dup EGL native fence sync: %#x", eglGetError());
374 }
375
376 return fenceFd;
377}
378
379bool SkiaGLRenderEngine::waitFence(base::unique_fd fenceFd) {
380 if (!gl::GLExtensions::getInstance().hasNativeFenceSync() ||
381 !gl::GLExtensions::getInstance().hasWaitSync()) {
382 return false;
383 }
384
385 // release the fd and transfer the ownership to EGLSync
386 EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceFd.release(), EGL_NONE};
387 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
388 if (sync == EGL_NO_SYNC_KHR) {
389 ALOGE("failed to create EGL native fence sync: %#x", eglGetError());
390 return false;
391 }
392
393 // XXX: The spec draft is inconsistent as to whether this should return an
394 // EGLint or void. Ignore the return value for now, as it's not strictly
395 // needed.
396 eglWaitSyncKHR(mEGLDisplay, sync, 0);
397 EGLint error = eglGetError();
398 eglDestroySyncKHR(mEGLDisplay, sync);
399 if (error != EGL_SUCCESS) {
400 ALOGE("failed to wait for EGL native fence sync: %#x", error);
401 return false;
402 }
403
404 return true;
405}
406
407static bool hasUsage(const AHardwareBuffer_Desc& desc, uint64_t usage) {
408 return !!(desc.usage & usage);
409}
410
Alec Mouri678245d2020-09-30 16:58:23 -0700411static float toDegrees(uint32_t transform) {
412 switch (transform) {
413 case ui::Transform::ROT_90:
414 return 90.0;
415 case ui::Transform::ROT_180:
416 return 180.0;
417 case ui::Transform::ROT_270:
418 return 270.0;
419 default:
420 return 0.0;
421 }
422}
423
Alec Mourib34f0b72020-10-02 13:18:34 -0700424static SkColorMatrix toSkColorMatrix(const mat4& matrix) {
425 return SkColorMatrix(matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0], 0, matrix[0][1],
426 matrix[1][1], matrix[2][1], matrix[3][1], 0, matrix[0][2], matrix[1][2],
427 matrix[2][2], matrix[3][2], 0, matrix[0][3], matrix[1][3], matrix[2][3],
428 matrix[3][3], 0);
429}
430
Alec Mouri029d1952020-10-12 10:37:08 -0700431static bool needsToneMapping(ui::Dataspace sourceDataspace, ui::Dataspace destinationDataspace) {
432 int64_t sourceTransfer = sourceDataspace & HAL_DATASPACE_TRANSFER_MASK;
433 int64_t destTransfer = destinationDataspace & HAL_DATASPACE_TRANSFER_MASK;
434
435 // Treat unsupported dataspaces as srgb
436 if (destTransfer != HAL_DATASPACE_TRANSFER_LINEAR &&
437 destTransfer != HAL_DATASPACE_TRANSFER_HLG &&
438 destTransfer != HAL_DATASPACE_TRANSFER_ST2084) {
439 destTransfer = HAL_DATASPACE_TRANSFER_SRGB;
440 }
441
442 if (sourceTransfer != HAL_DATASPACE_TRANSFER_LINEAR &&
443 sourceTransfer != HAL_DATASPACE_TRANSFER_HLG &&
444 sourceTransfer != HAL_DATASPACE_TRANSFER_ST2084) {
445 sourceTransfer = HAL_DATASPACE_TRANSFER_SRGB;
446 }
447
448 const bool isSourceLinear = sourceTransfer == HAL_DATASPACE_TRANSFER_LINEAR;
449 const bool isSourceSRGB = sourceTransfer == HAL_DATASPACE_TRANSFER_SRGB;
450 const bool isDestLinear = destTransfer == HAL_DATASPACE_TRANSFER_LINEAR;
451 const bool isDestSRGB = destTransfer == HAL_DATASPACE_TRANSFER_SRGB;
452
453 return !(isSourceLinear && isDestSRGB) && !(isSourceSRGB && isDestLinear) &&
454 sourceTransfer != destTransfer;
455}
456
Alec Mouri1a4d0642020-11-13 17:42:01 -0800457static bool needsLinearEffect(const mat4& colorTransform, ui::Dataspace sourceDataspace,
458 ui::Dataspace destinationDataspace) {
459 return colorTransform != mat4() || needsToneMapping(sourceDataspace, destinationDataspace);
460}
461
Ana Krulecdfec8f52021-01-13 12:51:47 -0800462void SkiaGLRenderEngine::cacheExternalTextureBuffer(const sp<GraphicBuffer>& buffer) {
463 // Only run this if RE is running on its own thread. This way the access to GL
464 // operations is guaranteed to be happening on the same thread.
465 if (mRenderEngineType != RenderEngineType::SKIA_GL_THREADED) {
466 return;
467 }
468 ATRACE_CALL();
469
470 std::lock_guard<std::mutex> lock(mRenderingMutex);
471 auto iter = mTextureCache.find(buffer->getId());
472 if (iter != mTextureCache.end()) {
473 ALOGV("Texture already exists in cache.");
474 return;
475 } else {
476 std::shared_ptr<AutoBackendTexture::LocalRef> imageTextureRef =
477 std::make_shared<AutoBackendTexture::LocalRef>();
478 imageTextureRef->setTexture(
479 new AutoBackendTexture(mGrContext.get(), buffer->toAHardwareBuffer(), false));
480 mTextureCache.insert({buffer->getId(), imageTextureRef});
481 }
482}
483
John Reck67b1e2b2020-08-26 13:17:24 -0700484void SkiaGLRenderEngine::unbindExternalTextureBuffer(uint64_t bufferId) {
Ana Krulecdfec8f52021-01-13 12:51:47 -0800485 ATRACE_CALL();
John Reck67b1e2b2020-08-26 13:17:24 -0700486 std::lock_guard<std::mutex> lock(mRenderingMutex);
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800487 mTextureCache.erase(bufferId);
488 mProtectedTextureCache.erase(bufferId);
John Reck67b1e2b2020-08-26 13:17:24 -0700489}
490
Ana Krulec47814212021-01-06 19:00:10 -0800491sk_sp<SkShader> SkiaGLRenderEngine::createRuntimeEffectShader(sk_sp<SkShader> shader,
492 const LayerSettings* layer,
493 const DisplaySettings& display,
494 bool undoPremultipliedAlpha) {
John Reckcdb4ed72021-02-04 13:39:33 -0500495 if (layer->stretchEffect.hasEffect()) {
496 // TODO: Implement
497 }
Ana Krulec47814212021-01-06 19:00:10 -0800498 if (mUseColorManagement &&
499 needsLinearEffect(layer->colorTransform, layer->sourceDataspace, display.outputDataspace)) {
500 LinearEffect effect = LinearEffect{.inputDataspace = layer->sourceDataspace,
501 .outputDataspace = display.outputDataspace,
502 .undoPremultipliedAlpha = undoPremultipliedAlpha};
503
504 auto effectIter = mRuntimeEffects.find(effect);
505 sk_sp<SkRuntimeEffect> runtimeEffect = nullptr;
506 if (effectIter == mRuntimeEffects.end()) {
507 runtimeEffect = buildRuntimeEffect(effect);
508 mRuntimeEffects.insert({effect, runtimeEffect});
509 } else {
510 runtimeEffect = effectIter->second;
511 }
512 return createLinearEffectShader(shader, effect, runtimeEffect, layer->colorTransform,
513 display.maxLuminance,
514 layer->source.buffer.maxMasteringLuminance,
515 layer->source.buffer.maxContentLuminance);
516 }
517 return shader;
518}
519
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500520void SkiaGLRenderEngine::initCanvas(SkCanvas* canvas, const DisplaySettings& display) {
Derek Sollenberger76664d62021-02-04 11:13:09 -0500521 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500522 // Record display settings when capture is running.
523 std::stringstream displaySettings;
524 PrintTo(display, &displaySettings);
525 // Store the DisplaySettings in additional information.
526 canvas->drawAnnotation(SkRect::MakeEmpty(), "DisplaySettings",
527 SkData::MakeWithCString(displaySettings.str().c_str()));
528 }
529
530 // Before doing any drawing, let's make sure that we'll start at the origin of the display.
531 // Some displays don't start at 0,0 for example when we're mirroring the screen. Also, virtual
532 // displays might have different scaling when compared to the physical screen.
533
534 canvas->clipRect(getSkRect(display.physicalDisplay));
535 canvas->translate(display.physicalDisplay.left, display.physicalDisplay.top);
536
537 const auto clipWidth = display.clip.width();
538 const auto clipHeight = display.clip.height();
539 auto rotatedClipWidth = clipWidth;
540 auto rotatedClipHeight = clipHeight;
541 // Scale is contingent on the rotation result.
542 if (display.orientation & ui::Transform::ROT_90) {
543 std::swap(rotatedClipWidth, rotatedClipHeight);
544 }
545 const auto scaleX = static_cast<SkScalar>(display.physicalDisplay.width()) /
546 static_cast<SkScalar>(rotatedClipWidth);
547 const auto scaleY = static_cast<SkScalar>(display.physicalDisplay.height()) /
548 static_cast<SkScalar>(rotatedClipHeight);
549 canvas->scale(scaleX, scaleY);
550
551 // Canvas rotation is done by centering the clip window at the origin, rotating, translating
552 // back so that the top left corner of the clip is at (0, 0).
553 canvas->translate(rotatedClipWidth / 2, rotatedClipHeight / 2);
554 canvas->rotate(toDegrees(display.orientation));
555 canvas->translate(-clipWidth / 2, -clipHeight / 2);
556 canvas->translate(-display.clip.left, -display.clip.top);
557}
558
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500559class AutoSaveRestore {
560public:
561 AutoSaveRestore(SkCanvas* canvas) : mCanvas(canvas) { mSaveCount = canvas->save(); }
562 ~AutoSaveRestore() { restore(); }
563 void replace(SkCanvas* canvas) {
564 mCanvas = canvas;
565 mSaveCount = canvas->save();
566 }
567 void restore() {
568 if (mCanvas) {
569 mCanvas->restoreToCount(mSaveCount);
570 mCanvas = nullptr;
571 }
572 }
573
574private:
575 SkCanvas* mCanvas;
576 int mSaveCount;
577};
578
John Reck67b1e2b2020-08-26 13:17:24 -0700579status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display,
580 const std::vector<const LayerSettings*>& layers,
581 const sp<GraphicBuffer>& buffer,
582 const bool useFramebufferCache,
583 base::unique_fd&& bufferFence, base::unique_fd* drawFence) {
584 ATRACE_NAME("SkiaGL::drawLayers");
Alec Mouric0aae732021-01-12 13:32:18 -0800585
John Reck67b1e2b2020-08-26 13:17:24 -0700586 std::lock_guard<std::mutex> lock(mRenderingMutex);
587 if (layers.empty()) {
588 ALOGV("Drawing empty layer stack");
589 return NO_ERROR;
590 }
591
592 if (bufferFence.get() >= 0) {
593 // Duplicate the fence for passing to waitFence.
594 base::unique_fd bufferFenceDup(dup(bufferFence.get()));
595 if (bufferFenceDup < 0 || !waitFence(std::move(bufferFenceDup))) {
596 ATRACE_NAME("Waiting before draw");
597 sync_wait(bufferFence.get(), -1);
598 }
599 }
600 if (buffer == nullptr) {
601 ALOGE("No output buffer provided. Aborting GPU composition.");
602 return BAD_VALUE;
603 }
604
Lucas Dupind508e472020-11-04 04:32:06 +0000605 auto grContext = mInProtectedContext ? mProtectedGrContext : mGrContext;
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800606 auto& cache = mInProtectedContext ? mProtectedTextureCache : mTextureCache;
John Reck67b1e2b2020-08-26 13:17:24 -0700607 AHardwareBuffer_Desc bufferDesc;
608 AHardwareBuffer_describe(buffer->toAHardwareBuffer(), &bufferDesc);
John Reck67b1e2b2020-08-26 13:17:24 -0700609 LOG_ALWAYS_FATAL_IF(!hasUsage(bufferDesc, AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE),
610 "missing usage");
611
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800612 std::shared_ptr<AutoBackendTexture::LocalRef> surfaceTextureRef = nullptr;
John Reck67b1e2b2020-08-26 13:17:24 -0700613 if (useFramebufferCache) {
Lucas Dupind508e472020-11-04 04:32:06 +0000614 auto iter = cache.find(buffer->getId());
615 if (iter != cache.end()) {
John Reck67b1e2b2020-08-26 13:17:24 -0700616 ALOGV("Cache hit!");
Ana Krulecdfec8f52021-01-13 12:51:47 -0800617 ATRACE_NAME("Cache hit");
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800618 surfaceTextureRef = iter->second;
John Reck67b1e2b2020-08-26 13:17:24 -0700619 }
620 }
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800621
622 if (surfaceTextureRef == nullptr || surfaceTextureRef->getTexture() == nullptr) {
Ana Krulecdfec8f52021-01-13 12:51:47 -0800623 ATRACE_NAME("Cache miss");
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800624 surfaceTextureRef = std::make_shared<AutoBackendTexture::LocalRef>();
625 surfaceTextureRef->setTexture(
Alec Mouric0aae732021-01-12 13:32:18 -0800626 new AutoBackendTexture(grContext.get(), buffer->toAHardwareBuffer(), true));
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800627 if (useFramebufferCache) {
John Reck67b1e2b2020-08-26 13:17:24 -0700628 ALOGD("Adding to cache");
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800629 cache.insert({buffer->getId(), surfaceTextureRef});
John Reck67b1e2b2020-08-26 13:17:24 -0700630 }
631 }
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800632
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500633 sk_sp<SkSurface> dstSurface =
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800634 surfaceTextureRef->getTexture()->getOrCreateSurface(mUseColorManagement
635 ? display.outputDataspace
Alec Mouric0aae732021-01-12 13:32:18 -0800636 : ui::Dataspace::UNKNOWN,
637 grContext.get());
Alec Mouri678245d2020-09-30 16:58:23 -0700638
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500639 SkCanvas* dstCanvas = mCapture->tryCapture(dstSurface.get());
640 if (dstCanvas == nullptr) {
Ana Krulec6eab17a2020-12-09 15:52:36 -0800641 ALOGE("Cannot acquire canvas from Skia.");
642 return BAD_VALUE;
643 }
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500644
645 // Find if any layers have requested blur, we'll use that info to decide when to render to an
646 // offscreen buffer and when to render to the native buffer.
647 sk_sp<SkSurface> activeSurface(dstSurface);
648 SkCanvas* canvas = dstCanvas;
Derek Sollenberger76664d62021-02-04 11:13:09 -0500649 SkiaCapture::OffscreenState offscreenCaptureState;
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500650 const LayerSettings* blurCompositionLayer = nullptr;
651 if (mBlurFilter) {
652 bool requiresCompositionLayer = false;
653 for (const auto& layer : layers) {
654 if (layer->backgroundBlurRadius > 0) {
655 // when skbug.com/11208 and b/176903027 are resolved we can add the additional
656 // restriction for layer->backgroundBlurRadius < BlurFilter::kMaxCrossFadeRadius
657 requiresCompositionLayer = true;
658 }
659 for (auto region : layer->blurRegions) {
660 if (region.blurRadius < BlurFilter::kMaxCrossFadeRadius) {
661 requiresCompositionLayer = true;
662 }
663 }
664 if (requiresCompositionLayer) {
665 activeSurface = dstSurface->makeSurface(dstSurface->imageInfo());
Derek Sollenberger76664d62021-02-04 11:13:09 -0500666 canvas = mCapture->tryOffscreenCapture(activeSurface.get(), &offscreenCaptureState);
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500667 blurCompositionLayer = layer;
668 break;
669 }
670 }
671 }
672
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500673 AutoSaveRestore surfaceAutoSaveRestore(canvas);
Alec Mouri678245d2020-09-30 16:58:23 -0700674 // Clear the entire canvas with a transparent black to prevent ghost images.
675 canvas->clear(SK_ColorTRANSPARENT);
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500676 initCanvas(canvas, display);
Alec Mouric0aae732021-01-12 13:32:18 -0800677
678 // TODO: clearRegion was required for SurfaceView when a buffer is not yet available but the
679 // view is still on-screen. The clear region could be re-specified as a black color layer,
680 // however.
681 if (!display.clearRegion.isEmpty()) {
Derek Sollenberger545ec442021-01-25 10:02:23 -0500682 ATRACE_NAME("ClearRegion");
Alec Mouric0aae732021-01-12 13:32:18 -0800683 size_t numRects = 0;
684 Rect const* rects = display.clearRegion.getArray(&numRects);
685 SkIRect skRects[numRects];
686 for (int i = 0; i < numRects; ++i) {
687 skRects[i] =
688 SkIRect::MakeLTRB(rects[i].left, rects[i].top, rects[i].right, rects[i].bottom);
689 }
690 SkRegion clearRegion;
691 SkPaint paint;
692 sk_sp<SkShader> shader =
693 SkShaders::Color(SkColor4f{.fR = 0., .fG = 0., .fB = 0., .fA = 1.0},
694 toSkColorSpace(mUseColorManagement ? display.outputDataspace
695 : ui::Dataspace::UNKNOWN));
696 paint.setShader(shader);
697 clearRegion.setRects(skRects, numRects);
698 canvas->drawRegion(clearRegion, paint);
699 }
700
John Reck67b1e2b2020-08-26 13:17:24 -0700701 for (const auto& layer : layers) {
Derek Sollenberger545ec442021-01-25 10:02:23 -0500702 ATRACE_NAME("DrawLayer");
Galia Peychevaf7889b32020-11-25 22:22:40 +0100703
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500704 sk_sp<SkImage> blurInput;
705 if (blurCompositionLayer == layer) {
706 LOG_ALWAYS_FATAL_IF(activeSurface == dstSurface);
707 LOG_ALWAYS_FATAL_IF(canvas == dstCanvas);
708
709 // save a snapshot of the activeSurface to use as input to the blur shaders
710 blurInput = activeSurface->makeImageSnapshot();
711
712 // TODO we could skip this step if we know the blur will cover the entire image
713 // blit the offscreen framebuffer into the destination AHB
714 SkPaint paint;
715 paint.setBlendMode(SkBlendMode::kSrc);
Derek Sollenberger76664d62021-02-04 11:13:09 -0500716 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
717 uint64_t id = mCapture->endOffscreenCapture(&offscreenCaptureState);
718 dstCanvas->drawAnnotation(SkRect::Make(dstCanvas->imageInfo().dimensions()),
719 String8::format("SurfaceID|%" PRId64, id).c_str(),
720 nullptr);
721 dstCanvas->drawImage(blurInput, 0, 0, SkSamplingOptions(), &paint);
722 } else {
723 activeSurface->draw(dstCanvas, 0, 0, SkSamplingOptions(), &paint);
724 }
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500725
726 // assign dstCanvas to canvas and ensure that the canvas state is up to date
727 canvas = dstCanvas;
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500728 surfaceAutoSaveRestore.replace(canvas);
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500729 initCanvas(canvas, display);
730
731 LOG_ALWAYS_FATAL_IF(activeSurface->getCanvas()->getSaveCount() !=
732 dstSurface->getCanvas()->getSaveCount());
733 LOG_ALWAYS_FATAL_IF(activeSurface->getCanvas()->getTotalMatrix() !=
734 dstSurface->getCanvas()->getTotalMatrix());
735
736 // assign dstSurface to activeSurface
737 activeSurface = dstSurface;
738 }
739
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500740 SkAutoCanvasRestore layerAutoSaveRestore(canvas, true);
Derek Sollenberger76664d62021-02-04 11:13:09 -0500741 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
Ana Krulec6eab17a2020-12-09 15:52:36 -0800742 // Record the name of the layer if the capture is running.
743 std::stringstream layerSettings;
744 PrintTo(*layer, &layerSettings);
745 // Store the LayerSettings in additional information.
746 canvas->drawAnnotation(SkRect::MakeEmpty(), layer->name.c_str(),
747 SkData::MakeWithCString(layerSettings.str().c_str()));
748 }
Galia Peychevaf7889b32020-11-25 22:22:40 +0100749 // Layers have a local transform that should be applied to them
750 canvas->concat(getSkM44(layer->geometry.positionTransform).asM33());
Galia Peycheva6c460652020-11-03 19:42:42 +0100751
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500752 const auto bounds = getSkRect(layer->geometry.boundaries);
753 if (mBlurFilter && layerHasBlur(layer)) {
754 std::unordered_map<uint32_t, sk_sp<SkImage>> cachedBlurs;
755
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500756 // if multiple layers have blur, then we need to take a snapshot now because
757 // only the lowest layer will have blurImage populated earlier
758 if (!blurInput) {
759 blurInput = activeSurface->makeImageSnapshot();
760 }
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500761 // rect to be blurred in the coordinate space of blurInput
762 const auto blurRect = canvas->getTotalMatrix().mapRect(bounds);
763
Lucas Dupinc3800b82020-10-02 16:24:48 -0700764 if (layer->backgroundBlurRadius > 0) {
765 ATRACE_NAME("BackgroundBlur");
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500766 auto blurredImage =
767 mBlurFilter->generate(grContext.get(), layer->backgroundBlurRadius,
768 blurInput, blurRect);
Galia Peycheva80116e52020-11-06 11:57:25 +0100769
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500770 cachedBlurs[layer->backgroundBlurRadius] = blurredImage;
771
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500772 mBlurFilter->drawBlurRegion(canvas, getBlurRegion(layer), blurRect, blurredImage,
773 blurInput);
Lucas Dupinc3800b82020-10-02 16:24:48 -0700774 }
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500775 for (auto region : layer->blurRegions) {
Galia Peychevaa600b972021-02-19 15:50:12 +0100776 if (cachedBlurs[region.blurRadius] == nullptr) {
Lucas Dupinc3800b82020-10-02 16:24:48 -0700777 ATRACE_NAME("BlurRegion");
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500778 cachedBlurs[region.blurRadius] =
779 mBlurFilter->generate(grContext.get(), region.blurRadius, blurInput,
780 blurRect);
Lucas Dupinc3800b82020-10-02 16:24:48 -0700781 }
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500782
783 mBlurFilter->drawBlurRegion(canvas, region, blurRect,
784 cachedBlurs[region.blurRadius], blurInput);
Lucas Dupinc3800b82020-10-02 16:24:48 -0700785 }
Lucas Dupinf4cb4a02020-09-22 14:19:26 -0700786 }
787
Alec Mouric0aae732021-01-12 13:32:18 -0800788 const ui::Dataspace targetDataspace = mUseColorManagement
789 ? (needsLinearEffect(layer->colorTransform, layer->sourceDataspace,
790 display.outputDataspace)
791 // If we need to map to linear space, then mark the source image with the
792 // same colorspace as the destination surface so that Skia's color
793 // management is a no-op.
794 ? display.outputDataspace
795 : layer->sourceDataspace)
796 : ui::Dataspace::UNKNOWN;
797
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500798 SkPaint paint;
John Reck67b1e2b2020-08-26 13:17:24 -0700799 if (layer->source.buffer.buffer) {
800 ATRACE_NAME("DrawImage");
801 const auto& item = layer->source.buffer;
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800802 std::shared_ptr<AutoBackendTexture::LocalRef> imageTextureRef = nullptr;
803 auto iter = mTextureCache.find(item.buffer->getId());
804 if (iter != mTextureCache.end()) {
805 imageTextureRef = iter->second;
John Reck67b1e2b2020-08-26 13:17:24 -0700806 } else {
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800807 imageTextureRef = std::make_shared<AutoBackendTexture::LocalRef>();
Alec Mouric0aae732021-01-12 13:32:18 -0800808 imageTextureRef->setTexture(new AutoBackendTexture(grContext.get(),
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800809 item.buffer->toAHardwareBuffer(),
810 false));
Alec Mouric0aae732021-01-12 13:32:18 -0800811 mTextureCache.insert({item.buffer->getId(), imageTextureRef});
John Reck67b1e2b2020-08-26 13:17:24 -0700812 }
Alec Mouri1a4d0642020-11-13 17:42:01 -0800813
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800814 sk_sp<SkImage> image =
Alec Mouric0aae732021-01-12 13:32:18 -0800815 imageTextureRef->getTexture()->makeImage(targetDataspace,
816 item.usePremultipliedAlpha
817 ? kPremul_SkAlphaType
818 : kUnpremul_SkAlphaType,
819 grContext.get());
Alec Mouri678245d2020-09-30 16:58:23 -0700820
821 auto texMatrix = getSkM44(item.textureTransform).asM33();
822 // textureTansform was intended to be passed directly into a shader, so when
823 // building the total matrix with the textureTransform we need to first
824 // normalize it, then apply the textureTransform, then scale back up.
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500825 texMatrix.preScale(1.0f / bounds.width(), 1.0f / bounds.height());
Huihong Luo3a3cf3c2020-12-07 17:05:41 -0800826 texMatrix.postScale(image->width(), image->height());
Alec Mouri678245d2020-09-30 16:58:23 -0700827
Huihong Luo3a3cf3c2020-12-07 17:05:41 -0800828 SkMatrix matrix;
829 if (!texMatrix.invert(&matrix)) {
830 matrix = texMatrix;
Alec Mouri678245d2020-09-30 16:58:23 -0700831 }
Ana Krulecf9a15d92020-12-11 08:35:00 -0800832 // The shader does not respect the translation, so we add it to the texture
833 // transform for the SkImage. This will make sure that the correct layer contents
834 // are drawn in the correct part of the screen.
835 matrix.postTranslate(layer->geometry.boundaries.left, layer->geometry.boundaries.top);
Alec Mouri678245d2020-09-30 16:58:23 -0700836
Ana Krulecb7b28b22020-11-23 14:48:58 -0800837 sk_sp<SkShader> shader;
838
839 if (layer->source.buffer.useTextureFiltering) {
840 shader = image->makeShader(SkTileMode::kClamp, SkTileMode::kClamp,
841 SkSamplingOptions(
842 {SkFilterMode::kLinear, SkMipmapMode::kNone}),
843 &matrix);
844 } else {
Mike Reed711e1f02020-12-11 13:06:19 -0500845 shader = image->makeShader(SkSamplingOptions(), matrix);
Ana Krulecb7b28b22020-11-23 14:48:58 -0800846 }
Alec Mouri029d1952020-10-12 10:37:08 -0700847
Alec Mouric0aae732021-01-12 13:32:18 -0800848 // Handle opaque images - it's a little nonstandard how we do this.
849 // Fundamentally we need to support SurfaceControl.Builder#setOpaque:
850 // https://developer.android.com/reference/android/view/SurfaceControl.Builder#setOpaque(boolean)
851 // The important language is that when isOpaque is set, opacity is not sampled from the
852 // alpha channel, but blending may still be supported on a transaction via setAlpha. So,
853 // here's the conundrum:
854 // 1. We can't force the SkImage alpha type to kOpaque_SkAlphaType, because it's treated
855 // as an internal hint - composition is undefined when there are alpha bits present.
856 // 2. We can try to lie about the pixel layout, but that only works for RGBA8888
857 // buffers, i.e., treating them as RGBx8888 instead. But we can't do the same for
858 // RGBA1010102 because RGBx1010102 is not supported as a pixel layout for SkImages. It's
859 // also not clear what to use for F16 either, and lying about the pixel layout is a bit
860 // of a hack anyways.
861 // 3. We can't change the blendmode to src, because while this satisfies the requirement
862 // for ignoring the alpha channel, it doesn't quite satisfy the blending requirement
863 // because src always clobbers the destination content.
864 //
865 // So, what we do here instead is an additive blend mode where we compose the input
866 // image with a solid black. This might need to be reassess if this does not support
867 // FP16 incredibly well, but FP16 end-to-end isn't well supported anyway at the moment.
868 if (item.isOpaque) {
869 shader = SkShaders::Blend(SkBlendMode::kPlus, shader,
870 SkShaders::Color(SkColors::kBlack,
871 toSkColorSpace(targetDataspace)));
872 }
873
Ana Krulec47814212021-01-06 19:00:10 -0800874 paint.setShader(
875 createRuntimeEffectShader(shader, layer, display,
876 !item.isOpaque && item.usePremultipliedAlpha));
Ana Krulec1768bd22020-11-23 14:51:31 -0800877 paint.setAlphaf(layer->alpha);
John Reck67b1e2b2020-08-26 13:17:24 -0700878 } else {
879 ATRACE_NAME("DrawColor");
John Reck67b1e2b2020-08-26 13:17:24 -0700880 const auto color = layer->source.solidColor;
Ana Krulec47814212021-01-06 19:00:10 -0800881 sk_sp<SkShader> shader = SkShaders::Color(SkColor4f{.fR = color.r,
882 .fG = color.g,
883 .fB = color.b,
Alec Mouric0aae732021-01-12 13:32:18 -0800884 .fA = layer->alpha},
885 toSkColorSpace(targetDataspace));
Ana Krulec47814212021-01-06 19:00:10 -0800886 paint.setShader(createRuntimeEffectShader(shader, layer, display,
887 /* undoPremultipliedAlpha */ false));
John Reck67b1e2b2020-08-26 13:17:24 -0700888 }
Lucas Dupin21f348e2020-09-16 17:31:26 -0700889
Alec Mouri4ce5ec02021-01-07 17:33:21 -0800890 sk_sp<SkColorFilter> filter =
891 SkColorFilters::Matrix(toSkColorMatrix(display.colorTransform));
892
Alec Mouri4ce5ec02021-01-07 17:33:21 -0800893 paint.setColorFilter(filter);
Alec Mourib34f0b72020-10-02 13:18:34 -0700894
Lucas Dupin3f11e922020-09-22 17:31:04 -0700895 if (layer->shadow.length > 0) {
896 const auto rect = layer->geometry.roundedCornersRadius > 0
897 ? getSkRect(layer->geometry.roundedCornersCrop)
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500898 : bounds;
Lucas Dupin3f11e922020-09-22 17:31:04 -0700899 drawShadow(canvas, rect, layer->geometry.roundedCornersRadius, layer->shadow);
Alec Mouribd17b3b2020-12-17 11:08:30 -0800900 } else {
901 // Shadows are assumed to live only on their own layer - it's not valid
902 // to draw the boundary retangles when there is already a caster shadow
903 // TODO(b/175915334): consider relaxing this restriction to enable more flexible
904 // composition - using a well-defined invalid color is long-term less error-prone.
905 // Push the clipRRect onto the clip stack. Draw the image. Pop the clip.
906 if (layer->geometry.roundedCornersRadius > 0) {
907 canvas->clipRRect(getRoundedRect(layer), true);
908 }
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500909 canvas->drawRect(bounds, paint);
Lucas Dupin3f11e922020-09-22 17:31:04 -0700910 }
John Reck67b1e2b2020-08-26 13:17:24 -0700911 }
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500912 surfaceAutoSaveRestore.restore();
Alec Mouric0aae732021-01-12 13:32:18 -0800913 mCapture->endCapture();
John Reck67b1e2b2020-08-26 13:17:24 -0700914 {
915 ATRACE_NAME("flush surface");
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500916 LOG_ALWAYS_FATAL_IF(activeSurface != dstSurface);
917 activeSurface->flush();
John Reck67b1e2b2020-08-26 13:17:24 -0700918 }
919
920 if (drawFence != nullptr) {
921 *drawFence = flush();
922 }
923
924 // If flush failed or we don't support native fences, we need to force the
925 // gl command stream to be executed.
926 bool requireSync = drawFence == nullptr || drawFence->get() < 0;
927 if (requireSync) {
928 ATRACE_BEGIN("Submit(sync=true)");
929 } else {
930 ATRACE_BEGIN("Submit(sync=false)");
931 }
Lucas Dupind508e472020-11-04 04:32:06 +0000932 bool success = grContext->submit(requireSync);
John Reck67b1e2b2020-08-26 13:17:24 -0700933 ATRACE_END();
934 if (!success) {
935 ALOGE("Failed to flush RenderEngine commands");
936 // Chances are, something illegal happened (either the caller passed
937 // us bad parameters, or we messed up our shader generation).
938 return INVALID_OPERATION;
939 }
940
941 // checkErrors();
942 return NO_ERROR;
943}
944
Lucas Dupin3f11e922020-09-22 17:31:04 -0700945inline SkRect SkiaGLRenderEngine::getSkRect(const FloatRect& rect) {
946 return SkRect::MakeLTRB(rect.left, rect.top, rect.right, rect.bottom);
947}
948
949inline SkRect SkiaGLRenderEngine::getSkRect(const Rect& rect) {
950 return SkRect::MakeLTRB(rect.left, rect.top, rect.right, rect.bottom);
951}
952
Lucas Dupin21f348e2020-09-16 17:31:26 -0700953inline SkRRect SkiaGLRenderEngine::getRoundedRect(const LayerSettings* layer) {
Ana Krulecf9a15d92020-12-11 08:35:00 -0800954 const auto rect = getSkRect(layer->geometry.roundedCornersCrop);
Lucas Dupin21f348e2020-09-16 17:31:26 -0700955 const auto cornerRadius = layer->geometry.roundedCornersRadius;
956 return SkRRect::MakeRectXY(rect, cornerRadius, cornerRadius);
957}
958
Galia Peycheva80116e52020-11-06 11:57:25 +0100959inline BlurRegion SkiaGLRenderEngine::getBlurRegion(const LayerSettings* layer) {
960 const auto rect = getSkRect(layer->geometry.boundaries);
961 const auto cornersRadius = layer->geometry.roundedCornersRadius;
962 return BlurRegion{.blurRadius = static_cast<uint32_t>(layer->backgroundBlurRadius),
963 .cornerRadiusTL = cornersRadius,
964 .cornerRadiusTR = cornersRadius,
965 .cornerRadiusBL = cornersRadius,
966 .cornerRadiusBR = cornersRadius,
967 .alpha = 1,
968 .left = static_cast<int>(rect.fLeft),
969 .top = static_cast<int>(rect.fTop),
970 .right = static_cast<int>(rect.fRight),
971 .bottom = static_cast<int>(rect.fBottom)};
972}
973
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500974inline bool SkiaGLRenderEngine::layerHasBlur(const LayerSettings* layer) {
975 return layer->backgroundBlurRadius > 0 || layer->blurRegions.size();
976}
977
Lucas Dupin3f11e922020-09-22 17:31:04 -0700978inline SkColor SkiaGLRenderEngine::getSkColor(const vec4& color) {
979 return SkColorSetARGB(color.a * 255, color.r * 255, color.g * 255, color.b * 255);
980}
981
Lucas Dupinbb1a1d42020-09-18 15:17:02 -0700982inline SkM44 SkiaGLRenderEngine::getSkM44(const mat4& matrix) {
983 return SkM44(matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0],
984 matrix[0][1], matrix[1][1], matrix[2][1], matrix[3][1],
985 matrix[0][2], matrix[1][2], matrix[2][2], matrix[3][2],
986 matrix[0][3], matrix[1][3], matrix[2][3], matrix[3][3]);
987}
988
Lucas Dupin3f11e922020-09-22 17:31:04 -0700989inline SkPoint3 SkiaGLRenderEngine::getSkPoint3(const vec3& vector) {
990 return SkPoint3::Make(vector.x, vector.y, vector.z);
991}
992
John Reck67b1e2b2020-08-26 13:17:24 -0700993size_t SkiaGLRenderEngine::getMaxTextureSize() const {
994 return mGrContext->maxTextureSize();
995}
996
997size_t SkiaGLRenderEngine::getMaxViewportDims() const {
998 return mGrContext->maxRenderTargetSize();
999}
1000
Lucas Dupin3f11e922020-09-22 17:31:04 -07001001void SkiaGLRenderEngine::drawShadow(SkCanvas* canvas, const SkRect& casterRect, float cornerRadius,
1002 const ShadowSettings& settings) {
1003 ATRACE_CALL();
1004 const float casterZ = settings.length / 2.0f;
1005 const auto shadowShape = cornerRadius > 0
1006 ? SkPath::RRect(SkRRect::MakeRectXY(casterRect, cornerRadius, cornerRadius))
1007 : SkPath::Rect(casterRect);
1008 const auto flags =
1009 settings.casterIsTranslucent ? kTransparentOccluder_ShadowFlag : kNone_ShadowFlag;
1010
1011 SkShadowUtils::DrawShadow(canvas, shadowShape, SkPoint3::Make(0, 0, casterZ),
1012 getSkPoint3(settings.lightPos), settings.lightRadius,
1013 getSkColor(settings.ambientColor), getSkColor(settings.spotColor),
1014 flags);
1015}
1016
John Reck67b1e2b2020-08-26 13:17:24 -07001017EGLContext SkiaGLRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,
Alec Mourid6f09462020-12-07 11:18:17 -08001018 EGLContext shareContext,
1019 std::optional<ContextPriority> contextPriority,
John Reck67b1e2b2020-08-26 13:17:24 -07001020 Protection protection) {
1021 EGLint renderableType = 0;
1022 if (config == EGL_NO_CONFIG_KHR) {
1023 renderableType = EGL_OPENGL_ES3_BIT;
1024 } else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) {
1025 LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");
1026 }
1027 EGLint contextClientVersion = 0;
1028 if (renderableType & EGL_OPENGL_ES3_BIT) {
1029 contextClientVersion = 3;
1030 } else if (renderableType & EGL_OPENGL_ES2_BIT) {
1031 contextClientVersion = 2;
1032 } else if (renderableType & EGL_OPENGL_ES_BIT) {
1033 contextClientVersion = 1;
1034 } else {
1035 LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs");
1036 }
1037
1038 std::vector<EGLint> contextAttributes;
1039 contextAttributes.reserve(7);
1040 contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
1041 contextAttributes.push_back(contextClientVersion);
Alec Mourid6f09462020-12-07 11:18:17 -08001042 if (contextPriority) {
John Reck67b1e2b2020-08-26 13:17:24 -07001043 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG);
Alec Mourid6f09462020-12-07 11:18:17 -08001044 switch (*contextPriority) {
1045 case ContextPriority::REALTIME:
1046 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_REALTIME_NV);
1047 break;
1048 case ContextPriority::MEDIUM:
1049 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_MEDIUM_IMG);
1050 break;
1051 case ContextPriority::LOW:
1052 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LOW_IMG);
1053 break;
1054 case ContextPriority::HIGH:
1055 default:
1056 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG);
1057 break;
1058 }
John Reck67b1e2b2020-08-26 13:17:24 -07001059 }
1060 if (protection == Protection::PROTECTED) {
1061 contextAttributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1062 contextAttributes.push_back(EGL_TRUE);
1063 }
1064 contextAttributes.push_back(EGL_NONE);
1065
1066 EGLContext context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1067
1068 if (contextClientVersion == 3 && context == EGL_NO_CONTEXT) {
1069 // eglGetConfigAttrib indicated we can create GLES 3 context, but we failed, thus
1070 // EGL_NO_CONTEXT so that we can abort.
1071 if (config != EGL_NO_CONFIG_KHR) {
1072 return context;
1073 }
1074 // If |config| is EGL_NO_CONFIG_KHR, we speculatively try to create GLES 3 context, so we
1075 // should try to fall back to GLES 2.
1076 contextAttributes[1] = 2;
1077 context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1078 }
1079
1080 return context;
1081}
1082
Alec Mourid6f09462020-12-07 11:18:17 -08001083std::optional<RenderEngine::ContextPriority> SkiaGLRenderEngine::createContextPriority(
1084 const RenderEngineCreationArgs& args) {
1085 if (!gl::GLExtensions::getInstance().hasContextPriority()) {
1086 return std::nullopt;
1087 }
1088
1089 switch (args.contextPriority) {
1090 case RenderEngine::ContextPriority::REALTIME:
1091 if (gl::GLExtensions::getInstance().hasRealtimePriority()) {
1092 return RenderEngine::ContextPriority::REALTIME;
1093 } else {
1094 ALOGI("Realtime priority unsupported, degrading gracefully to high priority");
1095 return RenderEngine::ContextPriority::HIGH;
1096 }
1097 case RenderEngine::ContextPriority::HIGH:
1098 case RenderEngine::ContextPriority::MEDIUM:
1099 case RenderEngine::ContextPriority::LOW:
1100 return args.contextPriority;
1101 default:
1102 return std::nullopt;
1103 }
1104}
1105
John Reck67b1e2b2020-08-26 13:17:24 -07001106EGLSurface SkiaGLRenderEngine::createPlaceholderEglPbufferSurface(EGLDisplay display,
1107 EGLConfig config, int hwcFormat,
1108 Protection protection) {
1109 EGLConfig placeholderConfig = config;
1110 if (placeholderConfig == EGL_NO_CONFIG_KHR) {
1111 placeholderConfig = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);
1112 }
1113 std::vector<EGLint> attributes;
1114 attributes.reserve(7);
1115 attributes.push_back(EGL_WIDTH);
1116 attributes.push_back(1);
1117 attributes.push_back(EGL_HEIGHT);
1118 attributes.push_back(1);
1119 if (protection == Protection::PROTECTED) {
1120 attributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1121 attributes.push_back(EGL_TRUE);
1122 }
1123 attributes.push_back(EGL_NONE);
1124
1125 return eglCreatePbufferSurface(display, placeholderConfig, attributes.data());
1126}
1127
Alec Mouric7f6c8b2020-11-09 18:35:20 -08001128void SkiaGLRenderEngine::cleanFramebufferCache() {}
John Reck67b1e2b2020-08-26 13:17:24 -07001129
Alec Mourid6f09462020-12-07 11:18:17 -08001130int SkiaGLRenderEngine::getContextPriority() {
1131 int value;
1132 eglQueryContext(mEGLDisplay, mEGLContext, EGL_CONTEXT_PRIORITY_LEVEL_IMG, &value);
1133 return value;
1134}
1135
Ana Krulec1d12b3b2021-01-27 16:49:51 -08001136void SkiaGLRenderEngine::dump(std::string& result) {
1137 const gl::GLExtensions& extensions = gl::GLExtensions::getInstance();
1138
1139 StringAppendF(&result, "\n ------------RE-----------------\n");
1140 StringAppendF(&result, "EGL implementation : %s\n", extensions.getEGLVersion());
1141 StringAppendF(&result, "%s\n", extensions.getEGLExtensions());
1142 StringAppendF(&result, "GLES: %s, %s, %s\n", extensions.getVendor(), extensions.getRenderer(),
1143 extensions.getVersion());
1144 StringAppendF(&result, "%s\n", extensions.getExtensions());
1145 StringAppendF(&result, "RenderEngine supports protected context: %d\n",
1146 supportsProtectedContent());
1147 StringAppendF(&result, "RenderEngine is in protected context: %d\n", mInProtectedContext);
1148
1149 {
1150 std::lock_guard<std::mutex> lock(mRenderingMutex);
1151 StringAppendF(&result, "RenderEngine texture cache size: %zu\n", mTextureCache.size());
1152 StringAppendF(&result, "Dumping buffer ids...\n");
1153 // TODO(178539829): It would be nice to know which layer these are coming from and what
1154 // the texture sizes are.
1155 for (const auto& [id, unused] : mTextureCache) {
1156 StringAppendF(&result, "- 0x%" PRIx64 "\n", id);
1157 }
1158 StringAppendF(&result, "\n");
1159 StringAppendF(&result, "RenderEngine protected texture cache size: %zu\n",
1160 mProtectedTextureCache.size());
1161 StringAppendF(&result, "Dumping buffer ids...\n");
1162 for (const auto& [id, unused] : mProtectedTextureCache) {
1163 StringAppendF(&result, "- 0x%" PRIx64 "\n", id);
1164 }
1165 StringAppendF(&result, "\n");
1166 StringAppendF(&result, "RenderEngine runtime effects: %zu\n", mRuntimeEffects.size());
1167 for (const auto& [linearEffect, unused] : mRuntimeEffects) {
1168 StringAppendF(&result, "- inputDataspace: %s\n",
1169 dataspaceDetails(
1170 static_cast<android_dataspace>(linearEffect.inputDataspace))
1171 .c_str());
1172 StringAppendF(&result, "- outputDataspace: %s\n",
1173 dataspaceDetails(
1174 static_cast<android_dataspace>(linearEffect.outputDataspace))
1175 .c_str());
1176 StringAppendF(&result, "undoPremultipliedAlpha: %s\n",
1177 linearEffect.undoPremultipliedAlpha ? "true" : "false");
1178 }
1179 }
1180 StringAppendF(&result, "\n");
1181}
1182
John Reck67b1e2b2020-08-26 13:17:24 -07001183} // namespace skia
1184} // namespace renderengine
Galia Peycheva6c460652020-11-03 19:42:42 +01001185} // namespace android