blob: 91b163eda86f90b87150fcb813ea97adfed7801c [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 Mouri0d995102021-02-24 16:53:38 -0800269 : SkiaRenderEngine(args.renderEngineType),
270 mEGLDisplay(display),
John Reck67b1e2b2020-08-26 13:17:24 -0700271 mEGLContext(ctxt),
272 mPlaceholderSurface(placeholder),
273 mProtectedEGLContext(protectedContext),
Alec Mourib5777452020-09-28 11:32:42 -0700274 mProtectedPlaceholderSurface(protectedPlaceholder),
Alec Mouri0d995102021-02-24 16:53:38 -0800275 mUseColorManagement(args.useColorManagement) {
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
Alec Mouri678245d2020-09-30 16:58:23 -0700407static float toDegrees(uint32_t transform) {
408 switch (transform) {
409 case ui::Transform::ROT_90:
410 return 90.0;
411 case ui::Transform::ROT_180:
412 return 180.0;
413 case ui::Transform::ROT_270:
414 return 270.0;
415 default:
416 return 0.0;
417 }
418}
419
Alec Mourib34f0b72020-10-02 13:18:34 -0700420static SkColorMatrix toSkColorMatrix(const mat4& matrix) {
421 return SkColorMatrix(matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0], 0, matrix[0][1],
422 matrix[1][1], matrix[2][1], matrix[3][1], 0, matrix[0][2], matrix[1][2],
423 matrix[2][2], matrix[3][2], 0, matrix[0][3], matrix[1][3], matrix[2][3],
424 matrix[3][3], 0);
425}
426
Alec Mouri029d1952020-10-12 10:37:08 -0700427static bool needsToneMapping(ui::Dataspace sourceDataspace, ui::Dataspace destinationDataspace) {
428 int64_t sourceTransfer = sourceDataspace & HAL_DATASPACE_TRANSFER_MASK;
429 int64_t destTransfer = destinationDataspace & HAL_DATASPACE_TRANSFER_MASK;
430
431 // Treat unsupported dataspaces as srgb
432 if (destTransfer != HAL_DATASPACE_TRANSFER_LINEAR &&
433 destTransfer != HAL_DATASPACE_TRANSFER_HLG &&
434 destTransfer != HAL_DATASPACE_TRANSFER_ST2084) {
435 destTransfer = HAL_DATASPACE_TRANSFER_SRGB;
436 }
437
438 if (sourceTransfer != HAL_DATASPACE_TRANSFER_LINEAR &&
439 sourceTransfer != HAL_DATASPACE_TRANSFER_HLG &&
440 sourceTransfer != HAL_DATASPACE_TRANSFER_ST2084) {
441 sourceTransfer = HAL_DATASPACE_TRANSFER_SRGB;
442 }
443
444 const bool isSourceLinear = sourceTransfer == HAL_DATASPACE_TRANSFER_LINEAR;
445 const bool isSourceSRGB = sourceTransfer == HAL_DATASPACE_TRANSFER_SRGB;
446 const bool isDestLinear = destTransfer == HAL_DATASPACE_TRANSFER_LINEAR;
447 const bool isDestSRGB = destTransfer == HAL_DATASPACE_TRANSFER_SRGB;
448
449 return !(isSourceLinear && isDestSRGB) && !(isSourceSRGB && isDestLinear) &&
450 sourceTransfer != destTransfer;
451}
452
Ana Krulecdfec8f52021-01-13 12:51:47 -0800453void SkiaGLRenderEngine::cacheExternalTextureBuffer(const sp<GraphicBuffer>& buffer) {
454 // Only run this if RE is running on its own thread. This way the access to GL
455 // operations is guaranteed to be happening on the same thread.
456 if (mRenderEngineType != RenderEngineType::SKIA_GL_THREADED) {
457 return;
458 }
459 ATRACE_CALL();
460
461 std::lock_guard<std::mutex> lock(mRenderingMutex);
462 auto iter = mTextureCache.find(buffer->getId());
463 if (iter != mTextureCache.end()) {
464 ALOGV("Texture already exists in cache.");
465 return;
466 } else {
467 std::shared_ptr<AutoBackendTexture::LocalRef> imageTextureRef =
468 std::make_shared<AutoBackendTexture::LocalRef>();
469 imageTextureRef->setTexture(
470 new AutoBackendTexture(mGrContext.get(), buffer->toAHardwareBuffer(), false));
471 mTextureCache.insert({buffer->getId(), imageTextureRef});
472 }
473}
474
John Reck67b1e2b2020-08-26 13:17:24 -0700475void SkiaGLRenderEngine::unbindExternalTextureBuffer(uint64_t bufferId) {
Ana Krulecdfec8f52021-01-13 12:51:47 -0800476 ATRACE_CALL();
John Reck67b1e2b2020-08-26 13:17:24 -0700477 std::lock_guard<std::mutex> lock(mRenderingMutex);
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800478 mTextureCache.erase(bufferId);
479 mProtectedTextureCache.erase(bufferId);
John Reck67b1e2b2020-08-26 13:17:24 -0700480}
481
Ana Krulec47814212021-01-06 19:00:10 -0800482sk_sp<SkShader> SkiaGLRenderEngine::createRuntimeEffectShader(sk_sp<SkShader> shader,
483 const LayerSettings* layer,
484 const DisplaySettings& display,
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500485 bool undoPremultipliedAlpha,
486 bool requiresLinearEffect) {
John Reckcdb4ed72021-02-04 13:39:33 -0500487 if (layer->stretchEffect.hasEffect()) {
488 // TODO: Implement
489 }
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500490 if (requiresLinearEffect) {
491 const ui::Dataspace inputDataspace =
492 mUseColorManagement ? layer->sourceDataspace : ui::Dataspace::UNKNOWN;
493 const ui::Dataspace outputDataspace =
494 mUseColorManagement ? display.outputDataspace : ui::Dataspace::UNKNOWN;
495
496 LinearEffect effect = LinearEffect{.inputDataspace = inputDataspace,
497 .outputDataspace = outputDataspace,
Ana Krulec47814212021-01-06 19:00:10 -0800498 .undoPremultipliedAlpha = undoPremultipliedAlpha};
499
500 auto effectIter = mRuntimeEffects.find(effect);
501 sk_sp<SkRuntimeEffect> runtimeEffect = nullptr;
502 if (effectIter == mRuntimeEffects.end()) {
503 runtimeEffect = buildRuntimeEffect(effect);
504 mRuntimeEffects.insert({effect, runtimeEffect});
505 } else {
506 runtimeEffect = effectIter->second;
507 }
508 return createLinearEffectShader(shader, effect, runtimeEffect, layer->colorTransform,
509 display.maxLuminance,
510 layer->source.buffer.maxMasteringLuminance,
511 layer->source.buffer.maxContentLuminance);
512 }
513 return shader;
514}
515
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500516void SkiaGLRenderEngine::initCanvas(SkCanvas* canvas, const DisplaySettings& display) {
Derek Sollenberger76664d62021-02-04 11:13:09 -0500517 if (CC_UNLIKELY(mCapture->isCaptureRunning())) {
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500518 // Record display settings when capture is running.
519 std::stringstream displaySettings;
520 PrintTo(display, &displaySettings);
521 // Store the DisplaySettings in additional information.
522 canvas->drawAnnotation(SkRect::MakeEmpty(), "DisplaySettings",
523 SkData::MakeWithCString(displaySettings.str().c_str()));
524 }
525
526 // Before doing any drawing, let's make sure that we'll start at the origin of the display.
527 // Some displays don't start at 0,0 for example when we're mirroring the screen. Also, virtual
528 // displays might have different scaling when compared to the physical screen.
529
530 canvas->clipRect(getSkRect(display.physicalDisplay));
531 canvas->translate(display.physicalDisplay.left, display.physicalDisplay.top);
532
533 const auto clipWidth = display.clip.width();
534 const auto clipHeight = display.clip.height();
535 auto rotatedClipWidth = clipWidth;
536 auto rotatedClipHeight = clipHeight;
537 // Scale is contingent on the rotation result.
538 if (display.orientation & ui::Transform::ROT_90) {
539 std::swap(rotatedClipWidth, rotatedClipHeight);
540 }
541 const auto scaleX = static_cast<SkScalar>(display.physicalDisplay.width()) /
542 static_cast<SkScalar>(rotatedClipWidth);
543 const auto scaleY = static_cast<SkScalar>(display.physicalDisplay.height()) /
544 static_cast<SkScalar>(rotatedClipHeight);
545 canvas->scale(scaleX, scaleY);
546
547 // Canvas rotation is done by centering the clip window at the origin, rotating, translating
548 // back so that the top left corner of the clip is at (0, 0).
549 canvas->translate(rotatedClipWidth / 2, rotatedClipHeight / 2);
550 canvas->rotate(toDegrees(display.orientation));
551 canvas->translate(-clipWidth / 2, -clipHeight / 2);
552 canvas->translate(-display.clip.left, -display.clip.top);
553}
554
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500555class AutoSaveRestore {
556public:
557 AutoSaveRestore(SkCanvas* canvas) : mCanvas(canvas) { mSaveCount = canvas->save(); }
558 ~AutoSaveRestore() { restore(); }
559 void replace(SkCanvas* canvas) {
560 mCanvas = canvas;
561 mSaveCount = canvas->save();
562 }
563 void restore() {
564 if (mCanvas) {
565 mCanvas->restoreToCount(mSaveCount);
566 mCanvas = nullptr;
567 }
568 }
569
570private:
571 SkCanvas* mCanvas;
572 int mSaveCount;
573};
574
John Reck67b1e2b2020-08-26 13:17:24 -0700575status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display,
576 const std::vector<const LayerSettings*>& layers,
577 const sp<GraphicBuffer>& buffer,
578 const bool useFramebufferCache,
579 base::unique_fd&& bufferFence, base::unique_fd* drawFence) {
580 ATRACE_NAME("SkiaGL::drawLayers");
Alec Mouric0aae732021-01-12 13:32:18 -0800581
John Reck67b1e2b2020-08-26 13:17:24 -0700582 std::lock_guard<std::mutex> lock(mRenderingMutex);
583 if (layers.empty()) {
584 ALOGV("Drawing empty layer stack");
585 return NO_ERROR;
586 }
587
588 if (bufferFence.get() >= 0) {
589 // Duplicate the fence for passing to waitFence.
590 base::unique_fd bufferFenceDup(dup(bufferFence.get()));
591 if (bufferFenceDup < 0 || !waitFence(std::move(bufferFenceDup))) {
592 ATRACE_NAME("Waiting before draw");
593 sync_wait(bufferFence.get(), -1);
594 }
595 }
596 if (buffer == nullptr) {
597 ALOGE("No output buffer provided. Aborting GPU composition.");
598 return BAD_VALUE;
599 }
600
Ady Abraham193426d2021-02-18 14:01:53 -0800601 validateOutputBufferUsage(buffer);
602
Lucas Dupind508e472020-11-04 04:32:06 +0000603 auto grContext = mInProtectedContext ? mProtectedGrContext : mGrContext;
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800604 auto& cache = mInProtectedContext ? mProtectedTextureCache : mTextureCache;
John Reck67b1e2b2020-08-26 13:17:24 -0700605 AHardwareBuffer_Desc bufferDesc;
606 AHardwareBuffer_describe(buffer->toAHardwareBuffer(), &bufferDesc);
John Reck67b1e2b2020-08-26 13:17:24 -0700607
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800608 std::shared_ptr<AutoBackendTexture::LocalRef> surfaceTextureRef = nullptr;
John Reck67b1e2b2020-08-26 13:17:24 -0700609 if (useFramebufferCache) {
Lucas Dupind508e472020-11-04 04:32:06 +0000610 auto iter = cache.find(buffer->getId());
611 if (iter != cache.end()) {
John Reck67b1e2b2020-08-26 13:17:24 -0700612 ALOGV("Cache hit!");
Ana Krulecdfec8f52021-01-13 12:51:47 -0800613 ATRACE_NAME("Cache hit");
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800614 surfaceTextureRef = iter->second;
John Reck67b1e2b2020-08-26 13:17:24 -0700615 }
616 }
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800617
618 if (surfaceTextureRef == nullptr || surfaceTextureRef->getTexture() == nullptr) {
Ana Krulecdfec8f52021-01-13 12:51:47 -0800619 ATRACE_NAME("Cache miss");
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800620 surfaceTextureRef = std::make_shared<AutoBackendTexture::LocalRef>();
621 surfaceTextureRef->setTexture(
Alec Mouric0aae732021-01-12 13:32:18 -0800622 new AutoBackendTexture(grContext.get(), buffer->toAHardwareBuffer(), true));
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800623 if (useFramebufferCache) {
John Reck67b1e2b2020-08-26 13:17:24 -0700624 ALOGD("Adding to cache");
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800625 cache.insert({buffer->getId(), surfaceTextureRef});
John Reck67b1e2b2020-08-26 13:17:24 -0700626 }
627 }
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800628
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500629 const ui::Dataspace dstDataspace =
630 mUseColorManagement ? display.outputDataspace : ui::Dataspace::UNKNOWN;
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500631 sk_sp<SkSurface> dstSurface =
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500632 surfaceTextureRef->getTexture()->getOrCreateSurface(dstDataspace, grContext.get());
Alec Mouri678245d2020-09-30 16:58:23 -0700633
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500634 SkCanvas* dstCanvas = mCapture->tryCapture(dstSurface.get());
635 if (dstCanvas == nullptr) {
Ana Krulec6eab17a2020-12-09 15:52:36 -0800636 ALOGE("Cannot acquire canvas from Skia.");
637 return BAD_VALUE;
638 }
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500639
640 // Find if any layers have requested blur, we'll use that info to decide when to render to an
641 // offscreen buffer and when to render to the native buffer.
642 sk_sp<SkSurface> activeSurface(dstSurface);
643 SkCanvas* canvas = dstCanvas;
Derek Sollenberger76664d62021-02-04 11:13:09 -0500644 SkiaCapture::OffscreenState offscreenCaptureState;
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500645 const LayerSettings* blurCompositionLayer = nullptr;
646 if (mBlurFilter) {
647 bool requiresCompositionLayer = false;
648 for (const auto& layer : layers) {
649 if (layer->backgroundBlurRadius > 0) {
650 // when skbug.com/11208 and b/176903027 are resolved we can add the additional
651 // restriction for layer->backgroundBlurRadius < BlurFilter::kMaxCrossFadeRadius
652 requiresCompositionLayer = true;
653 }
654 for (auto region : layer->blurRegions) {
655 if (region.blurRadius < BlurFilter::kMaxCrossFadeRadius) {
656 requiresCompositionLayer = true;
657 }
658 }
659 if (requiresCompositionLayer) {
660 activeSurface = dstSurface->makeSurface(dstSurface->imageInfo());
Derek Sollenberger76664d62021-02-04 11:13:09 -0500661 canvas = mCapture->tryOffscreenCapture(activeSurface.get(), &offscreenCaptureState);
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500662 blurCompositionLayer = layer;
663 break;
664 }
665 }
666 }
667
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500668 AutoSaveRestore surfaceAutoSaveRestore(canvas);
Alec Mouri678245d2020-09-30 16:58:23 -0700669 // Clear the entire canvas with a transparent black to prevent ghost images.
670 canvas->clear(SK_ColorTRANSPARENT);
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500671 initCanvas(canvas, display);
Alec Mouric0aae732021-01-12 13:32:18 -0800672
673 // TODO: clearRegion was required for SurfaceView when a buffer is not yet available but the
674 // view is still on-screen. The clear region could be re-specified as a black color layer,
675 // however.
676 if (!display.clearRegion.isEmpty()) {
Derek Sollenberger545ec442021-01-25 10:02:23 -0500677 ATRACE_NAME("ClearRegion");
Alec Mouric0aae732021-01-12 13:32:18 -0800678 size_t numRects = 0;
679 Rect const* rects = display.clearRegion.getArray(&numRects);
680 SkIRect skRects[numRects];
681 for (int i = 0; i < numRects; ++i) {
682 skRects[i] =
683 SkIRect::MakeLTRB(rects[i].left, rects[i].top, rects[i].right, rects[i].bottom);
684 }
685 SkRegion clearRegion;
686 SkPaint paint;
687 sk_sp<SkShader> shader =
688 SkShaders::Color(SkColor4f{.fR = 0., .fG = 0., .fB = 0., .fA = 1.0},
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500689 toSkColorSpace(dstDataspace));
Alec Mouric0aae732021-01-12 13:32:18 -0800690 paint.setShader(shader);
691 clearRegion.setRects(skRects, numRects);
692 canvas->drawRegion(clearRegion, paint);
693 }
694
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500695 // setup color filter if necessary
696 sk_sp<SkColorFilter> displayColorTransform;
697 if (display.colorTransform != mat4()) {
698 displayColorTransform = SkColorFilters::Matrix(toSkColorMatrix(display.colorTransform));
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
Derek Sollenberger4c331c82021-02-23 13:09:50 -0500788 // Shadows are assumed to live only on their own layer - it's not valid
789 // to draw the boundary rectangles when there is already a caster shadow
790 // TODO(b/175915334): consider relaxing this restriction to enable more flexible
791 // composition - using a well-defined invalid color is long-term less error-prone.
792 if (layer->shadow.length > 0) {
793 const auto rect = layer->geometry.roundedCornersRadius > 0
794 ? getSkRect(layer->geometry.roundedCornersCrop)
795 : bounds;
796 drawShadow(canvas, rect, layer->geometry.roundedCornersRadius, layer->shadow);
797 continue;
798 }
799
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500800 const bool requiresLinearEffect = layer->colorTransform != mat4() ||
801 (mUseColorManagement &&
802 needsToneMapping(layer->sourceDataspace, display.outputDataspace));
803
804 // quick abort from drawing the remaining portion of the layer
805 if (layer->alpha == 0 && !requiresLinearEffect &&
806 (!displayColorTransform || displayColorTransform->isAlphaUnchanged())) {
807 continue;
808 }
809
810 // If we need to map to linear space or color management is disabled, then mark the source
811 // image with the same colorspace as the destination surface so that Skia's color
812 // management is a no-op.
813 const ui::Dataspace layerDataspace = (!mUseColorManagement || requiresLinearEffect)
814 ? dstDataspace
815 : layer->sourceDataspace;
Alec Mouric0aae732021-01-12 13:32:18 -0800816
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500817 SkPaint paint;
John Reck67b1e2b2020-08-26 13:17:24 -0700818 if (layer->source.buffer.buffer) {
819 ATRACE_NAME("DrawImage");
Ady Abraham193426d2021-02-18 14:01:53 -0800820 validateInputBufferUsage(layer->source.buffer.buffer);
John Reck67b1e2b2020-08-26 13:17:24 -0700821 const auto& item = layer->source.buffer;
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800822 std::shared_ptr<AutoBackendTexture::LocalRef> imageTextureRef = nullptr;
823 auto iter = mTextureCache.find(item.buffer->getId());
824 if (iter != mTextureCache.end()) {
825 imageTextureRef = iter->second;
John Reck67b1e2b2020-08-26 13:17:24 -0700826 } else {
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800827 imageTextureRef = std::make_shared<AutoBackendTexture::LocalRef>();
Alec Mouric0aae732021-01-12 13:32:18 -0800828 imageTextureRef->setTexture(new AutoBackendTexture(grContext.get(),
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800829 item.buffer->toAHardwareBuffer(),
830 false));
Alec Mouric0aae732021-01-12 13:32:18 -0800831 mTextureCache.insert({item.buffer->getId(), imageTextureRef});
John Reck67b1e2b2020-08-26 13:17:24 -0700832 }
Alec Mouri1a4d0642020-11-13 17:42:01 -0800833
Alec Mouric7f6c8b2020-11-09 18:35:20 -0800834 sk_sp<SkImage> image =
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500835 imageTextureRef->getTexture()->makeImage(layerDataspace,
Alec Mouric0aae732021-01-12 13:32:18 -0800836 item.usePremultipliedAlpha
837 ? kPremul_SkAlphaType
838 : kUnpremul_SkAlphaType,
839 grContext.get());
Alec Mouri678245d2020-09-30 16:58:23 -0700840
841 auto texMatrix = getSkM44(item.textureTransform).asM33();
842 // textureTansform was intended to be passed directly into a shader, so when
843 // building the total matrix with the textureTransform we need to first
844 // normalize it, then apply the textureTransform, then scale back up.
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500845 texMatrix.preScale(1.0f / bounds.width(), 1.0f / bounds.height());
Huihong Luo3a3cf3c2020-12-07 17:05:41 -0800846 texMatrix.postScale(image->width(), image->height());
Alec Mouri678245d2020-09-30 16:58:23 -0700847
Huihong Luo3a3cf3c2020-12-07 17:05:41 -0800848 SkMatrix matrix;
849 if (!texMatrix.invert(&matrix)) {
850 matrix = texMatrix;
Alec Mouri678245d2020-09-30 16:58:23 -0700851 }
Ana Krulecf9a15d92020-12-11 08:35:00 -0800852 // The shader does not respect the translation, so we add it to the texture
853 // transform for the SkImage. This will make sure that the correct layer contents
854 // are drawn in the correct part of the screen.
855 matrix.postTranslate(layer->geometry.boundaries.left, layer->geometry.boundaries.top);
Alec Mouri678245d2020-09-30 16:58:23 -0700856
Ana Krulecb7b28b22020-11-23 14:48:58 -0800857 sk_sp<SkShader> shader;
858
859 if (layer->source.buffer.useTextureFiltering) {
860 shader = image->makeShader(SkTileMode::kClamp, SkTileMode::kClamp,
861 SkSamplingOptions(
862 {SkFilterMode::kLinear, SkMipmapMode::kNone}),
863 &matrix);
864 } else {
Mike Reed711e1f02020-12-11 13:06:19 -0500865 shader = image->makeShader(SkSamplingOptions(), matrix);
Ana Krulecb7b28b22020-11-23 14:48:58 -0800866 }
Alec Mouri029d1952020-10-12 10:37:08 -0700867
Alec Mouric0aae732021-01-12 13:32:18 -0800868 // Handle opaque images - it's a little nonstandard how we do this.
869 // Fundamentally we need to support SurfaceControl.Builder#setOpaque:
870 // https://developer.android.com/reference/android/view/SurfaceControl.Builder#setOpaque(boolean)
871 // The important language is that when isOpaque is set, opacity is not sampled from the
872 // alpha channel, but blending may still be supported on a transaction via setAlpha. So,
873 // here's the conundrum:
874 // 1. We can't force the SkImage alpha type to kOpaque_SkAlphaType, because it's treated
875 // as an internal hint - composition is undefined when there are alpha bits present.
876 // 2. We can try to lie about the pixel layout, but that only works for RGBA8888
877 // buffers, i.e., treating them as RGBx8888 instead. But we can't do the same for
878 // RGBA1010102 because RGBx1010102 is not supported as a pixel layout for SkImages. It's
879 // also not clear what to use for F16 either, and lying about the pixel layout is a bit
880 // of a hack anyways.
881 // 3. We can't change the blendmode to src, because while this satisfies the requirement
882 // for ignoring the alpha channel, it doesn't quite satisfy the blending requirement
883 // because src always clobbers the destination content.
884 //
885 // So, what we do here instead is an additive blend mode where we compose the input
886 // image with a solid black. This might need to be reassess if this does not support
887 // FP16 incredibly well, but FP16 end-to-end isn't well supported anyway at the moment.
888 if (item.isOpaque) {
889 shader = SkShaders::Blend(SkBlendMode::kPlus, shader,
890 SkShaders::Color(SkColors::kBlack,
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500891 toSkColorSpace(layerDataspace)));
Alec Mouric0aae732021-01-12 13:32:18 -0800892 }
893
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500894 paint.setShader(createRuntimeEffectShader(shader, layer, display,
895 !item.isOpaque && item.usePremultipliedAlpha,
896 requiresLinearEffect));
Ana Krulec1768bd22020-11-23 14:51:31 -0800897 paint.setAlphaf(layer->alpha);
John Reck67b1e2b2020-08-26 13:17:24 -0700898 } else {
899 ATRACE_NAME("DrawColor");
John Reck67b1e2b2020-08-26 13:17:24 -0700900 const auto color = layer->source.solidColor;
Ana Krulec47814212021-01-06 19:00:10 -0800901 sk_sp<SkShader> shader = SkShaders::Color(SkColor4f{.fR = color.r,
902 .fG = color.g,
903 .fB = color.b,
Alec Mouric0aae732021-01-12 13:32:18 -0800904 .fA = layer->alpha},
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500905 toSkColorSpace(layerDataspace));
Ana Krulec47814212021-01-06 19:00:10 -0800906 paint.setShader(createRuntimeEffectShader(shader, layer, display,
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500907 /* undoPremultipliedAlpha */ false,
908 requiresLinearEffect));
John Reck67b1e2b2020-08-26 13:17:24 -0700909 }
Lucas Dupin21f348e2020-09-16 17:31:26 -0700910
Derek Sollenbergere2fe78c2021-02-23 13:22:54 -0500911 paint.setColorFilter(displayColorTransform);
Alec Mourib34f0b72020-10-02 13:18:34 -0700912
Derek Sollenberger4c331c82021-02-23 13:09:50 -0500913 if (layer->geometry.roundedCornersRadius > 0) {
914 paint.setAntiAlias(true);
915 canvas->drawRRect(getRoundedRect(layer), paint);
Alec Mouribd17b3b2020-12-17 11:08:30 -0800916 } else {
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500917 canvas->drawRect(bounds, paint);
Lucas Dupin3f11e922020-09-22 17:31:04 -0700918 }
John Reck67b1e2b2020-08-26 13:17:24 -0700919 }
Derek Sollenberger7c42bef2021-02-23 13:01:39 -0500920 surfaceAutoSaveRestore.restore();
Alec Mouric0aae732021-01-12 13:32:18 -0800921 mCapture->endCapture();
John Reck67b1e2b2020-08-26 13:17:24 -0700922 {
923 ATRACE_NAME("flush surface");
Derek Sollenberger3f77aa42021-02-04 11:06:34 -0500924 LOG_ALWAYS_FATAL_IF(activeSurface != dstSurface);
925 activeSurface->flush();
John Reck67b1e2b2020-08-26 13:17:24 -0700926 }
927
928 if (drawFence != nullptr) {
929 *drawFence = flush();
930 }
931
932 // If flush failed or we don't support native fences, we need to force the
933 // gl command stream to be executed.
934 bool requireSync = drawFence == nullptr || drawFence->get() < 0;
935 if (requireSync) {
936 ATRACE_BEGIN("Submit(sync=true)");
937 } else {
938 ATRACE_BEGIN("Submit(sync=false)");
939 }
Lucas Dupind508e472020-11-04 04:32:06 +0000940 bool success = grContext->submit(requireSync);
John Reck67b1e2b2020-08-26 13:17:24 -0700941 ATRACE_END();
942 if (!success) {
943 ALOGE("Failed to flush RenderEngine commands");
944 // Chances are, something illegal happened (either the caller passed
945 // us bad parameters, or we messed up our shader generation).
946 return INVALID_OPERATION;
947 }
948
949 // checkErrors();
950 return NO_ERROR;
951}
952
Lucas Dupin3f11e922020-09-22 17:31:04 -0700953inline SkRect SkiaGLRenderEngine::getSkRect(const FloatRect& rect) {
954 return SkRect::MakeLTRB(rect.left, rect.top, rect.right, rect.bottom);
955}
956
957inline SkRect SkiaGLRenderEngine::getSkRect(const Rect& rect) {
958 return SkRect::MakeLTRB(rect.left, rect.top, rect.right, rect.bottom);
959}
960
Lucas Dupin21f348e2020-09-16 17:31:26 -0700961inline SkRRect SkiaGLRenderEngine::getRoundedRect(const LayerSettings* layer) {
Ana Krulecf9a15d92020-12-11 08:35:00 -0800962 const auto rect = getSkRect(layer->geometry.roundedCornersCrop);
Lucas Dupin21f348e2020-09-16 17:31:26 -0700963 const auto cornerRadius = layer->geometry.roundedCornersRadius;
964 return SkRRect::MakeRectXY(rect, cornerRadius, cornerRadius);
965}
966
Galia Peycheva80116e52020-11-06 11:57:25 +0100967inline BlurRegion SkiaGLRenderEngine::getBlurRegion(const LayerSettings* layer) {
968 const auto rect = getSkRect(layer->geometry.boundaries);
969 const auto cornersRadius = layer->geometry.roundedCornersRadius;
970 return BlurRegion{.blurRadius = static_cast<uint32_t>(layer->backgroundBlurRadius),
971 .cornerRadiusTL = cornersRadius,
972 .cornerRadiusTR = cornersRadius,
973 .cornerRadiusBL = cornersRadius,
974 .cornerRadiusBR = cornersRadius,
975 .alpha = 1,
976 .left = static_cast<int>(rect.fLeft),
977 .top = static_cast<int>(rect.fTop),
978 .right = static_cast<int>(rect.fRight),
979 .bottom = static_cast<int>(rect.fBottom)};
980}
981
Derek Sollenbergerecb21462021-01-29 16:53:49 -0500982inline bool SkiaGLRenderEngine::layerHasBlur(const LayerSettings* layer) {
983 return layer->backgroundBlurRadius > 0 || layer->blurRegions.size();
984}
985
Lucas Dupin3f11e922020-09-22 17:31:04 -0700986inline SkColor SkiaGLRenderEngine::getSkColor(const vec4& color) {
987 return SkColorSetARGB(color.a * 255, color.r * 255, color.g * 255, color.b * 255);
988}
989
Lucas Dupinbb1a1d42020-09-18 15:17:02 -0700990inline SkM44 SkiaGLRenderEngine::getSkM44(const mat4& matrix) {
991 return SkM44(matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0],
992 matrix[0][1], matrix[1][1], matrix[2][1], matrix[3][1],
993 matrix[0][2], matrix[1][2], matrix[2][2], matrix[3][2],
994 matrix[0][3], matrix[1][3], matrix[2][3], matrix[3][3]);
995}
996
Lucas Dupin3f11e922020-09-22 17:31:04 -0700997inline SkPoint3 SkiaGLRenderEngine::getSkPoint3(const vec3& vector) {
998 return SkPoint3::Make(vector.x, vector.y, vector.z);
999}
1000
John Reck67b1e2b2020-08-26 13:17:24 -07001001size_t SkiaGLRenderEngine::getMaxTextureSize() const {
1002 return mGrContext->maxTextureSize();
1003}
1004
1005size_t SkiaGLRenderEngine::getMaxViewportDims() const {
1006 return mGrContext->maxRenderTargetSize();
1007}
1008
Lucas Dupin3f11e922020-09-22 17:31:04 -07001009void SkiaGLRenderEngine::drawShadow(SkCanvas* canvas, const SkRect& casterRect, float cornerRadius,
1010 const ShadowSettings& settings) {
1011 ATRACE_CALL();
1012 const float casterZ = settings.length / 2.0f;
1013 const auto shadowShape = cornerRadius > 0
1014 ? SkPath::RRect(SkRRect::MakeRectXY(casterRect, cornerRadius, cornerRadius))
1015 : SkPath::Rect(casterRect);
1016 const auto flags =
1017 settings.casterIsTranslucent ? kTransparentOccluder_ShadowFlag : kNone_ShadowFlag;
1018
1019 SkShadowUtils::DrawShadow(canvas, shadowShape, SkPoint3::Make(0, 0, casterZ),
1020 getSkPoint3(settings.lightPos), settings.lightRadius,
1021 getSkColor(settings.ambientColor), getSkColor(settings.spotColor),
1022 flags);
1023}
1024
John Reck67b1e2b2020-08-26 13:17:24 -07001025EGLContext SkiaGLRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,
Alec Mourid6f09462020-12-07 11:18:17 -08001026 EGLContext shareContext,
1027 std::optional<ContextPriority> contextPriority,
John Reck67b1e2b2020-08-26 13:17:24 -07001028 Protection protection) {
1029 EGLint renderableType = 0;
1030 if (config == EGL_NO_CONFIG_KHR) {
1031 renderableType = EGL_OPENGL_ES3_BIT;
1032 } else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) {
1033 LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");
1034 }
1035 EGLint contextClientVersion = 0;
1036 if (renderableType & EGL_OPENGL_ES3_BIT) {
1037 contextClientVersion = 3;
1038 } else if (renderableType & EGL_OPENGL_ES2_BIT) {
1039 contextClientVersion = 2;
1040 } else if (renderableType & EGL_OPENGL_ES_BIT) {
1041 contextClientVersion = 1;
1042 } else {
1043 LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs");
1044 }
1045
1046 std::vector<EGLint> contextAttributes;
1047 contextAttributes.reserve(7);
1048 contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
1049 contextAttributes.push_back(contextClientVersion);
Alec Mourid6f09462020-12-07 11:18:17 -08001050 if (contextPriority) {
John Reck67b1e2b2020-08-26 13:17:24 -07001051 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG);
Alec Mourid6f09462020-12-07 11:18:17 -08001052 switch (*contextPriority) {
1053 case ContextPriority::REALTIME:
1054 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_REALTIME_NV);
1055 break;
1056 case ContextPriority::MEDIUM:
1057 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_MEDIUM_IMG);
1058 break;
1059 case ContextPriority::LOW:
1060 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LOW_IMG);
1061 break;
1062 case ContextPriority::HIGH:
1063 default:
1064 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG);
1065 break;
1066 }
John Reck67b1e2b2020-08-26 13:17:24 -07001067 }
1068 if (protection == Protection::PROTECTED) {
1069 contextAttributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1070 contextAttributes.push_back(EGL_TRUE);
1071 }
1072 contextAttributes.push_back(EGL_NONE);
1073
1074 EGLContext context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1075
1076 if (contextClientVersion == 3 && context == EGL_NO_CONTEXT) {
1077 // eglGetConfigAttrib indicated we can create GLES 3 context, but we failed, thus
1078 // EGL_NO_CONTEXT so that we can abort.
1079 if (config != EGL_NO_CONFIG_KHR) {
1080 return context;
1081 }
1082 // If |config| is EGL_NO_CONFIG_KHR, we speculatively try to create GLES 3 context, so we
1083 // should try to fall back to GLES 2.
1084 contextAttributes[1] = 2;
1085 context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1086 }
1087
1088 return context;
1089}
1090
Alec Mourid6f09462020-12-07 11:18:17 -08001091std::optional<RenderEngine::ContextPriority> SkiaGLRenderEngine::createContextPriority(
1092 const RenderEngineCreationArgs& args) {
1093 if (!gl::GLExtensions::getInstance().hasContextPriority()) {
1094 return std::nullopt;
1095 }
1096
1097 switch (args.contextPriority) {
1098 case RenderEngine::ContextPriority::REALTIME:
1099 if (gl::GLExtensions::getInstance().hasRealtimePriority()) {
1100 return RenderEngine::ContextPriority::REALTIME;
1101 } else {
1102 ALOGI("Realtime priority unsupported, degrading gracefully to high priority");
1103 return RenderEngine::ContextPriority::HIGH;
1104 }
1105 case RenderEngine::ContextPriority::HIGH:
1106 case RenderEngine::ContextPriority::MEDIUM:
1107 case RenderEngine::ContextPriority::LOW:
1108 return args.contextPriority;
1109 default:
1110 return std::nullopt;
1111 }
1112}
1113
John Reck67b1e2b2020-08-26 13:17:24 -07001114EGLSurface SkiaGLRenderEngine::createPlaceholderEglPbufferSurface(EGLDisplay display,
1115 EGLConfig config, int hwcFormat,
1116 Protection protection) {
1117 EGLConfig placeholderConfig = config;
1118 if (placeholderConfig == EGL_NO_CONFIG_KHR) {
1119 placeholderConfig = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);
1120 }
1121 std::vector<EGLint> attributes;
1122 attributes.reserve(7);
1123 attributes.push_back(EGL_WIDTH);
1124 attributes.push_back(1);
1125 attributes.push_back(EGL_HEIGHT);
1126 attributes.push_back(1);
1127 if (protection == Protection::PROTECTED) {
1128 attributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1129 attributes.push_back(EGL_TRUE);
1130 }
1131 attributes.push_back(EGL_NONE);
1132
1133 return eglCreatePbufferSurface(display, placeholderConfig, attributes.data());
1134}
1135
Alec Mouric7f6c8b2020-11-09 18:35:20 -08001136void SkiaGLRenderEngine::cleanFramebufferCache() {}
John Reck67b1e2b2020-08-26 13:17:24 -07001137
Alec Mourid6f09462020-12-07 11:18:17 -08001138int SkiaGLRenderEngine::getContextPriority() {
1139 int value;
1140 eglQueryContext(mEGLDisplay, mEGLContext, EGL_CONTEXT_PRIORITY_LEVEL_IMG, &value);
1141 return value;
1142}
1143
Ana Krulec1d12b3b2021-01-27 16:49:51 -08001144void SkiaGLRenderEngine::dump(std::string& result) {
1145 const gl::GLExtensions& extensions = gl::GLExtensions::getInstance();
1146
1147 StringAppendF(&result, "\n ------------RE-----------------\n");
1148 StringAppendF(&result, "EGL implementation : %s\n", extensions.getEGLVersion());
1149 StringAppendF(&result, "%s\n", extensions.getEGLExtensions());
1150 StringAppendF(&result, "GLES: %s, %s, %s\n", extensions.getVendor(), extensions.getRenderer(),
1151 extensions.getVersion());
1152 StringAppendF(&result, "%s\n", extensions.getExtensions());
1153 StringAppendF(&result, "RenderEngine supports protected context: %d\n",
1154 supportsProtectedContent());
1155 StringAppendF(&result, "RenderEngine is in protected context: %d\n", mInProtectedContext);
1156
1157 {
1158 std::lock_guard<std::mutex> lock(mRenderingMutex);
1159 StringAppendF(&result, "RenderEngine texture cache size: %zu\n", mTextureCache.size());
1160 StringAppendF(&result, "Dumping buffer ids...\n");
1161 // TODO(178539829): It would be nice to know which layer these are coming from and what
1162 // the texture sizes are.
1163 for (const auto& [id, unused] : mTextureCache) {
1164 StringAppendF(&result, "- 0x%" PRIx64 "\n", id);
1165 }
1166 StringAppendF(&result, "\n");
1167 StringAppendF(&result, "RenderEngine protected texture cache size: %zu\n",
1168 mProtectedTextureCache.size());
1169 StringAppendF(&result, "Dumping buffer ids...\n");
1170 for (const auto& [id, unused] : mProtectedTextureCache) {
1171 StringAppendF(&result, "- 0x%" PRIx64 "\n", id);
1172 }
1173 StringAppendF(&result, "\n");
1174 StringAppendF(&result, "RenderEngine runtime effects: %zu\n", mRuntimeEffects.size());
1175 for (const auto& [linearEffect, unused] : mRuntimeEffects) {
1176 StringAppendF(&result, "- inputDataspace: %s\n",
1177 dataspaceDetails(
1178 static_cast<android_dataspace>(linearEffect.inputDataspace))
1179 .c_str());
1180 StringAppendF(&result, "- outputDataspace: %s\n",
1181 dataspaceDetails(
1182 static_cast<android_dataspace>(linearEffect.outputDataspace))
1183 .c_str());
1184 StringAppendF(&result, "undoPremultipliedAlpha: %s\n",
1185 linearEffect.undoPremultipliedAlpha ? "true" : "false");
1186 }
1187 }
1188 StringAppendF(&result, "\n");
1189}
1190
John Reck67b1e2b2020-08-26 13:17:24 -07001191} // namespace skia
1192} // namespace renderengine
Galia Peycheva6c460652020-11-03 19:42:42 +01001193} // namespace android