1 /*
2  * Copyright 2013 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
18 #undef LOG_TAG
19 #define LOG_TAG "RenderEngine"
20 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
21 
22 #include <sched.h>
23 #include <cmath>
24 #include <fstream>
25 #include <sstream>
26 #include <unordered_set>
27 
28 #include <GLES2/gl2.h>
29 #include <GLES2/gl2ext.h>
30 #include <android-base/stringprintf.h>
31 #include <cutils/compiler.h>
32 #include <cutils/properties.h>
33 #include <gui/DebugEGLImageTracker.h>
34 #include <renderengine/Mesh.h>
35 #include <renderengine/Texture.h>
36 #include <renderengine/private/Description.h>
37 #include <sync/sync.h>
38 #include <ui/ColorSpace.h>
39 #include <ui/DebugUtils.h>
40 #include <ui/GraphicBuffer.h>
41 #include <ui/Rect.h>
42 #include <ui/Region.h>
43 #include <utils/KeyedVector.h>
44 #include <utils/Trace.h>
45 #include "GLESRenderEngine.h"
46 #include "GLExtensions.h"
47 #include "GLFramebuffer.h"
48 #include "GLImage.h"
49 #include "GLShadowVertexGenerator.h"
50 #include "Program.h"
51 #include "ProgramCache.h"
52 #include "filters/BlurFilter.h"
53 
54 extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
55 
checkGlError(const char * op,int lineNumber)56 bool checkGlError(const char* op, int lineNumber) {
57     bool errorFound = false;
58     GLint error = glGetError();
59     while (error != GL_NO_ERROR) {
60         errorFound = true;
61         error = glGetError();
62         ALOGV("after %s() (line # %d) glError (0x%x)\n", op, lineNumber, error);
63     }
64     return errorFound;
65 }
66 
67 static constexpr bool outputDebugPPMs = false;
68 
writePPM(const char * basename,GLuint width,GLuint height)69 void writePPM(const char* basename, GLuint width, GLuint height) {
70     ALOGV("writePPM #%s: %d x %d", basename, width, height);
71 
72     std::vector<GLubyte> pixels(width * height * 4);
73     std::vector<GLubyte> outBuffer(width * height * 3);
74 
75     // TODO(courtneygo): We can now have float formats, need
76     // to remove this code or update to support.
77     // Make returned pixels fit in uint32_t, one byte per component
78     glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
79     if (checkGlError(__FUNCTION__, __LINE__)) {
80         return;
81     }
82 
83     std::string filename(basename);
84     filename.append(".ppm");
85     std::ofstream file(filename.c_str(), std::ios::binary);
86     if (!file.is_open()) {
87         ALOGE("Unable to open file: %s", filename.c_str());
88         ALOGE("You may need to do: \"adb shell setenforce 0\" to enable "
89               "surfaceflinger to write debug images");
90         return;
91     }
92 
93     file << "P6\n";
94     file << width << "\n";
95     file << height << "\n";
96     file << 255 << "\n";
97 
98     auto ptr = reinterpret_cast<char*>(pixels.data());
99     auto outPtr = reinterpret_cast<char*>(outBuffer.data());
100     for (int y = height - 1; y >= 0; y--) {
101         char* data = ptr + y * width * sizeof(uint32_t);
102 
103         for (GLuint x = 0; x < width; x++) {
104             // Only copy R, G and B components
105             outPtr[0] = data[0];
106             outPtr[1] = data[1];
107             outPtr[2] = data[2];
108             data += sizeof(uint32_t);
109             outPtr += 3;
110         }
111     }
112     file.write(reinterpret_cast<char*>(outBuffer.data()), outBuffer.size());
113 }
114 
115 namespace android {
116 namespace renderengine {
117 namespace gl {
118 
119 using base::StringAppendF;
120 using ui::Dataspace;
121 
selectConfigForAttribute(EGLDisplay dpy,EGLint const * attrs,EGLint attribute,EGLint wanted,EGLConfig * outConfig)122 static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs, EGLint attribute,
123                                          EGLint wanted, EGLConfig* outConfig) {
124     EGLint numConfigs = -1, n = 0;
125     eglGetConfigs(dpy, nullptr, 0, &numConfigs);
126     std::vector<EGLConfig> configs(numConfigs, EGL_NO_CONFIG_KHR);
127     eglChooseConfig(dpy, attrs, configs.data(), configs.size(), &n);
128     configs.resize(n);
129 
130     if (!configs.empty()) {
131         if (attribute != EGL_NONE) {
132             for (EGLConfig config : configs) {
133                 EGLint value = 0;
134                 eglGetConfigAttrib(dpy, config, attribute, &value);
135                 if (wanted == value) {
136                     *outConfig = config;
137                     return NO_ERROR;
138                 }
139             }
140         } else {
141             // just pick the first one
142             *outConfig = configs[0];
143             return NO_ERROR;
144         }
145     }
146 
147     return NAME_NOT_FOUND;
148 }
149 
selectEGLConfig(EGLDisplay display,EGLint format,EGLint renderableType,EGLConfig * config)150 static status_t selectEGLConfig(EGLDisplay display, EGLint format, EGLint renderableType,
151                                 EGLConfig* config) {
152     // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if
153     // it is to be used with WIFI displays
154     status_t err;
155     EGLint wantedAttribute;
156     EGLint wantedAttributeValue;
157 
158     std::vector<EGLint> attribs;
159     if (renderableType) {
160         const ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(format);
161         const bool is1010102 = pixelFormat == ui::PixelFormat::RGBA_1010102;
162 
163         // Default to 8 bits per channel.
164         const EGLint tmpAttribs[] = {
165                 EGL_RENDERABLE_TYPE,
166                 renderableType,
167                 EGL_RECORDABLE_ANDROID,
168                 EGL_TRUE,
169                 EGL_SURFACE_TYPE,
170                 EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
171                 EGL_FRAMEBUFFER_TARGET_ANDROID,
172                 EGL_TRUE,
173                 EGL_RED_SIZE,
174                 is1010102 ? 10 : 8,
175                 EGL_GREEN_SIZE,
176                 is1010102 ? 10 : 8,
177                 EGL_BLUE_SIZE,
178                 is1010102 ? 10 : 8,
179                 EGL_ALPHA_SIZE,
180                 is1010102 ? 2 : 8,
181                 EGL_NONE,
182         };
183         std::copy(tmpAttribs, tmpAttribs + (sizeof(tmpAttribs) / sizeof(EGLint)),
184                   std::back_inserter(attribs));
185         wantedAttribute = EGL_NONE;
186         wantedAttributeValue = EGL_NONE;
187     } else {
188         // if no renderable type specified, fallback to a simplified query
189         wantedAttribute = EGL_NATIVE_VISUAL_ID;
190         wantedAttributeValue = format;
191     }
192 
193     err = selectConfigForAttribute(display, attribs.data(), wantedAttribute, wantedAttributeValue,
194                                    config);
195     if (err == NO_ERROR) {
196         EGLint caveat;
197         if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat))
198             ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!");
199     }
200 
201     return err;
202 }
203 
create(const RenderEngineCreationArgs & args)204 std::unique_ptr<GLESRenderEngine> GLESRenderEngine::create(const RenderEngineCreationArgs& args) {
205     // initialize EGL for the default display
206     EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
207     if (!eglInitialize(display, nullptr, nullptr)) {
208         LOG_ALWAYS_FATAL("failed to initialize EGL");
209     }
210 
211     const auto eglVersion = eglQueryStringImplementationANDROID(display, EGL_VERSION);
212     if (!eglVersion) {
213         checkGlError(__FUNCTION__, __LINE__);
214         LOG_ALWAYS_FATAL("eglQueryStringImplementationANDROID(EGL_VERSION) failed");
215     }
216 
217     const auto eglExtensions = eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS);
218     if (!eglExtensions) {
219         checkGlError(__FUNCTION__, __LINE__);
220         LOG_ALWAYS_FATAL("eglQueryStringImplementationANDROID(EGL_EXTENSIONS) failed");
221     }
222 
223     GLExtensions& extensions = GLExtensions::getInstance();
224     extensions.initWithEGLStrings(eglVersion, eglExtensions);
225 
226     // The code assumes that ES2 or later is available if this extension is
227     // supported.
228     EGLConfig config = EGL_NO_CONFIG;
229     if (!extensions.hasNoConfigContext()) {
230         config = chooseEglConfig(display, args.pixelFormat, /*logConfig*/ true);
231     }
232 
233     bool useContextPriority =
234             extensions.hasContextPriority() && args.contextPriority == ContextPriority::HIGH;
235     EGLContext protectedContext = EGL_NO_CONTEXT;
236     if (args.enableProtectedContext && extensions.hasProtectedContent()) {
237         protectedContext = createEglContext(display, config, nullptr, useContextPriority,
238                                             Protection::PROTECTED);
239         ALOGE_IF(protectedContext == EGL_NO_CONTEXT, "Can't create protected context");
240     }
241 
242     EGLContext ctxt = createEglContext(display, config, protectedContext, useContextPriority,
243                                        Protection::UNPROTECTED);
244 
245     // if can't create a GL context, we can only abort.
246     LOG_ALWAYS_FATAL_IF(ctxt == EGL_NO_CONTEXT, "EGLContext creation failed");
247 
248     EGLSurface dummy = EGL_NO_SURFACE;
249     if (!extensions.hasSurfacelessContext()) {
250         dummy = createDummyEglPbufferSurface(display, config, args.pixelFormat,
251                                              Protection::UNPROTECTED);
252         LOG_ALWAYS_FATAL_IF(dummy == EGL_NO_SURFACE, "can't create dummy pbuffer");
253     }
254     EGLBoolean success = eglMakeCurrent(display, dummy, dummy, ctxt);
255     LOG_ALWAYS_FATAL_IF(!success, "can't make dummy pbuffer current");
256     extensions.initWithGLStrings(glGetString(GL_VENDOR), glGetString(GL_RENDERER),
257                                  glGetString(GL_VERSION), glGetString(GL_EXTENSIONS));
258 
259     EGLSurface protectedDummy = EGL_NO_SURFACE;
260     if (protectedContext != EGL_NO_CONTEXT && !extensions.hasSurfacelessContext()) {
261         protectedDummy = createDummyEglPbufferSurface(display, config, args.pixelFormat,
262                                                       Protection::PROTECTED);
263         ALOGE_IF(protectedDummy == EGL_NO_SURFACE, "can't create protected dummy pbuffer");
264     }
265 
266     // now figure out what version of GL did we actually get
267     GlesVersion version = parseGlesVersion(extensions.getVersion());
268 
269     LOG_ALWAYS_FATAL_IF(args.supportsBackgroundBlur && version < GLES_VERSION_3_0,
270         "Blurs require OpenGL ES 3.0. Please unset ro.surface_flinger.supports_background_blur");
271 
272     // initialize the renderer while GL is current
273     std::unique_ptr<GLESRenderEngine> engine;
274     switch (version) {
275         case GLES_VERSION_1_0:
276         case GLES_VERSION_1_1:
277             LOG_ALWAYS_FATAL("SurfaceFlinger requires OpenGL ES 2.0 minimum to run.");
278             break;
279         case GLES_VERSION_2_0:
280         case GLES_VERSION_3_0:
281             engine = std::make_unique<GLESRenderEngine>(args, display, config, ctxt, dummy,
282                                                         protectedContext, protectedDummy);
283             break;
284     }
285 
286     ALOGI("OpenGL ES informations:");
287     ALOGI("vendor    : %s", extensions.getVendor());
288     ALOGI("renderer  : %s", extensions.getRenderer());
289     ALOGI("version   : %s", extensions.getVersion());
290     ALOGI("extensions: %s", extensions.getExtensions());
291     ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize());
292     ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims());
293 
294     return engine;
295 }
296 
chooseEglConfig(EGLDisplay display,int format,bool logConfig)297 EGLConfig GLESRenderEngine::chooseEglConfig(EGLDisplay display, int format, bool logConfig) {
298     status_t err;
299     EGLConfig config;
300 
301     // First try to get an ES3 config
302     err = selectEGLConfig(display, format, EGL_OPENGL_ES3_BIT, &config);
303     if (err != NO_ERROR) {
304         // If ES3 fails, try to get an ES2 config
305         err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);
306         if (err != NO_ERROR) {
307             // If ES2 still doesn't work, probably because we're on the emulator.
308             // try a simplified query
309             ALOGW("no suitable EGLConfig found, trying a simpler query");
310             err = selectEGLConfig(display, format, 0, &config);
311             if (err != NO_ERROR) {
312                 // this EGL is too lame for android
313                 LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up");
314             }
315         }
316     }
317 
318     if (logConfig) {
319         // print some debugging info
320         EGLint r, g, b, a;
321         eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r);
322         eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
323         eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);
324         eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);
325         ALOGI("EGL information:");
326         ALOGI("vendor    : %s", eglQueryString(display, EGL_VENDOR));
327         ALOGI("version   : %s", eglQueryString(display, EGL_VERSION));
328         ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS));
329         ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS) ?: "Not Supported");
330         ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);
331     }
332 
333     return config;
334 }
335 
GLESRenderEngine(const RenderEngineCreationArgs & args,EGLDisplay display,EGLConfig config,EGLContext ctxt,EGLSurface dummy,EGLContext protectedContext,EGLSurface protectedDummy)336 GLESRenderEngine::GLESRenderEngine(const RenderEngineCreationArgs& args, EGLDisplay display,
337                                    EGLConfig config, EGLContext ctxt, EGLSurface dummy,
338                                    EGLContext protectedContext, EGLSurface protectedDummy)
339       : renderengine::impl::RenderEngine(args),
340         mEGLDisplay(display),
341         mEGLConfig(config),
342         mEGLContext(ctxt),
343         mDummySurface(dummy),
344         mProtectedEGLContext(protectedContext),
345         mProtectedDummySurface(protectedDummy),
346         mVpWidth(0),
347         mVpHeight(0),
348         mFramebufferImageCacheSize(args.imageCacheSize),
349         mUseColorManagement(args.useColorManagement) {
350     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
351     glGetIntegerv(GL_MAX_VIEWPORT_DIMS, mMaxViewportDims);
352 
353     glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
354     glPixelStorei(GL_PACK_ALIGNMENT, 4);
355 
356     // Initialize protected EGL Context.
357     if (mProtectedEGLContext != EGL_NO_CONTEXT) {
358         EGLBoolean success = eglMakeCurrent(display, mProtectedDummySurface, mProtectedDummySurface,
359                                             mProtectedEGLContext);
360         ALOGE_IF(!success, "can't make protected context current");
361         glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
362         glPixelStorei(GL_PACK_ALIGNMENT, 4);
363         success = eglMakeCurrent(display, mDummySurface, mDummySurface, mEGLContext);
364         LOG_ALWAYS_FATAL_IF(!success, "can't make default context current");
365     }
366 
367     // mColorBlindnessCorrection = M;
368 
369     if (mUseColorManagement) {
370         const ColorSpace srgb(ColorSpace::sRGB());
371         const ColorSpace displayP3(ColorSpace::DisplayP3());
372         const ColorSpace bt2020(ColorSpace::BT2020());
373 
374         // no chromatic adaptation needed since all color spaces use D65 for their white points.
375         mSrgbToXyz = mat4(srgb.getRGBtoXYZ());
376         mDisplayP3ToXyz = mat4(displayP3.getRGBtoXYZ());
377         mBt2020ToXyz = mat4(bt2020.getRGBtoXYZ());
378         mXyzToSrgb = mat4(srgb.getXYZtoRGB());
379         mXyzToDisplayP3 = mat4(displayP3.getXYZtoRGB());
380         mXyzToBt2020 = mat4(bt2020.getXYZtoRGB());
381 
382         // Compute sRGB to Display P3 and BT2020 transform matrix.
383         // NOTE: For now, we are limiting output wide color space support to
384         // Display-P3 and BT2020 only.
385         mSrgbToDisplayP3 = mXyzToDisplayP3 * mSrgbToXyz;
386         mSrgbToBt2020 = mXyzToBt2020 * mSrgbToXyz;
387 
388         // Compute Display P3 to sRGB and BT2020 transform matrix.
389         mDisplayP3ToSrgb = mXyzToSrgb * mDisplayP3ToXyz;
390         mDisplayP3ToBt2020 = mXyzToBt2020 * mDisplayP3ToXyz;
391 
392         // Compute BT2020 to sRGB and Display P3 transform matrix
393         mBt2020ToSrgb = mXyzToSrgb * mBt2020ToXyz;
394         mBt2020ToDisplayP3 = mXyzToDisplayP3 * mBt2020ToXyz;
395     }
396 
397     char value[PROPERTY_VALUE_MAX];
398     property_get("debug.egl.traceGpuCompletion", value, "0");
399     if (atoi(value)) {
400         mTraceGpuCompletion = true;
401         mFlushTracer = std::make_unique<FlushTracer>(this);
402     }
403 
404     if (args.supportsBackgroundBlur) {
405         mBlurFilter = new BlurFilter(*this);
406         checkErrors("BlurFilter creation");
407     }
408 
409     mImageManager = std::make_unique<ImageManager>(this);
410     mImageManager->initThread();
411     mDrawingBuffer = createFramebuffer();
412 }
413 
~GLESRenderEngine()414 GLESRenderEngine::~GLESRenderEngine() {
415     // Destroy the image manager first.
416     mImageManager = nullptr;
417     std::lock_guard<std::mutex> lock(mRenderingMutex);
418     unbindFrameBuffer(mDrawingBuffer.get());
419     mDrawingBuffer = nullptr;
420     while (!mFramebufferImageCache.empty()) {
421         EGLImageKHR expired = mFramebufferImageCache.front().second;
422         mFramebufferImageCache.pop_front();
423         eglDestroyImageKHR(mEGLDisplay, expired);
424         DEBUG_EGL_IMAGE_TRACKER_DESTROY();
425     }
426     mImageCache.clear();
427     eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
428     eglTerminate(mEGLDisplay);
429 }
430 
createFramebuffer()431 std::unique_ptr<Framebuffer> GLESRenderEngine::createFramebuffer() {
432     return std::make_unique<GLFramebuffer>(*this);
433 }
434 
createImage()435 std::unique_ptr<Image> GLESRenderEngine::createImage() {
436     return std::make_unique<GLImage>(*this);
437 }
438 
getFramebufferForDrawing()439 Framebuffer* GLESRenderEngine::getFramebufferForDrawing() {
440     return mDrawingBuffer.get();
441 }
442 
primeCache() const443 void GLESRenderEngine::primeCache() const {
444     ProgramCache::getInstance().primeCache(mInProtectedContext ? mProtectedEGLContext : mEGLContext,
445                                            mArgs.useColorManagement,
446                                            mArgs.precacheToneMapperShaderOnly);
447 }
448 
flush()449 base::unique_fd GLESRenderEngine::flush() {
450     ATRACE_CALL();
451     if (!GLExtensions::getInstance().hasNativeFenceSync()) {
452         return base::unique_fd();
453     }
454 
455     EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
456     if (sync == EGL_NO_SYNC_KHR) {
457         ALOGW("failed to create EGL native fence sync: %#x", eglGetError());
458         return base::unique_fd();
459     }
460 
461     // native fence fd will not be populated until flush() is done.
462     glFlush();
463 
464     // get the fence fd
465     base::unique_fd fenceFd(eglDupNativeFenceFDANDROID(mEGLDisplay, sync));
466     eglDestroySyncKHR(mEGLDisplay, sync);
467     if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
468         ALOGW("failed to dup EGL native fence sync: %#x", eglGetError());
469     }
470 
471     // Only trace if we have a valid fence, as current usage falls back to
472     // calling finish() if the fence fd is invalid.
473     if (CC_UNLIKELY(mTraceGpuCompletion && mFlushTracer) && fenceFd.get() >= 0) {
474         mFlushTracer->queueSync(eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr));
475     }
476 
477     return fenceFd;
478 }
479 
finish()480 bool GLESRenderEngine::finish() {
481     ATRACE_CALL();
482     if (!GLExtensions::getInstance().hasFenceSync()) {
483         ALOGW("no synchronization support");
484         return false;
485     }
486 
487     EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr);
488     if (sync == EGL_NO_SYNC_KHR) {
489         ALOGW("failed to create EGL fence sync: %#x", eglGetError());
490         return false;
491     }
492 
493     if (CC_UNLIKELY(mTraceGpuCompletion && mFlushTracer)) {
494         mFlushTracer->queueSync(eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr));
495     }
496 
497     return waitSync(sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR);
498 }
499 
waitSync(EGLSyncKHR sync,EGLint flags)500 bool GLESRenderEngine::waitSync(EGLSyncKHR sync, EGLint flags) {
501     EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync, flags, 2000000000 /*2 sec*/);
502     EGLint error = eglGetError();
503     eglDestroySyncKHR(mEGLDisplay, sync);
504     if (result != EGL_CONDITION_SATISFIED_KHR) {
505         if (result == EGL_TIMEOUT_EXPIRED_KHR) {
506             ALOGW("fence wait timed out");
507         } else {
508             ALOGW("error waiting on EGL fence: %#x", error);
509         }
510         return false;
511     }
512 
513     return true;
514 }
515 
waitFence(base::unique_fd fenceFd)516 bool GLESRenderEngine::waitFence(base::unique_fd fenceFd) {
517     if (!GLExtensions::getInstance().hasNativeFenceSync() ||
518         !GLExtensions::getInstance().hasWaitSync()) {
519         return false;
520     }
521 
522     // release the fd and transfer the ownership to EGLSync
523     EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceFd.release(), EGL_NONE};
524     EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
525     if (sync == EGL_NO_SYNC_KHR) {
526         ALOGE("failed to create EGL native fence sync: %#x", eglGetError());
527         return false;
528     }
529 
530     // XXX: The spec draft is inconsistent as to whether this should return an
531     // EGLint or void.  Ignore the return value for now, as it's not strictly
532     // needed.
533     eglWaitSyncKHR(mEGLDisplay, sync, 0);
534     EGLint error = eglGetError();
535     eglDestroySyncKHR(mEGLDisplay, sync);
536     if (error != EGL_SUCCESS) {
537         ALOGE("failed to wait for EGL native fence sync: %#x", error);
538         return false;
539     }
540 
541     return true;
542 }
543 
clearWithColor(float red,float green,float blue,float alpha)544 void GLESRenderEngine::clearWithColor(float red, float green, float blue, float alpha) {
545     ATRACE_CALL();
546     glDisable(GL_BLEND);
547     glClearColor(red, green, blue, alpha);
548     glClear(GL_COLOR_BUFFER_BIT);
549 }
550 
fillRegionWithColor(const Region & region,float red,float green,float blue,float alpha)551 void GLESRenderEngine::fillRegionWithColor(const Region& region, float red, float green, float blue,
552                                            float alpha) {
553     size_t c;
554     Rect const* r = region.getArray(&c);
555     Mesh mesh = Mesh::Builder()
556                         .setPrimitive(Mesh::TRIANGLES)
557                         .setVertices(c * 6 /* count */, 2 /* size */)
558                         .build();
559     Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
560     for (size_t i = 0; i < c; i++, r++) {
561         position[i * 6 + 0].x = r->left;
562         position[i * 6 + 0].y = r->top;
563         position[i * 6 + 1].x = r->left;
564         position[i * 6 + 1].y = r->bottom;
565         position[i * 6 + 2].x = r->right;
566         position[i * 6 + 2].y = r->bottom;
567         position[i * 6 + 3].x = r->left;
568         position[i * 6 + 3].y = r->top;
569         position[i * 6 + 4].x = r->right;
570         position[i * 6 + 4].y = r->bottom;
571         position[i * 6 + 5].x = r->right;
572         position[i * 6 + 5].y = r->top;
573     }
574     setupFillWithColor(red, green, blue, alpha);
575     drawMesh(mesh);
576 }
577 
setScissor(const Rect & region)578 void GLESRenderEngine::setScissor(const Rect& region) {
579     glScissor(region.left, region.top, region.getWidth(), region.getHeight());
580     glEnable(GL_SCISSOR_TEST);
581 }
582 
disableScissor()583 void GLESRenderEngine::disableScissor() {
584     glDisable(GL_SCISSOR_TEST);
585 }
586 
genTextures(size_t count,uint32_t * names)587 void GLESRenderEngine::genTextures(size_t count, uint32_t* names) {
588     glGenTextures(count, names);
589 }
590 
deleteTextures(size_t count,uint32_t const * names)591 void GLESRenderEngine::deleteTextures(size_t count, uint32_t const* names) {
592     glDeleteTextures(count, names);
593 }
594 
bindExternalTextureImage(uint32_t texName,const Image & image)595 void GLESRenderEngine::bindExternalTextureImage(uint32_t texName, const Image& image) {
596     ATRACE_CALL();
597     const GLImage& glImage = static_cast<const GLImage&>(image);
598     const GLenum target = GL_TEXTURE_EXTERNAL_OES;
599 
600     glBindTexture(target, texName);
601     if (glImage.getEGLImage() != EGL_NO_IMAGE_KHR) {
602         glEGLImageTargetTexture2DOES(target, static_cast<GLeglImageOES>(glImage.getEGLImage()));
603     }
604 }
605 
bindExternalTextureBuffer(uint32_t texName,const sp<GraphicBuffer> & buffer,const sp<Fence> & bufferFence)606 status_t GLESRenderEngine::bindExternalTextureBuffer(uint32_t texName,
607                                                      const sp<GraphicBuffer>& buffer,
608                                                      const sp<Fence>& bufferFence) {
609     if (buffer == nullptr) {
610         return BAD_VALUE;
611     }
612 
613     ATRACE_CALL();
614 
615     bool found = false;
616     {
617         std::lock_guard<std::mutex> lock(mRenderingMutex);
618         auto cachedImage = mImageCache.find(buffer->getId());
619         found = (cachedImage != mImageCache.end());
620     }
621 
622     // If we couldn't find the image in the cache at this time, then either
623     // SurfaceFlinger messed up registering the buffer ahead of time or we got
624     // backed up creating other EGLImages.
625     if (!found) {
626         status_t cacheResult = mImageManager->cache(buffer);
627         if (cacheResult != NO_ERROR) {
628             return cacheResult;
629         }
630     }
631 
632     // Whether or not we needed to cache, re-check mImageCache to make sure that
633     // there's an EGLImage. The current threading model guarantees that we don't
634     // destroy a cached image until it's really not needed anymore (i.e. this
635     // function should not be called), so the only possibility is that something
636     // terrible went wrong and we should just bind something and move on.
637     {
638         std::lock_guard<std::mutex> lock(mRenderingMutex);
639         auto cachedImage = mImageCache.find(buffer->getId());
640 
641         if (cachedImage == mImageCache.end()) {
642             // We failed creating the image if we got here, so bail out.
643             ALOGE("Failed to create an EGLImage when rendering");
644             bindExternalTextureImage(texName, *createImage());
645             return NO_INIT;
646         }
647 
648         bindExternalTextureImage(texName, *cachedImage->second);
649     }
650 
651     // Wait for the new buffer to be ready.
652     if (bufferFence != nullptr && bufferFence->isValid()) {
653         if (GLExtensions::getInstance().hasWaitSync()) {
654             base::unique_fd fenceFd(bufferFence->dup());
655             if (fenceFd == -1) {
656                 ALOGE("error dup'ing fence fd: %d", errno);
657                 return -errno;
658             }
659             if (!waitFence(std::move(fenceFd))) {
660                 ALOGE("failed to wait on fence fd");
661                 return UNKNOWN_ERROR;
662             }
663         } else {
664             status_t err = bufferFence->waitForever("RenderEngine::bindExternalTextureBuffer");
665             if (err != NO_ERROR) {
666                 ALOGE("error waiting for fence: %d", err);
667                 return err;
668             }
669         }
670     }
671 
672     return NO_ERROR;
673 }
674 
cacheExternalTextureBuffer(const sp<GraphicBuffer> & buffer)675 void GLESRenderEngine::cacheExternalTextureBuffer(const sp<GraphicBuffer>& buffer) {
676     mImageManager->cacheAsync(buffer, nullptr);
677 }
678 
cacheExternalTextureBufferForTesting(const sp<GraphicBuffer> & buffer)679 std::shared_ptr<ImageManager::Barrier> GLESRenderEngine::cacheExternalTextureBufferForTesting(
680         const sp<GraphicBuffer>& buffer) {
681     auto barrier = std::make_shared<ImageManager::Barrier>();
682     mImageManager->cacheAsync(buffer, barrier);
683     return barrier;
684 }
685 
cacheExternalTextureBufferInternal(const sp<GraphicBuffer> & buffer)686 status_t GLESRenderEngine::cacheExternalTextureBufferInternal(const sp<GraphicBuffer>& buffer) {
687     if (buffer == nullptr) {
688         return BAD_VALUE;
689     }
690 
691     {
692         std::lock_guard<std::mutex> lock(mRenderingMutex);
693         if (mImageCache.count(buffer->getId()) > 0) {
694             // If there's already an image then fail fast here.
695             return NO_ERROR;
696         }
697     }
698     ATRACE_CALL();
699 
700     // Create the image without holding a lock so that we don't block anything.
701     std::unique_ptr<Image> newImage = createImage();
702 
703     bool created = newImage->setNativeWindowBuffer(buffer->getNativeBuffer(),
704                                                    buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
705     if (!created) {
706         ALOGE("Failed to create image. size=%ux%u st=%u usage=%#" PRIx64 " fmt=%d",
707               buffer->getWidth(), buffer->getHeight(), buffer->getStride(), buffer->getUsage(),
708               buffer->getPixelFormat());
709         return NO_INIT;
710     }
711 
712     {
713         std::lock_guard<std::mutex> lock(mRenderingMutex);
714         if (mImageCache.count(buffer->getId()) > 0) {
715             // In theory it's possible for another thread to recache the image,
716             // so bail out if another thread won.
717             return NO_ERROR;
718         }
719         mImageCache.insert(std::make_pair(buffer->getId(), std::move(newImage)));
720     }
721 
722     return NO_ERROR;
723 }
724 
unbindExternalTextureBuffer(uint64_t bufferId)725 void GLESRenderEngine::unbindExternalTextureBuffer(uint64_t bufferId) {
726     mImageManager->releaseAsync(bufferId, nullptr);
727 }
728 
unbindExternalTextureBufferForTesting(uint64_t bufferId)729 std::shared_ptr<ImageManager::Barrier> GLESRenderEngine::unbindExternalTextureBufferForTesting(
730         uint64_t bufferId) {
731     auto barrier = std::make_shared<ImageManager::Barrier>();
732     mImageManager->releaseAsync(bufferId, barrier);
733     return barrier;
734 }
735 
unbindExternalTextureBufferInternal(uint64_t bufferId)736 void GLESRenderEngine::unbindExternalTextureBufferInternal(uint64_t bufferId) {
737     std::unique_ptr<Image> image;
738     {
739         std::lock_guard<std::mutex> lock(mRenderingMutex);
740         const auto& cachedImage = mImageCache.find(bufferId);
741 
742         if (cachedImage != mImageCache.end()) {
743             ALOGV("Destroying image for buffer: %" PRIu64, bufferId);
744             // Move the buffer out of cache first, so that we can destroy
745             // without holding the cache's lock.
746             image = std::move(cachedImage->second);
747             mImageCache.erase(bufferId);
748             return;
749         }
750     }
751     ALOGV("Failed to find image for buffer: %" PRIu64, bufferId);
752 }
753 
setupLayerCropping(const LayerSettings & layer,Mesh & mesh)754 FloatRect GLESRenderEngine::setupLayerCropping(const LayerSettings& layer, Mesh& mesh) {
755     // Translate win by the rounded corners rect coordinates, to have all values in
756     // layer coordinate space.
757     FloatRect cropWin = layer.geometry.boundaries;
758     const FloatRect& roundedCornersCrop = layer.geometry.roundedCornersCrop;
759     cropWin.left -= roundedCornersCrop.left;
760     cropWin.right -= roundedCornersCrop.left;
761     cropWin.top -= roundedCornersCrop.top;
762     cropWin.bottom -= roundedCornersCrop.top;
763     Mesh::VertexArray<vec2> cropCoords(mesh.getCropCoordArray<vec2>());
764     cropCoords[0] = vec2(cropWin.left, cropWin.top);
765     cropCoords[1] = vec2(cropWin.left, cropWin.top + cropWin.getHeight());
766     cropCoords[2] = vec2(cropWin.right, cropWin.top + cropWin.getHeight());
767     cropCoords[3] = vec2(cropWin.right, cropWin.top);
768 
769     setupCornerRadiusCropSize(roundedCornersCrop.getWidth(), roundedCornersCrop.getHeight());
770     return cropWin;
771 }
772 
handleRoundedCorners(const DisplaySettings & display,const LayerSettings & layer,const Mesh & mesh)773 void GLESRenderEngine::handleRoundedCorners(const DisplaySettings& display,
774                                             const LayerSettings& layer, const Mesh& mesh) {
775     // We separate the layer into 3 parts essentially, such that we only turn on blending for the
776     // top rectangle and the bottom rectangle, and turn off blending for the middle rectangle.
777     FloatRect bounds = layer.geometry.roundedCornersCrop;
778 
779     // Explicitly compute the transform from the clip rectangle to the physical
780     // display. Normally, this is done in glViewport but we explicitly compute
781     // it here so that we can get the scissor bounds correct.
782     const Rect& source = display.clip;
783     const Rect& destination = display.physicalDisplay;
784     // Here we compute the following transform:
785     // 1. Translate the top left corner of the source clip to (0, 0)
786     // 2. Rotate the clip rectangle about the origin in accordance with the
787     // orientation flag
788     // 3. Translate the top left corner back to the origin.
789     // 4. Scale the clip rectangle to the destination rectangle dimensions
790     // 5. Translate the top left corner to the destination rectangle's top left
791     // corner.
792     const mat4 translateSource = mat4::translate(vec4(-source.left, -source.top, 0, 1));
793     mat4 rotation;
794     int displacementX = 0;
795     int displacementY = 0;
796     float destinationWidth = static_cast<float>(destination.getWidth());
797     float destinationHeight = static_cast<float>(destination.getHeight());
798     float sourceWidth = static_cast<float>(source.getWidth());
799     float sourceHeight = static_cast<float>(source.getHeight());
800     const float rot90InRadians = 2.0f * static_cast<float>(M_PI) / 4.0f;
801     switch (display.orientation) {
802         case ui::Transform::ROT_90:
803             rotation = mat4::rotate(rot90InRadians, vec3(0, 0, 1));
804             displacementX = source.getHeight();
805             std::swap(sourceHeight, sourceWidth);
806             break;
807         case ui::Transform::ROT_180:
808             rotation = mat4::rotate(rot90InRadians * 2.0f, vec3(0, 0, 1));
809             displacementY = source.getHeight();
810             displacementX = source.getWidth();
811             break;
812         case ui::Transform::ROT_270:
813             rotation = mat4::rotate(rot90InRadians * 3.0f, vec3(0, 0, 1));
814             displacementY = source.getWidth();
815             std::swap(sourceHeight, sourceWidth);
816             break;
817         default:
818             break;
819     }
820 
821     const mat4 intermediateTranslation = mat4::translate(vec4(displacementX, displacementY, 0, 1));
822     const mat4 scale = mat4::scale(
823             vec4(destinationWidth / sourceWidth, destinationHeight / sourceHeight, 1, 1));
824     const mat4 translateDestination =
825             mat4::translate(vec4(destination.left, destination.top, 0, 1));
826     const mat4 globalTransform =
827             translateDestination * scale * intermediateTranslation * rotation * translateSource;
828 
829     const mat4 transformMatrix = globalTransform * layer.geometry.positionTransform;
830     const vec4 leftTopCoordinate(bounds.left, bounds.top, 1.0, 1.0);
831     const vec4 rightBottomCoordinate(bounds.right, bounds.bottom, 1.0, 1.0);
832     const vec4 leftTopCoordinateInBuffer = transformMatrix * leftTopCoordinate;
833     const vec4 rightBottomCoordinateInBuffer = transformMatrix * rightBottomCoordinate;
834     bounds = FloatRect(std::min(leftTopCoordinateInBuffer[0], rightBottomCoordinateInBuffer[0]),
835                        std::min(leftTopCoordinateInBuffer[1], rightBottomCoordinateInBuffer[1]),
836                        std::max(leftTopCoordinateInBuffer[0], rightBottomCoordinateInBuffer[0]),
837                        std::max(leftTopCoordinateInBuffer[1], rightBottomCoordinateInBuffer[1]));
838 
839     // Finally, we cut the layer into 3 parts, with top and bottom parts having rounded corners
840     // and the middle part without rounded corners.
841     const int32_t radius = ceil(layer.geometry.roundedCornersRadius);
842     const Rect topRect(bounds.left, bounds.top, bounds.right, bounds.top + radius);
843     setScissor(topRect);
844     drawMesh(mesh);
845     const Rect bottomRect(bounds.left, bounds.bottom - radius, bounds.right, bounds.bottom);
846     setScissor(bottomRect);
847     drawMesh(mesh);
848 
849     // The middle part of the layer can turn off blending.
850     if (topRect.bottom < bottomRect.top) {
851         const Rect middleRect(bounds.left, bounds.top + radius, bounds.right,
852                               bounds.bottom - radius);
853         setScissor(middleRect);
854         mState.cornerRadius = 0.0;
855         disableBlending();
856         drawMesh(mesh);
857     }
858     disableScissor();
859 }
860 
bindFrameBuffer(Framebuffer * framebuffer)861 status_t GLESRenderEngine::bindFrameBuffer(Framebuffer* framebuffer) {
862     ATRACE_CALL();
863     GLFramebuffer* glFramebuffer = static_cast<GLFramebuffer*>(framebuffer);
864     EGLImageKHR eglImage = glFramebuffer->getEGLImage();
865     uint32_t textureName = glFramebuffer->getTextureName();
866     uint32_t framebufferName = glFramebuffer->getFramebufferName();
867 
868     // Bind the texture and turn our EGLImage into a texture
869     glBindTexture(GL_TEXTURE_2D, textureName);
870     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)eglImage);
871 
872     // Bind the Framebuffer to render into
873     glBindFramebuffer(GL_FRAMEBUFFER, framebufferName);
874     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureName, 0);
875 
876     uint32_t glStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
877     ALOGE_IF(glStatus != GL_FRAMEBUFFER_COMPLETE_OES, "glCheckFramebufferStatusOES error %d",
878              glStatus);
879 
880     return glStatus == GL_FRAMEBUFFER_COMPLETE_OES ? NO_ERROR : BAD_VALUE;
881 }
882 
unbindFrameBuffer(Framebuffer *)883 void GLESRenderEngine::unbindFrameBuffer(Framebuffer* /*framebuffer*/) {
884     ATRACE_CALL();
885 
886     // back to main framebuffer
887     glBindFramebuffer(GL_FRAMEBUFFER, 0);
888 }
889 
cleanupPostRender()890 bool GLESRenderEngine::cleanupPostRender() {
891     ATRACE_CALL();
892 
893     if (mPriorResourcesCleaned ||
894         (mLastDrawFence != nullptr && mLastDrawFence->getStatus() != Fence::Status::Signaled)) {
895         // If we don't have a prior frame needing cleanup, then don't do anything.
896         return false;
897     }
898 
899     // Bind the texture to dummy data so that backing image data can be freed.
900     GLFramebuffer* glFramebuffer = static_cast<GLFramebuffer*>(getFramebufferForDrawing());
901     glFramebuffer->allocateBuffers(1, 1, mPlaceholderDrawBuffer);
902     // Release the cached fence here, so that we don't churn reallocations when
903     // we could no-op repeated calls of this method instead.
904     mLastDrawFence = nullptr;
905     mPriorResourcesCleaned = true;
906     return true;
907 }
908 
checkErrors() const909 void GLESRenderEngine::checkErrors() const {
910     checkErrors(nullptr);
911 }
912 
checkErrors(const char * tag) const913 void GLESRenderEngine::checkErrors(const char* tag) const {
914     do {
915         // there could be more than one error flag
916         GLenum error = glGetError();
917         if (error == GL_NO_ERROR) break;
918         if (tag == nullptr) {
919             ALOGE("GL error 0x%04x", int(error));
920         } else {
921             ALOGE("GL error: %s -> 0x%04x", tag, int(error));
922         }
923     } while (true);
924 }
925 
supportsProtectedContent() const926 bool GLESRenderEngine::supportsProtectedContent() const {
927     return mProtectedEGLContext != EGL_NO_CONTEXT;
928 }
929 
useProtectedContext(bool useProtectedContext)930 bool GLESRenderEngine::useProtectedContext(bool useProtectedContext) {
931     if (useProtectedContext == mInProtectedContext) {
932         return true;
933     }
934     if (useProtectedContext && mProtectedEGLContext == EGL_NO_CONTEXT) {
935         return false;
936     }
937     const EGLSurface surface = useProtectedContext ? mProtectedDummySurface : mDummySurface;
938     const EGLContext context = useProtectedContext ? mProtectedEGLContext : mEGLContext;
939     const bool success = eglMakeCurrent(mEGLDisplay, surface, surface, context) == EGL_TRUE;
940     if (success) {
941         mInProtectedContext = useProtectedContext;
942     }
943     return success;
944 }
createFramebufferImageIfNeeded(ANativeWindowBuffer * nativeBuffer,bool isProtected,bool useFramebufferCache)945 EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer* nativeBuffer,
946                                                              bool isProtected,
947                                                              bool useFramebufferCache) {
948     sp<GraphicBuffer> graphicBuffer = GraphicBuffer::from(nativeBuffer);
949     if (useFramebufferCache) {
950         std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
951         for (const auto& image : mFramebufferImageCache) {
952             if (image.first == graphicBuffer->getId()) {
953                 return image.second;
954             }
955         }
956     }
957     EGLint attributes[] = {
958             isProtected ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
959             isProtected ? EGL_TRUE : EGL_NONE,
960             EGL_NONE,
961     };
962     EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
963                                           nativeBuffer, attributes);
964     if (useFramebufferCache) {
965         if (image != EGL_NO_IMAGE_KHR) {
966             std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
967             if (mFramebufferImageCache.size() >= mFramebufferImageCacheSize) {
968                 EGLImageKHR expired = mFramebufferImageCache.front().second;
969                 mFramebufferImageCache.pop_front();
970                 eglDestroyImageKHR(mEGLDisplay, expired);
971                 DEBUG_EGL_IMAGE_TRACKER_DESTROY();
972             }
973             mFramebufferImageCache.push_back({graphicBuffer->getId(), image});
974         }
975     }
976 
977     if (image != EGL_NO_IMAGE_KHR) {
978         DEBUG_EGL_IMAGE_TRACKER_CREATE();
979     }
980     return image;
981 }
982 
drawLayers(const DisplaySettings & display,const std::vector<const LayerSettings * > & layers,ANativeWindowBuffer * const buffer,const bool useFramebufferCache,base::unique_fd && bufferFence,base::unique_fd * drawFence)983 status_t GLESRenderEngine::drawLayers(const DisplaySettings& display,
984                                       const std::vector<const LayerSettings*>& layers,
985                                       ANativeWindowBuffer* const buffer,
986                                       const bool useFramebufferCache, base::unique_fd&& bufferFence,
987                                       base::unique_fd* drawFence) {
988     ATRACE_CALL();
989     if (layers.empty()) {
990         ALOGV("Drawing empty layer stack");
991         return NO_ERROR;
992     }
993 
994     if (bufferFence.get() >= 0) {
995         // Duplicate the fence for passing to waitFence.
996         base::unique_fd bufferFenceDup(dup(bufferFence.get()));
997         if (bufferFenceDup < 0 || !waitFence(std::move(bufferFenceDup))) {
998             ATRACE_NAME("Waiting before draw");
999             sync_wait(bufferFence.get(), -1);
1000         }
1001     }
1002 
1003     if (buffer == nullptr) {
1004         ALOGE("No output buffer provided. Aborting GPU composition.");
1005         return BAD_VALUE;
1006     }
1007 
1008     std::unique_ptr<BindNativeBufferAsFramebuffer> fbo;
1009     // Gathering layers that requested blur, we'll need them to decide when to render to an
1010     // offscreen buffer, and when to render to the native buffer.
1011     std::deque<const LayerSettings*> blurLayers;
1012     if (CC_LIKELY(mBlurFilter != nullptr)) {
1013         for (auto layer : layers) {
1014             if (layer->backgroundBlurRadius > 0) {
1015                 blurLayers.push_back(layer);
1016             }
1017         }
1018     }
1019     const auto blurLayersSize = blurLayers.size();
1020 
1021     if (blurLayersSize == 0) {
1022         fbo = std::make_unique<BindNativeBufferAsFramebuffer>(*this, buffer, useFramebufferCache);
1023         if (fbo->getStatus() != NO_ERROR) {
1024             ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",
1025                   buffer->handle);
1026             checkErrors();
1027             return fbo->getStatus();
1028         }
1029         setViewportAndProjection(display.physicalDisplay, display.clip);
1030     } else {
1031         setViewportAndProjection(display.physicalDisplay, display.clip);
1032         auto status =
1033                 mBlurFilter->setAsDrawTarget(display, blurLayers.front()->backgroundBlurRadius);
1034         if (status != NO_ERROR) {
1035             ALOGE("Failed to prepare blur filter! Aborting GPU composition for buffer (%p).",
1036                   buffer->handle);
1037             checkErrors();
1038             return status;
1039         }
1040     }
1041 
1042     // clear the entire buffer, sometimes when we reuse buffers we'd persist
1043     // ghost images otherwise.
1044     // we also require a full transparent framebuffer for overlays. This is
1045     // probably not quite efficient on all GPUs, since we could filter out
1046     // opaque layers.
1047     clearWithColor(0.0, 0.0, 0.0, 0.0);
1048 
1049     setOutputDataSpace(display.outputDataspace);
1050     setDisplayMaxLuminance(display.maxLuminance);
1051 
1052     const mat4 projectionMatrix =
1053             ui::Transform(display.orientation).asMatrix4() * mState.projectionMatrix;
1054     if (!display.clearRegion.isEmpty()) {
1055         glDisable(GL_BLEND);
1056         fillRegionWithColor(display.clearRegion, 0.0, 0.0, 0.0, 1.0);
1057     }
1058 
1059     Mesh mesh = Mesh::Builder()
1060                         .setPrimitive(Mesh::TRIANGLE_FAN)
1061                         .setVertices(4 /* count */, 2 /* size */)
1062                         .setTexCoords(2 /* size */)
1063                         .setCropCoords(2 /* size */)
1064                         .build();
1065     for (auto const layer : layers) {
1066         if (blurLayers.size() > 0 && blurLayers.front() == layer) {
1067             blurLayers.pop_front();
1068 
1069             auto status = mBlurFilter->prepare();
1070             if (status != NO_ERROR) {
1071                 ALOGE("Failed to render blur effect! Aborting GPU composition for buffer (%p).",
1072                       buffer->handle);
1073                 checkErrors("Can't render first blur pass");
1074                 return status;
1075             }
1076 
1077             if (blurLayers.size() == 0) {
1078                 // Done blurring, time to bind the native FBO and render our blur onto it.
1079                 fbo = std::make_unique<BindNativeBufferAsFramebuffer>(*this, buffer,
1080                                                                       useFramebufferCache);
1081                 status = fbo->getStatus();
1082                 setViewportAndProjection(display.physicalDisplay, display.clip);
1083             } else {
1084                 // There's still something else to blur, so let's keep rendering to our FBO
1085                 // instead of to the display.
1086                 status = mBlurFilter->setAsDrawTarget(display,
1087                                                       blurLayers.front()->backgroundBlurRadius);
1088             }
1089             if (status != NO_ERROR) {
1090                 ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",
1091                       buffer->handle);
1092                 checkErrors("Can't bind native framebuffer");
1093                 return status;
1094             }
1095 
1096             status = mBlurFilter->render(blurLayersSize > 1);
1097             if (status != NO_ERROR) {
1098                 ALOGE("Failed to render blur effect! Aborting GPU composition for buffer (%p).",
1099                       buffer->handle);
1100                 checkErrors("Can't render blur filter");
1101                 return status;
1102             }
1103         }
1104 
1105         mState.maxMasteringLuminance = layer->source.buffer.maxMasteringLuminance;
1106         mState.maxContentLuminance = layer->source.buffer.maxContentLuminance;
1107         mState.projectionMatrix = projectionMatrix * layer->geometry.positionTransform;
1108 
1109         const FloatRect bounds = layer->geometry.boundaries;
1110         Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
1111         position[0] = vec2(bounds.left, bounds.top);
1112         position[1] = vec2(bounds.left, bounds.bottom);
1113         position[2] = vec2(bounds.right, bounds.bottom);
1114         position[3] = vec2(bounds.right, bounds.top);
1115 
1116         setupLayerCropping(*layer, mesh);
1117         setColorTransform(display.colorTransform * layer->colorTransform);
1118 
1119         bool usePremultipliedAlpha = true;
1120         bool disableTexture = true;
1121         bool isOpaque = false;
1122         if (layer->source.buffer.buffer != nullptr) {
1123             disableTexture = false;
1124             isOpaque = layer->source.buffer.isOpaque;
1125 
1126             sp<GraphicBuffer> gBuf = layer->source.buffer.buffer;
1127             bindExternalTextureBuffer(layer->source.buffer.textureName, gBuf,
1128                                       layer->source.buffer.fence);
1129 
1130             usePremultipliedAlpha = layer->source.buffer.usePremultipliedAlpha;
1131             Texture texture(Texture::TEXTURE_EXTERNAL, layer->source.buffer.textureName);
1132             mat4 texMatrix = layer->source.buffer.textureTransform;
1133 
1134             texture.setMatrix(texMatrix.asArray());
1135             texture.setFiltering(layer->source.buffer.useTextureFiltering);
1136 
1137             texture.setDimensions(gBuf->getWidth(), gBuf->getHeight());
1138             setSourceY410BT2020(layer->source.buffer.isY410BT2020);
1139 
1140             renderengine::Mesh::VertexArray<vec2> texCoords(mesh.getTexCoordArray<vec2>());
1141             texCoords[0] = vec2(0.0, 0.0);
1142             texCoords[1] = vec2(0.0, 1.0);
1143             texCoords[2] = vec2(1.0, 1.0);
1144             texCoords[3] = vec2(1.0, 0.0);
1145             setupLayerTexturing(texture);
1146         }
1147 
1148         const half3 solidColor = layer->source.solidColor;
1149         const half4 color = half4(solidColor.r, solidColor.g, solidColor.b, layer->alpha);
1150         // Buffer sources will have a black solid color ignored in the shader,
1151         // so in that scenario the solid color passed here is arbitrary.
1152         setupLayerBlending(usePremultipliedAlpha, isOpaque, disableTexture, color,
1153                            layer->geometry.roundedCornersRadius);
1154         if (layer->disableBlending) {
1155             glDisable(GL_BLEND);
1156         }
1157         setSourceDataSpace(layer->sourceDataspace);
1158 
1159         if (layer->shadow.length > 0.0f) {
1160             handleShadow(layer->geometry.boundaries, layer->geometry.roundedCornersRadius,
1161                          layer->shadow);
1162         }
1163         // We only want to do a special handling for rounded corners when having rounded corners
1164         // is the only reason it needs to turn on blending, otherwise, we handle it like the
1165         // usual way since it needs to turn on blending anyway.
1166         else if (layer->geometry.roundedCornersRadius > 0.0 && color.a >= 1.0f && isOpaque) {
1167             handleRoundedCorners(display, *layer, mesh);
1168         } else {
1169             drawMesh(mesh);
1170         }
1171 
1172         // Cleanup if there's a buffer source
1173         if (layer->source.buffer.buffer != nullptr) {
1174             disableBlending();
1175             setSourceY410BT2020(false);
1176             disableTexturing();
1177         }
1178     }
1179 
1180     if (drawFence != nullptr) {
1181         *drawFence = flush();
1182     }
1183     // If flush failed or we don't support native fences, we need to force the
1184     // gl command stream to be executed.
1185     if (drawFence == nullptr || drawFence->get() < 0) {
1186         bool success = finish();
1187         if (!success) {
1188             ALOGE("Failed to flush RenderEngine commands");
1189             checkErrors();
1190             // Chances are, something illegal happened (either the caller passed
1191             // us bad parameters, or we messed up our shader generation).
1192             return INVALID_OPERATION;
1193         }
1194         mLastDrawFence = nullptr;
1195     } else {
1196         // The caller takes ownership of drawFence, so we need to duplicate the
1197         // fd here.
1198         mLastDrawFence = new Fence(dup(drawFence->get()));
1199     }
1200     mPriorResourcesCleaned = false;
1201 
1202     checkErrors();
1203     return NO_ERROR;
1204 }
1205 
setViewportAndProjection(Rect viewport,Rect clip)1206 void GLESRenderEngine::setViewportAndProjection(Rect viewport, Rect clip) {
1207     ATRACE_CALL();
1208     mVpWidth = viewport.getWidth();
1209     mVpHeight = viewport.getHeight();
1210 
1211     // We pass the the top left corner instead of the bottom left corner,
1212     // because since we're rendering off-screen first.
1213     glViewport(viewport.left, viewport.top, mVpWidth, mVpHeight);
1214 
1215     mState.projectionMatrix = mat4::ortho(clip.left, clip.right, clip.top, clip.bottom, 0, 1);
1216 }
1217 
setupLayerBlending(bool premultipliedAlpha,bool opaque,bool disableTexture,const half4 & color,float cornerRadius)1218 void GLESRenderEngine::setupLayerBlending(bool premultipliedAlpha, bool opaque, bool disableTexture,
1219                                           const half4& color, float cornerRadius) {
1220     mState.isPremultipliedAlpha = premultipliedAlpha;
1221     mState.isOpaque = opaque;
1222     mState.color = color;
1223     mState.cornerRadius = cornerRadius;
1224 
1225     if (disableTexture) {
1226         mState.textureEnabled = false;
1227     }
1228 
1229     if (color.a < 1.0f || !opaque || cornerRadius > 0.0f) {
1230         glEnable(GL_BLEND);
1231         glBlendFunc(premultipliedAlpha ? GL_ONE : GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1232     } else {
1233         glDisable(GL_BLEND);
1234     }
1235 }
1236 
setSourceY410BT2020(bool enable)1237 void GLESRenderEngine::setSourceY410BT2020(bool enable) {
1238     mState.isY410BT2020 = enable;
1239 }
1240 
setSourceDataSpace(Dataspace source)1241 void GLESRenderEngine::setSourceDataSpace(Dataspace source) {
1242     mDataSpace = source;
1243 }
1244 
setOutputDataSpace(Dataspace dataspace)1245 void GLESRenderEngine::setOutputDataSpace(Dataspace dataspace) {
1246     mOutputDataSpace = dataspace;
1247 }
1248 
setDisplayMaxLuminance(const float maxLuminance)1249 void GLESRenderEngine::setDisplayMaxLuminance(const float maxLuminance) {
1250     mState.displayMaxLuminance = maxLuminance;
1251 }
1252 
setupLayerTexturing(const Texture & texture)1253 void GLESRenderEngine::setupLayerTexturing(const Texture& texture) {
1254     GLuint target = texture.getTextureTarget();
1255     glBindTexture(target, texture.getTextureName());
1256     GLenum filter = GL_NEAREST;
1257     if (texture.getFiltering()) {
1258         filter = GL_LINEAR;
1259     }
1260     glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1261     glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1262     glTexParameteri(target, GL_TEXTURE_MAG_FILTER, filter);
1263     glTexParameteri(target, GL_TEXTURE_MIN_FILTER, filter);
1264 
1265     mState.texture = texture;
1266     mState.textureEnabled = true;
1267 }
1268 
setColorTransform(const mat4 & colorTransform)1269 void GLESRenderEngine::setColorTransform(const mat4& colorTransform) {
1270     mState.colorMatrix = colorTransform;
1271 }
1272 
disableTexturing()1273 void GLESRenderEngine::disableTexturing() {
1274     mState.textureEnabled = false;
1275 }
1276 
disableBlending()1277 void GLESRenderEngine::disableBlending() {
1278     glDisable(GL_BLEND);
1279 }
1280 
setupFillWithColor(float r,float g,float b,float a)1281 void GLESRenderEngine::setupFillWithColor(float r, float g, float b, float a) {
1282     mState.isPremultipliedAlpha = true;
1283     mState.isOpaque = false;
1284     mState.color = half4(r, g, b, a);
1285     mState.textureEnabled = false;
1286     glDisable(GL_BLEND);
1287 }
1288 
setupCornerRadiusCropSize(float width,float height)1289 void GLESRenderEngine::setupCornerRadiusCropSize(float width, float height) {
1290     mState.cropSize = half2(width, height);
1291 }
1292 
drawMesh(const Mesh & mesh)1293 void GLESRenderEngine::drawMesh(const Mesh& mesh) {
1294     ATRACE_CALL();
1295     if (mesh.getTexCoordsSize()) {
1296         glEnableVertexAttribArray(Program::texCoords);
1297         glVertexAttribPointer(Program::texCoords, mesh.getTexCoordsSize(), GL_FLOAT, GL_FALSE,
1298                               mesh.getByteStride(), mesh.getTexCoords());
1299     }
1300 
1301     glVertexAttribPointer(Program::position, mesh.getVertexSize(), GL_FLOAT, GL_FALSE,
1302                           mesh.getByteStride(), mesh.getPositions());
1303 
1304     if (mState.cornerRadius > 0.0f) {
1305         glEnableVertexAttribArray(Program::cropCoords);
1306         glVertexAttribPointer(Program::cropCoords, mesh.getVertexSize(), GL_FLOAT, GL_FALSE,
1307                               mesh.getByteStride(), mesh.getCropCoords());
1308     }
1309 
1310     if (mState.drawShadows) {
1311         glEnableVertexAttribArray(Program::shadowColor);
1312         glVertexAttribPointer(Program::shadowColor, mesh.getShadowColorSize(), GL_FLOAT, GL_FALSE,
1313                               mesh.getByteStride(), mesh.getShadowColor());
1314 
1315         glEnableVertexAttribArray(Program::shadowParams);
1316         glVertexAttribPointer(Program::shadowParams, mesh.getShadowParamsSize(), GL_FLOAT, GL_FALSE,
1317                               mesh.getByteStride(), mesh.getShadowParams());
1318     }
1319 
1320     Description managedState = mState;
1321     // By default, DISPLAY_P3 is the only supported wide color output. However,
1322     // when HDR content is present, hardware composer may be able to handle
1323     // BT2020 data space, in that case, the output data space is set to be
1324     // BT2020_HLG or BT2020_PQ respectively. In GPU fall back we need
1325     // to respect this and convert non-HDR content to HDR format.
1326     if (mUseColorManagement) {
1327         Dataspace inputStandard = static_cast<Dataspace>(mDataSpace & Dataspace::STANDARD_MASK);
1328         Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK);
1329         Dataspace outputStandard =
1330                 static_cast<Dataspace>(mOutputDataSpace & Dataspace::STANDARD_MASK);
1331         Dataspace outputTransfer =
1332                 static_cast<Dataspace>(mOutputDataSpace & Dataspace::TRANSFER_MASK);
1333         bool needsXYZConversion = needsXYZTransformMatrix();
1334 
1335         // NOTE: if the input standard of the input dataspace is not STANDARD_DCI_P3 or
1336         // STANDARD_BT2020, it will be  treated as STANDARD_BT709
1337         if (inputStandard != Dataspace::STANDARD_DCI_P3 &&
1338             inputStandard != Dataspace::STANDARD_BT2020) {
1339             inputStandard = Dataspace::STANDARD_BT709;
1340         }
1341 
1342         if (needsXYZConversion) {
1343             // The supported input color spaces are standard RGB, Display P3 and BT2020.
1344             switch (inputStandard) {
1345                 case Dataspace::STANDARD_DCI_P3:
1346                     managedState.inputTransformMatrix = mDisplayP3ToXyz;
1347                     break;
1348                 case Dataspace::STANDARD_BT2020:
1349                     managedState.inputTransformMatrix = mBt2020ToXyz;
1350                     break;
1351                 default:
1352                     managedState.inputTransformMatrix = mSrgbToXyz;
1353                     break;
1354             }
1355 
1356             // The supported output color spaces are BT2020, Display P3 and standard RGB.
1357             switch (outputStandard) {
1358                 case Dataspace::STANDARD_BT2020:
1359                     managedState.outputTransformMatrix = mXyzToBt2020;
1360                     break;
1361                 case Dataspace::STANDARD_DCI_P3:
1362                     managedState.outputTransformMatrix = mXyzToDisplayP3;
1363                     break;
1364                 default:
1365                     managedState.outputTransformMatrix = mXyzToSrgb;
1366                     break;
1367             }
1368         } else if (inputStandard != outputStandard) {
1369             // At this point, the input data space and output data space could be both
1370             // HDR data spaces, but they match each other, we do nothing in this case.
1371             // In addition to the case above, the input data space could be
1372             // - scRGB linear
1373             // - scRGB non-linear
1374             // - sRGB
1375             // - Display P3
1376             // - BT2020
1377             // The output data spaces could be
1378             // - sRGB
1379             // - Display P3
1380             // - BT2020
1381             switch (outputStandard) {
1382                 case Dataspace::STANDARD_BT2020:
1383                     if (inputStandard == Dataspace::STANDARD_BT709) {
1384                         managedState.outputTransformMatrix = mSrgbToBt2020;
1385                     } else if (inputStandard == Dataspace::STANDARD_DCI_P3) {
1386                         managedState.outputTransformMatrix = mDisplayP3ToBt2020;
1387                     }
1388                     break;
1389                 case Dataspace::STANDARD_DCI_P3:
1390                     if (inputStandard == Dataspace::STANDARD_BT709) {
1391                         managedState.outputTransformMatrix = mSrgbToDisplayP3;
1392                     } else if (inputStandard == Dataspace::STANDARD_BT2020) {
1393                         managedState.outputTransformMatrix = mBt2020ToDisplayP3;
1394                     }
1395                     break;
1396                 default:
1397                     if (inputStandard == Dataspace::STANDARD_DCI_P3) {
1398                         managedState.outputTransformMatrix = mDisplayP3ToSrgb;
1399                     } else if (inputStandard == Dataspace::STANDARD_BT2020) {
1400                         managedState.outputTransformMatrix = mBt2020ToSrgb;
1401                     }
1402                     break;
1403             }
1404         }
1405 
1406         // we need to convert the RGB value to linear space and convert it back when:
1407         // - there is a color matrix that is not an identity matrix, or
1408         // - there is an output transform matrix that is not an identity matrix, or
1409         // - the input transfer function doesn't match the output transfer function.
1410         if (managedState.hasColorMatrix() || managedState.hasOutputTransformMatrix() ||
1411             inputTransfer != outputTransfer) {
1412             managedState.inputTransferFunction =
1413                     Description::dataSpaceToTransferFunction(inputTransfer);
1414             managedState.outputTransferFunction =
1415                     Description::dataSpaceToTransferFunction(outputTransfer);
1416         }
1417     }
1418 
1419     ProgramCache::getInstance().useProgram(mInProtectedContext ? mProtectedEGLContext : mEGLContext,
1420                                            managedState);
1421 
1422     if (mState.drawShadows) {
1423         glDrawElements(mesh.getPrimitive(), mesh.getIndexCount(), GL_UNSIGNED_SHORT,
1424                        mesh.getIndices());
1425     } else {
1426         glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());
1427     }
1428 
1429     if (mUseColorManagement && outputDebugPPMs) {
1430         static uint64_t managedColorFrameCount = 0;
1431         std::ostringstream out;
1432         out << "/data/texture_out" << managedColorFrameCount++;
1433         writePPM(out.str().c_str(), mVpWidth, mVpHeight);
1434     }
1435 
1436     if (mesh.getTexCoordsSize()) {
1437         glDisableVertexAttribArray(Program::texCoords);
1438     }
1439 
1440     if (mState.cornerRadius > 0.0f) {
1441         glDisableVertexAttribArray(Program::cropCoords);
1442     }
1443 
1444     if (mState.drawShadows) {
1445         glDisableVertexAttribArray(Program::shadowColor);
1446         glDisableVertexAttribArray(Program::shadowParams);
1447     }
1448 }
1449 
getMaxTextureSize() const1450 size_t GLESRenderEngine::getMaxTextureSize() const {
1451     return mMaxTextureSize;
1452 }
1453 
getMaxViewportDims() const1454 size_t GLESRenderEngine::getMaxViewportDims() const {
1455     return mMaxViewportDims[0] < mMaxViewportDims[1] ? mMaxViewportDims[0] : mMaxViewportDims[1];
1456 }
1457 
dump(std::string & result)1458 void GLESRenderEngine::dump(std::string& result) {
1459     const GLExtensions& extensions = GLExtensions::getInstance();
1460     ProgramCache& cache = ProgramCache::getInstance();
1461 
1462     StringAppendF(&result, "EGL implementation : %s\n", extensions.getEGLVersion());
1463     StringAppendF(&result, "%s\n", extensions.getEGLExtensions());
1464     StringAppendF(&result, "GLES: %s, %s, %s\n", extensions.getVendor(), extensions.getRenderer(),
1465                   extensions.getVersion());
1466     StringAppendF(&result, "%s\n", extensions.getExtensions());
1467     StringAppendF(&result, "RenderEngine supports protected context: %d\n",
1468                   supportsProtectedContent());
1469     StringAppendF(&result, "RenderEngine is in protected context: %d\n", mInProtectedContext);
1470     StringAppendF(&result, "RenderEngine program cache size for unprotected context: %zu\n",
1471                   cache.getSize(mEGLContext));
1472     StringAppendF(&result, "RenderEngine program cache size for protected context: %zu\n",
1473                   cache.getSize(mProtectedEGLContext));
1474     StringAppendF(&result, "RenderEngine last dataspace conversion: (%s) to (%s)\n",
1475                   dataspaceDetails(static_cast<android_dataspace>(mDataSpace)).c_str(),
1476                   dataspaceDetails(static_cast<android_dataspace>(mOutputDataSpace)).c_str());
1477     {
1478         std::lock_guard<std::mutex> lock(mRenderingMutex);
1479         StringAppendF(&result, "RenderEngine image cache size: %zu\n", mImageCache.size());
1480         StringAppendF(&result, "Dumping buffer ids...\n");
1481         for (const auto& [id, unused] : mImageCache) {
1482             StringAppendF(&result, "0x%" PRIx64 "\n", id);
1483         }
1484     }
1485     {
1486         std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
1487         StringAppendF(&result, "RenderEngine framebuffer image cache size: %zu\n",
1488                       mFramebufferImageCache.size());
1489         StringAppendF(&result, "Dumping buffer ids...\n");
1490         for (const auto& [id, unused] : mFramebufferImageCache) {
1491             StringAppendF(&result, "0x%" PRIx64 "\n", id);
1492         }
1493     }
1494 }
1495 
parseGlesVersion(const char * str)1496 GLESRenderEngine::GlesVersion GLESRenderEngine::parseGlesVersion(const char* str) {
1497     int major, minor;
1498     if (sscanf(str, "OpenGL ES-CM %d.%d", &major, &minor) != 2) {
1499         if (sscanf(str, "OpenGL ES %d.%d", &major, &minor) != 2) {
1500             ALOGW("Unable to parse GL_VERSION string: \"%s\"", str);
1501             return GLES_VERSION_1_0;
1502         }
1503     }
1504 
1505     if (major == 1 && minor == 0) return GLES_VERSION_1_0;
1506     if (major == 1 && minor >= 1) return GLES_VERSION_1_1;
1507     if (major == 2 && minor >= 0) return GLES_VERSION_2_0;
1508     if (major == 3 && minor >= 0) return GLES_VERSION_3_0;
1509 
1510     ALOGW("Unrecognized OpenGL ES version: %d.%d", major, minor);
1511     return GLES_VERSION_1_0;
1512 }
1513 
createEglContext(EGLDisplay display,EGLConfig config,EGLContext shareContext,bool useContextPriority,Protection protection)1514 EGLContext GLESRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,
1515                                               EGLContext shareContext, bool useContextPriority,
1516                                               Protection protection) {
1517     EGLint renderableType = 0;
1518     if (config == EGL_NO_CONFIG) {
1519         renderableType = EGL_OPENGL_ES3_BIT;
1520     } else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) {
1521         LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");
1522     }
1523     EGLint contextClientVersion = 0;
1524     if (renderableType & EGL_OPENGL_ES3_BIT) {
1525         contextClientVersion = 3;
1526     } else if (renderableType & EGL_OPENGL_ES2_BIT) {
1527         contextClientVersion = 2;
1528     } else if (renderableType & EGL_OPENGL_ES_BIT) {
1529         contextClientVersion = 1;
1530     } else {
1531         LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs");
1532     }
1533 
1534     std::vector<EGLint> contextAttributes;
1535     contextAttributes.reserve(7);
1536     contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
1537     contextAttributes.push_back(contextClientVersion);
1538     if (useContextPriority) {
1539         contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG);
1540         contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG);
1541     }
1542     if (protection == Protection::PROTECTED) {
1543         contextAttributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1544         contextAttributes.push_back(EGL_TRUE);
1545     }
1546     contextAttributes.push_back(EGL_NONE);
1547 
1548     EGLContext context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1549 
1550     if (contextClientVersion == 3 && context == EGL_NO_CONTEXT) {
1551         // eglGetConfigAttrib indicated we can create GLES 3 context, but we failed, thus
1552         // EGL_NO_CONTEXT so that we can abort.
1553         if (config != EGL_NO_CONFIG) {
1554             return context;
1555         }
1556         // If |config| is EGL_NO_CONFIG, we speculatively try to create GLES 3 context, so we should
1557         // try to fall back to GLES 2.
1558         contextAttributes[1] = 2;
1559         context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1560     }
1561 
1562     return context;
1563 }
1564 
createDummyEglPbufferSurface(EGLDisplay display,EGLConfig config,int hwcFormat,Protection protection)1565 EGLSurface GLESRenderEngine::createDummyEglPbufferSurface(EGLDisplay display, EGLConfig config,
1566                                                           int hwcFormat, Protection protection) {
1567     EGLConfig dummyConfig = config;
1568     if (dummyConfig == EGL_NO_CONFIG) {
1569         dummyConfig = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);
1570     }
1571     std::vector<EGLint> attributes;
1572     attributes.reserve(7);
1573     attributes.push_back(EGL_WIDTH);
1574     attributes.push_back(1);
1575     attributes.push_back(EGL_HEIGHT);
1576     attributes.push_back(1);
1577     if (protection == Protection::PROTECTED) {
1578         attributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1579         attributes.push_back(EGL_TRUE);
1580     }
1581     attributes.push_back(EGL_NONE);
1582 
1583     return eglCreatePbufferSurface(display, dummyConfig, attributes.data());
1584 }
1585 
isHdrDataSpace(const Dataspace dataSpace) const1586 bool GLESRenderEngine::isHdrDataSpace(const Dataspace dataSpace) const {
1587     const Dataspace standard = static_cast<Dataspace>(dataSpace & Dataspace::STANDARD_MASK);
1588     const Dataspace transfer = static_cast<Dataspace>(dataSpace & Dataspace::TRANSFER_MASK);
1589     return standard == Dataspace::STANDARD_BT2020 &&
1590             (transfer == Dataspace::TRANSFER_ST2084 || transfer == Dataspace::TRANSFER_HLG);
1591 }
1592 
1593 // For convenience, we want to convert the input color space to XYZ color space first,
1594 // and then convert from XYZ color space to output color space when
1595 // - SDR and HDR contents are mixed, either SDR content will be converted to HDR or
1596 //   HDR content will be tone-mapped to SDR; Or,
1597 // - there are HDR PQ and HLG contents presented at the same time, where we want to convert
1598 //   HLG content to PQ content.
1599 // In either case above, we need to operate the Y value in XYZ color space. Thus, when either
1600 // input data space or output data space is HDR data space, and the input transfer function
1601 // doesn't match the output transfer function, we would enable an intermediate transfrom to
1602 // XYZ color space.
needsXYZTransformMatrix() const1603 bool GLESRenderEngine::needsXYZTransformMatrix() const {
1604     const bool isInputHdrDataSpace = isHdrDataSpace(mDataSpace);
1605     const bool isOutputHdrDataSpace = isHdrDataSpace(mOutputDataSpace);
1606     const Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK);
1607     const Dataspace outputTransfer =
1608             static_cast<Dataspace>(mOutputDataSpace & Dataspace::TRANSFER_MASK);
1609 
1610     return (isInputHdrDataSpace || isOutputHdrDataSpace) && inputTransfer != outputTransfer;
1611 }
1612 
isImageCachedForTesting(uint64_t bufferId)1613 bool GLESRenderEngine::isImageCachedForTesting(uint64_t bufferId) {
1614     std::lock_guard<std::mutex> lock(mRenderingMutex);
1615     const auto& cachedImage = mImageCache.find(bufferId);
1616     return cachedImage != mImageCache.end();
1617 }
1618 
isFramebufferImageCachedForTesting(uint64_t bufferId)1619 bool GLESRenderEngine::isFramebufferImageCachedForTesting(uint64_t bufferId) {
1620     std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
1621     return std::any_of(mFramebufferImageCache.cbegin(), mFramebufferImageCache.cend(),
1622                        [=](std::pair<uint64_t, EGLImageKHR> image) {
1623                            return image.first == bufferId;
1624                        });
1625 }
1626 
1627 // FlushTracer implementation
FlushTracer(GLESRenderEngine * engine)1628 GLESRenderEngine::FlushTracer::FlushTracer(GLESRenderEngine* engine) : mEngine(engine) {
1629     mThread = std::thread(&GLESRenderEngine::FlushTracer::loop, this);
1630 }
1631 
~FlushTracer()1632 GLESRenderEngine::FlushTracer::~FlushTracer() {
1633     {
1634         std::lock_guard<std::mutex> lock(mMutex);
1635         mRunning = false;
1636     }
1637     mCondition.notify_all();
1638     if (mThread.joinable()) {
1639         mThread.join();
1640     }
1641 }
1642 
queueSync(EGLSyncKHR sync)1643 void GLESRenderEngine::FlushTracer::queueSync(EGLSyncKHR sync) {
1644     std::lock_guard<std::mutex> lock(mMutex);
1645     char name[64];
1646     const uint64_t frameNum = mFramesQueued++;
1647     snprintf(name, sizeof(name), "Queueing sync for frame: %lu",
1648              static_cast<unsigned long>(frameNum));
1649     ATRACE_NAME(name);
1650     mQueue.push({sync, frameNum});
1651     ATRACE_INT("GPU Frames Outstanding", mQueue.size());
1652     mCondition.notify_one();
1653 }
1654 
loop()1655 void GLESRenderEngine::FlushTracer::loop() {
1656     while (mRunning) {
1657         QueueEntry entry;
1658         {
1659             std::lock_guard<std::mutex> lock(mMutex);
1660 
1661             mCondition.wait(mMutex,
1662                             [&]() REQUIRES(mMutex) { return !mQueue.empty() || !mRunning; });
1663 
1664             if (!mRunning) {
1665                 // if mRunning is false, then FlushTracer is being destroyed, so
1666                 // bail out now.
1667                 break;
1668             }
1669             entry = mQueue.front();
1670             mQueue.pop();
1671         }
1672         {
1673             char name[64];
1674             snprintf(name, sizeof(name), "waiting for frame %lu",
1675                      static_cast<unsigned long>(entry.mFrameNum));
1676             ATRACE_NAME(name);
1677             mEngine->waitSync(entry.mSync, 0);
1678         }
1679     }
1680 }
1681 
handleShadow(const FloatRect & casterRect,float casterCornerRadius,const ShadowSettings & settings)1682 void GLESRenderEngine::handleShadow(const FloatRect& casterRect, float casterCornerRadius,
1683                                     const ShadowSettings& settings) {
1684     ATRACE_CALL();
1685     const float casterZ = settings.length / 2.0f;
1686     const GLShadowVertexGenerator shadows(casterRect, casterCornerRadius, casterZ,
1687                                           settings.casterIsTranslucent, settings.ambientColor,
1688                                           settings.spotColor, settings.lightPos,
1689                                           settings.lightRadius);
1690 
1691     // setup mesh for both shadows
1692     Mesh mesh = Mesh::Builder()
1693                         .setPrimitive(Mesh::TRIANGLES)
1694                         .setVertices(shadows.getVertexCount(), 2 /* size */)
1695                         .setShadowAttrs()
1696                         .setIndices(shadows.getIndexCount())
1697                         .build();
1698 
1699     Mesh::VertexArray<vec2> position = mesh.getPositionArray<vec2>();
1700     Mesh::VertexArray<vec4> shadowColor = mesh.getShadowColorArray<vec4>();
1701     Mesh::VertexArray<vec3> shadowParams = mesh.getShadowParamsArray<vec3>();
1702     shadows.fillVertices(position, shadowColor, shadowParams);
1703     shadows.fillIndices(mesh.getIndicesArray());
1704 
1705     mState.cornerRadius = 0.0f;
1706     mState.drawShadows = true;
1707     setupLayerTexturing(mShadowTexture.getTexture());
1708     drawMesh(mesh);
1709     mState.drawShadows = false;
1710 }
1711 
1712 } // namespace gl
1713 } // namespace renderengine
1714 } // namespace android
1715