blob: 7caaef35be51397da95b28d4eef0b72d961ebbc2 [file] [log] [blame]
Mathias Agopian3f844832013-08-07 21:24:32 -07001/*
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
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -060017//#define LOG_NDEBUG 0
18#undef LOG_TAG
19#define LOG_TAG "RenderEngine"
Mathias Agopian3f844832013-08-07 21:24:32 -070020#define ATRACE_TAG ATRACE_TAG_GRAPHICS
21
Peiyong Lin7e219eb2018-12-03 05:40:42 -080022#include "GLESRenderEngine.h"
Peiyong Lin833074a2018-08-28 11:53:54 -070023
24#include <math.h>
25#include <fstream>
26#include <sstream>
Alec Mouri0d5e1eb2018-11-10 20:40:12 -080027#include <unordered_set>
Peiyong Lincbc184f2018-08-22 13:24:10 -070028
Mathias Agopian3f844832013-08-07 21:24:32 -070029#include <GLES2/gl2.h>
Mathias Agopian458197d2013-08-15 14:56:51 -070030#include <GLES2/gl2ext.h>
Yiwei Zhang5434a782018-12-05 18:06:32 -080031#include <android-base/stringprintf.h>
Peiyong Lin833074a2018-08-28 11:53:54 -070032#include <cutils/compiler.h>
Alec Mouri554d06e2018-12-20 00:15:33 -080033#include <cutils/properties.h>
Ady Abrahama3b08ef2019-07-15 18:43:10 -070034#include <gui/DebugEGLImageTracker.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070035#include <renderengine/Mesh.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070036#include <renderengine/Texture.h>
Peiyong Lin833074a2018-08-28 11:53:54 -070037#include <renderengine/private/Description.h>
Alec Mouri0d5e1eb2018-11-10 20:40:12 -080038#include <sync/sync.h>
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -060039#include <ui/ColorSpace.h>
40#include <ui/DebugUtils.h>
Alec Mourida4cf3b2019-02-12 15:33:01 -080041#include <ui/GraphicBuffer.h>
Dan Stozac1879002014-05-22 15:59:05 -070042#include <ui/Rect.h>
Peiyong Lin60bedb52018-09-05 10:47:31 -070043#include <ui/Region.h>
Chia-I Wu56d7b0a2018-10-01 15:13:11 -070044#include <utils/KeyedVector.h>
Mathias Agopian3f844832013-08-07 21:24:32 -070045#include <utils/Trace.h>
Peiyong Linf1bada92018-08-29 09:39:31 -070046#include "GLExtensions.h"
Peiyong Line5a9a7f2018-08-30 15:32:13 -070047#include "GLFramebuffer.h"
Peiyong Linf1bada92018-08-29 09:39:31 -070048#include "GLImage.h"
Peiyong Lin833074a2018-08-28 11:53:54 -070049#include "Program.h"
50#include "ProgramCache.h"
Mathias Agopian3f844832013-08-07 21:24:32 -070051
Peiyong Linf11f39b2018-09-05 14:37:41 -070052extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
53
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -060054bool checkGlError(const char* op, int lineNumber) {
55 bool errorFound = false;
56 GLint error = glGetError();
57 while (error != GL_NO_ERROR) {
58 errorFound = true;
59 error = glGetError();
60 ALOGV("after %s() (line # %d) glError (0x%x)\n", op, lineNumber, error);
61 }
62 return errorFound;
63}
64
Courtney Goeltzenleuchter4f20f9c2017-04-06 08:18:34 -060065static constexpr bool outputDebugPPMs = false;
66
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -060067void writePPM(const char* basename, GLuint width, GLuint height) {
68 ALOGV("writePPM #%s: %d x %d", basename, width, height);
69
70 std::vector<GLubyte> pixels(width * height * 4);
71 std::vector<GLubyte> outBuffer(width * height * 3);
72
73 // TODO(courtneygo): We can now have float formats, need
74 // to remove this code or update to support.
75 // Make returned pixels fit in uint32_t, one byte per component
76 glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
77 if (checkGlError(__FUNCTION__, __LINE__)) {
78 return;
79 }
80
81 std::string filename(basename);
82 filename.append(".ppm");
83 std::ofstream file(filename.c_str(), std::ios::binary);
84 if (!file.is_open()) {
85 ALOGE("Unable to open file: %s", filename.c_str());
86 ALOGE("You may need to do: \"adb shell setenforce 0\" to enable "
87 "surfaceflinger to write debug images");
88 return;
89 }
90
91 file << "P6\n";
92 file << width << "\n";
93 file << height << "\n";
94 file << 255 << "\n";
95
96 auto ptr = reinterpret_cast<char*>(pixels.data());
97 auto outPtr = reinterpret_cast<char*>(outBuffer.data());
98 for (int y = height - 1; y >= 0; y--) {
99 char* data = ptr + y * width * sizeof(uint32_t);
100
101 for (GLuint x = 0; x < width; x++) {
102 // Only copy R, G and B components
103 outPtr[0] = data[0];
104 outPtr[1] = data[1];
105 outPtr[2] = data[2];
106 data += sizeof(uint32_t);
107 outPtr += 3;
108 }
109 }
110 file.write(reinterpret_cast<char*>(outBuffer.data()), outBuffer.size());
111}
112
Mathias Agopian3f844832013-08-07 21:24:32 -0700113namespace android {
Peiyong Lin833074a2018-08-28 11:53:54 -0700114namespace renderengine {
115namespace gl {
Mathias Agopian3f844832013-08-07 21:24:32 -0700116
Yiwei Zhang5434a782018-12-05 18:06:32 -0800117using base::StringAppendF;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700118using ui::Dataspace;
119
Peiyong Linf11f39b2018-09-05 14:37:41 -0700120static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs, EGLint attribute,
121 EGLint wanted, EGLConfig* outConfig) {
122 EGLint numConfigs = -1, n = 0;
123 eglGetConfigs(dpy, nullptr, 0, &numConfigs);
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700124 std::vector<EGLConfig> configs(numConfigs, EGL_NO_CONFIG_KHR);
125 eglChooseConfig(dpy, attrs, configs.data(), configs.size(), &n);
126 configs.resize(n);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700127
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700128 if (!configs.empty()) {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700129 if (attribute != EGL_NONE) {
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700130 for (EGLConfig config : configs) {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700131 EGLint value = 0;
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700132 eglGetConfigAttrib(dpy, config, attribute, &value);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700133 if (wanted == value) {
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700134 *outConfig = config;
Peiyong Linf11f39b2018-09-05 14:37:41 -0700135 return NO_ERROR;
136 }
137 }
138 } else {
139 // just pick the first one
140 *outConfig = configs[0];
Peiyong Linf11f39b2018-09-05 14:37:41 -0700141 return NO_ERROR;
142 }
143 }
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700144
Peiyong Linf11f39b2018-09-05 14:37:41 -0700145 return NAME_NOT_FOUND;
146}
147
148class EGLAttributeVector {
149 struct Attribute;
150 class Adder;
151 friend class Adder;
152 KeyedVector<Attribute, EGLint> mList;
153 struct Attribute {
154 Attribute() : v(0){};
155 explicit Attribute(EGLint v) : v(v) {}
156 EGLint v;
157 bool operator<(const Attribute& other) const {
158 // this places EGL_NONE at the end
159 EGLint lhs(v);
160 EGLint rhs(other.v);
161 if (lhs == EGL_NONE) lhs = 0x7FFFFFFF;
162 if (rhs == EGL_NONE) rhs = 0x7FFFFFFF;
163 return lhs < rhs;
164 }
165 };
166 class Adder {
167 friend class EGLAttributeVector;
168 EGLAttributeVector& v;
169 EGLint attribute;
170 Adder(EGLAttributeVector& v, EGLint attribute) : v(v), attribute(attribute) {}
171
172 public:
173 void operator=(EGLint value) {
174 if (attribute != EGL_NONE) {
175 v.mList.add(Attribute(attribute), value);
176 }
177 }
178 operator EGLint() const { return v.mList[attribute]; }
179 };
180
181public:
182 EGLAttributeVector() { mList.add(Attribute(EGL_NONE), EGL_NONE); }
183 void remove(EGLint attribute) {
184 if (attribute != EGL_NONE) {
185 mList.removeItem(Attribute(attribute));
186 }
187 }
188 Adder operator[](EGLint attribute) { return Adder(*this, attribute); }
189 EGLint operator[](EGLint attribute) const { return mList[attribute]; }
190 // cast-operator to (EGLint const*)
191 operator EGLint const*() const { return &mList.keyAt(0).v; }
192};
193
194static status_t selectEGLConfig(EGLDisplay display, EGLint format, EGLint renderableType,
195 EGLConfig* config) {
196 // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if
197 // it is to be used with WIFI displays
198 status_t err;
199 EGLint wantedAttribute;
200 EGLint wantedAttributeValue;
201
202 EGLAttributeVector attribs;
203 if (renderableType) {
204 attribs[EGL_RENDERABLE_TYPE] = renderableType;
205 attribs[EGL_RECORDABLE_ANDROID] = EGL_TRUE;
206 attribs[EGL_SURFACE_TYPE] = EGL_WINDOW_BIT | EGL_PBUFFER_BIT;
207 attribs[EGL_FRAMEBUFFER_TARGET_ANDROID] = EGL_TRUE;
208 attribs[EGL_RED_SIZE] = 8;
209 attribs[EGL_GREEN_SIZE] = 8;
210 attribs[EGL_BLUE_SIZE] = 8;
211 attribs[EGL_ALPHA_SIZE] = 8;
212 wantedAttribute = EGL_NONE;
213 wantedAttributeValue = EGL_NONE;
214 } else {
215 // if no renderable type specified, fallback to a simplified query
216 wantedAttribute = EGL_NATIVE_VISUAL_ID;
217 wantedAttributeValue = format;
218 }
219
220 err = selectConfigForAttribute(display, attribs, wantedAttribute, wantedAttributeValue, config);
221 if (err == NO_ERROR) {
222 EGLint caveat;
223 if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat))
224 ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!");
225 }
226
227 return err;
228}
229
Alec Mourida4cf3b2019-02-12 15:33:01 -0800230std::unique_ptr<GLESRenderEngine> GLESRenderEngine::create(int hwcFormat, uint32_t featureFlags,
231 uint32_t imageCacheSize) {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700232 // initialize EGL for the default display
233 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
234 if (!eglInitialize(display, nullptr, nullptr)) {
235 LOG_ALWAYS_FATAL("failed to initialize EGL");
236 }
237
238 GLExtensions& extensions = GLExtensions::getInstance();
239 extensions.initWithEGLStrings(eglQueryStringImplementationANDROID(display, EGL_VERSION),
240 eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS));
241
242 // The code assumes that ES2 or later is available if this extension is
243 // supported.
244 EGLConfig config = EGL_NO_CONFIG;
245 if (!extensions.hasNoConfigContext()) {
246 config = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);
247 }
248
Peiyong Linf11f39b2018-09-05 14:37:41 -0700249 bool useContextPriority = extensions.hasContextPriority() &&
Peiyong Lin46080ef2018-10-26 18:43:14 -0700250 (featureFlags & RenderEngine::USE_HIGH_PRIORITY_CONTEXT);
Peiyong Linfb530cf2018-12-15 05:07:38 +0000251 EGLContext protectedContext = EGL_NO_CONTEXT;
Peiyong Lin6a043d52019-04-01 17:18:21 -0700252 if ((featureFlags & RenderEngine::ENABLE_PROTECTED_CONTEXT) &&
253 extensions.hasProtectedContent()) {
Peiyong Linfb530cf2018-12-15 05:07:38 +0000254 protectedContext = createEglContext(display, config, nullptr, useContextPriority,
255 Protection::PROTECTED);
256 ALOGE_IF(protectedContext == EGL_NO_CONTEXT, "Can't create protected context");
257 }
258
259 EGLContext ctxt = createEglContext(display, config, protectedContext, useContextPriority,
260 Protection::UNPROTECTED);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700261
262 // if can't create a GL context, we can only abort.
263 LOG_ALWAYS_FATAL_IF(ctxt == EGL_NO_CONTEXT, "EGLContext creation failed");
264
Peiyong Lina5e9f1b2018-11-27 22:49:37 -0800265 EGLSurface dummy = EGL_NO_SURFACE;
266 if (!extensions.hasSurfacelessContext()) {
Peiyong Linfb530cf2018-12-15 05:07:38 +0000267 dummy = createDummyEglPbufferSurface(display, config, hwcFormat, Protection::UNPROTECTED);
Peiyong Lina5e9f1b2018-11-27 22:49:37 -0800268 LOG_ALWAYS_FATAL_IF(dummy == EGL_NO_SURFACE, "can't create dummy pbuffer");
Peiyong Linf11f39b2018-09-05 14:37:41 -0700269 }
Peiyong Linf11f39b2018-09-05 14:37:41 -0700270 EGLBoolean success = eglMakeCurrent(display, dummy, dummy, ctxt);
271 LOG_ALWAYS_FATAL_IF(!success, "can't make dummy pbuffer current");
Peiyong Linf11f39b2018-09-05 14:37:41 -0700272 extensions.initWithGLStrings(glGetString(GL_VENDOR), glGetString(GL_RENDERER),
273 glGetString(GL_VERSION), glGetString(GL_EXTENSIONS));
274
Peiyong Linfb530cf2018-12-15 05:07:38 +0000275 EGLSurface protectedDummy = EGL_NO_SURFACE;
276 if (protectedContext != EGL_NO_CONTEXT && !extensions.hasSurfacelessContext()) {
277 protectedDummy =
278 createDummyEglPbufferSurface(display, config, hwcFormat, Protection::PROTECTED);
279 ALOGE_IF(protectedDummy == EGL_NO_SURFACE, "can't create protected dummy pbuffer");
280 }
281
Peiyong Lina5e9f1b2018-11-27 22:49:37 -0800282 // now figure out what version of GL did we actually get
Peiyong Linf11f39b2018-09-05 14:37:41 -0700283 GlesVersion version = parseGlesVersion(extensions.getVersion());
284
285 // initialize the renderer while GL is current
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800286 std::unique_ptr<GLESRenderEngine> engine;
Peiyong Linf11f39b2018-09-05 14:37:41 -0700287 switch (version) {
288 case GLES_VERSION_1_0:
289 case GLES_VERSION_1_1:
290 LOG_ALWAYS_FATAL("SurfaceFlinger requires OpenGL ES 2.0 minimum to run.");
291 break;
292 case GLES_VERSION_2_0:
293 case GLES_VERSION_3_0:
Peiyong Linfb530cf2018-12-15 05:07:38 +0000294 engine = std::make_unique<GLESRenderEngine>(featureFlags, display, config, ctxt, dummy,
Alec Mourida4cf3b2019-02-12 15:33:01 -0800295 protectedContext, protectedDummy,
296 imageCacheSize);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700297 break;
298 }
Peiyong Linf11f39b2018-09-05 14:37:41 -0700299
300 ALOGI("OpenGL ES informations:");
301 ALOGI("vendor : %s", extensions.getVendor());
302 ALOGI("renderer : %s", extensions.getRenderer());
303 ALOGI("version : %s", extensions.getVersion());
304 ALOGI("extensions: %s", extensions.getExtensions());
305 ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize());
306 ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims());
307
Peiyong Linf11f39b2018-09-05 14:37:41 -0700308 return engine;
309}
310
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800311EGLConfig GLESRenderEngine::chooseEglConfig(EGLDisplay display, int format, bool logConfig) {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700312 status_t err;
313 EGLConfig config;
314
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800315 // First try to get an ES3 config
316 err = selectEGLConfig(display, format, EGL_OPENGL_ES3_BIT, &config);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700317 if (err != NO_ERROR) {
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800318 // If ES3 fails, try to get an ES2 config
319 err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700320 if (err != NO_ERROR) {
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800321 // If ES2 still doesn't work, probably because we're on the emulator.
Peiyong Linf11f39b2018-09-05 14:37:41 -0700322 // try a simplified query
323 ALOGW("no suitable EGLConfig found, trying a simpler query");
324 err = selectEGLConfig(display, format, 0, &config);
325 if (err != NO_ERROR) {
326 // this EGL is too lame for android
327 LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up");
328 }
329 }
330 }
331
332 if (logConfig) {
333 // print some debugging info
334 EGLint r, g, b, a;
335 eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r);
336 eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
337 eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);
338 eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);
339 ALOGI("EGL information:");
340 ALOGI("vendor : %s", eglQueryString(display, EGL_VENDOR));
341 ALOGI("version : %s", eglQueryString(display, EGL_VERSION));
342 ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS));
343 ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS) ?: "Not Supported");
344 ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);
345 }
346
347 return config;
348}
349
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800350GLESRenderEngine::GLESRenderEngine(uint32_t featureFlags, EGLDisplay display, EGLConfig config,
Peiyong Linfb530cf2018-12-15 05:07:38 +0000351 EGLContext ctxt, EGLSurface dummy, EGLContext protectedContext,
Alec Mourida4cf3b2019-02-12 15:33:01 -0800352 EGLSurface protectedDummy, uint32_t imageCacheSize)
Peiyong Linf11f39b2018-09-05 14:37:41 -0700353 : renderengine::impl::RenderEngine(featureFlags),
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800354 mEGLDisplay(display),
355 mEGLConfig(config),
356 mEGLContext(ctxt),
357 mDummySurface(dummy),
Peiyong Linfb530cf2018-12-15 05:07:38 +0000358 mProtectedEGLContext(protectedContext),
359 mProtectedDummySurface(protectedDummy),
Chia-I Wu93e14df2018-06-04 10:10:17 -0700360 mVpWidth(0),
361 mVpHeight(0),
Alec Mourida4cf3b2019-02-12 15:33:01 -0800362 mFramebufferImageCacheSize(imageCacheSize),
Peiyong Lin13effd12018-07-24 17:01:47 -0700363 mUseColorManagement(featureFlags & USE_COLOR_MANAGEMENT) {
Mathias Agopian3f844832013-08-07 21:24:32 -0700364 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
365 glGetIntegerv(GL_MAX_VIEWPORT_DIMS, mMaxViewportDims);
366
367 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
368 glPixelStorei(GL_PACK_ALIGNMENT, 4);
369
Peiyong Linfb530cf2018-12-15 05:07:38 +0000370 // Initialize protected EGL Context.
371 if (mProtectedEGLContext != EGL_NO_CONTEXT) {
372 EGLBoolean success = eglMakeCurrent(display, mProtectedDummySurface, mProtectedDummySurface,
373 mProtectedEGLContext);
374 ALOGE_IF(!success, "can't make protected context current");
375 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
376 glPixelStorei(GL_PACK_ALIGNMENT, 4);
377 success = eglMakeCurrent(display, mDummySurface, mDummySurface, mEGLContext);
378 LOG_ALWAYS_FATAL_IF(!success, "can't make default context current");
379 }
380
Chia-I Wub027f802017-11-29 14:00:52 -0800381 const uint16_t protTexData[] = {0};
Mathias Agopian3f844832013-08-07 21:24:32 -0700382 glGenTextures(1, &mProtectedTexName);
383 glBindTexture(GL_TEXTURE_2D, mProtectedTexName);
384 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
385 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
386 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
387 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
Chia-I Wub027f802017-11-29 14:00:52 -0800388 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, protTexData);
Mathias Agopianff2ed702013-09-01 21:36:12 -0700389
Chia-I Wub027f802017-11-29 14:00:52 -0800390 // mColorBlindnessCorrection = M;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600391
Peiyong Lin13effd12018-07-24 17:01:47 -0700392 if (mUseColorManagement) {
Valerie Haueb8e0762018-11-06 10:10:42 -0800393 const ColorSpace srgb(ColorSpace::sRGB());
394 const ColorSpace displayP3(ColorSpace::DisplayP3());
395 const ColorSpace bt2020(ColorSpace::BT2020());
Peiyong Lina296b0c2018-04-30 16:55:29 -0700396
397 // no chromatic adaptation needed since all color spaces use D65 for their white points.
Peiyong Lin70b26ce2018-09-18 19:02:39 -0700398 mSrgbToXyz = mat4(srgb.getRGBtoXYZ());
399 mDisplayP3ToXyz = mat4(displayP3.getRGBtoXYZ());
400 mBt2020ToXyz = mat4(bt2020.getRGBtoXYZ());
Peiyong Lin9b03c732018-05-17 10:14:02 -0700401 mXyzToSrgb = mat4(srgb.getXYZtoRGB());
Peiyong Lina296b0c2018-04-30 16:55:29 -0700402 mXyzToDisplayP3 = mat4(displayP3.getXYZtoRGB());
403 mXyzToBt2020 = mat4(bt2020.getXYZtoRGB());
Valerie Haueb8e0762018-11-06 10:10:42 -0800404
405 // Compute sRGB to Display P3 and BT2020 transform matrix.
406 // NOTE: For now, we are limiting output wide color space support to
407 // Display-P3 and BT2020 only.
408 mSrgbToDisplayP3 = mXyzToDisplayP3 * mSrgbToXyz;
409 mSrgbToBt2020 = mXyzToBt2020 * mSrgbToXyz;
410
411 // Compute Display P3 to sRGB and BT2020 transform matrix.
412 mDisplayP3ToSrgb = mXyzToSrgb * mDisplayP3ToXyz;
413 mDisplayP3ToBt2020 = mXyzToBt2020 * mDisplayP3ToXyz;
414
415 // Compute BT2020 to sRGB and Display P3 transform matrix
416 mBt2020ToSrgb = mXyzToSrgb * mBt2020ToXyz;
417 mBt2020ToDisplayP3 = mXyzToDisplayP3 * mBt2020ToXyz;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600418 }
Alec Mouri554d06e2018-12-20 00:15:33 -0800419
420 char value[PROPERTY_VALUE_MAX];
421 property_get("debug.egl.traceGpuCompletion", value, "0");
422 if (atoi(value)) {
423 mTraceGpuCompletion = true;
424 mFlushTracer = std::make_unique<FlushTracer>(this);
425 }
Alec Mouri820c7402019-01-23 13:02:39 -0800426 mDrawingBuffer = createFramebuffer();
Mathias Agopian3f844832013-08-07 21:24:32 -0700427}
428
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800429GLESRenderEngine::~GLESRenderEngine() {
Alec Mourid43ccab2019-03-13 12:23:45 -0700430 std::lock_guard<std::mutex> lock(mRenderingMutex);
431 unbindFrameBuffer(mDrawingBuffer.get());
432 mDrawingBuffer = nullptr;
433 while (!mFramebufferImageCache.empty()) {
434 EGLImageKHR expired = mFramebufferImageCache.front().second;
435 mFramebufferImageCache.pop_front();
436 eglDestroyImageKHR(mEGLDisplay, expired);
Ady Abrahama3b08ef2019-07-15 18:43:10 -0700437 DEBUG_EGL_IMAGE_TRACKER_DESTROY();
Alec Mourida4cf3b2019-02-12 15:33:01 -0800438 }
Alec Mourid43ccab2019-03-13 12:23:45 -0700439 mImageCache.clear();
Peiyong Linf11f39b2018-09-05 14:37:41 -0700440 eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
441 eglTerminate(mEGLDisplay);
442}
Mathias Agopian3f844832013-08-07 21:24:32 -0700443
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800444std::unique_ptr<Framebuffer> GLESRenderEngine::createFramebuffer() {
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700445 return std::make_unique<GLFramebuffer>(*this);
446}
447
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800448std::unique_ptr<Image> GLESRenderEngine::createImage() {
Peiyong Linf1bada92018-08-29 09:39:31 -0700449 return std::make_unique<GLImage>(*this);
450}
451
Alec Mouri820c7402019-01-23 13:02:39 -0800452Framebuffer* GLESRenderEngine::getFramebufferForDrawing() {
453 return mDrawingBuffer.get();
454}
455
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800456void GLESRenderEngine::primeCache() const {
Peiyong Linfb530cf2018-12-15 05:07:38 +0000457 ProgramCache::getInstance().primeCache(mInProtectedContext ? mProtectedEGLContext : mEGLContext,
458 mFeatureFlags & USE_COLOR_MANAGEMENT);
Peiyong Linf1bada92018-08-29 09:39:31 -0700459}
460
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800461bool GLESRenderEngine::isCurrent() const {
Peiyong Linf1bada92018-08-29 09:39:31 -0700462 return mEGLDisplay == eglGetCurrentDisplay() && mEGLContext == eglGetCurrentContext();
463}
464
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800465base::unique_fd GLESRenderEngine::flush() {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000466 ATRACE_CALL();
Peiyong Lin60bedb52018-09-05 10:47:31 -0700467 if (!GLExtensions::getInstance().hasNativeFenceSync()) {
468 return base::unique_fd();
469 }
470
471 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
472 if (sync == EGL_NO_SYNC_KHR) {
473 ALOGW("failed to create EGL native fence sync: %#x", eglGetError());
474 return base::unique_fd();
475 }
476
477 // native fence fd will not be populated until flush() is done.
478 glFlush();
479
480 // get the fence fd
481 base::unique_fd fenceFd(eglDupNativeFenceFDANDROID(mEGLDisplay, sync));
482 eglDestroySyncKHR(mEGLDisplay, sync);
483 if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
484 ALOGW("failed to dup EGL native fence sync: %#x", eglGetError());
485 }
486
Alec Mouri554d06e2018-12-20 00:15:33 -0800487 // Only trace if we have a valid fence, as current usage falls back to
488 // calling finish() if the fence fd is invalid.
489 if (CC_UNLIKELY(mTraceGpuCompletion && mFlushTracer) && fenceFd.get() >= 0) {
490 mFlushTracer->queueSync(eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr));
491 }
492
Peiyong Lin60bedb52018-09-05 10:47:31 -0700493 return fenceFd;
494}
495
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800496bool GLESRenderEngine::finish() {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000497 ATRACE_CALL();
Peiyong Lin60bedb52018-09-05 10:47:31 -0700498 if (!GLExtensions::getInstance().hasFenceSync()) {
499 ALOGW("no synchronization support");
500 return false;
501 }
502
503 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr);
504 if (sync == EGL_NO_SYNC_KHR) {
505 ALOGW("failed to create EGL fence sync: %#x", eglGetError());
506 return false;
507 }
508
Alec Mouri554d06e2018-12-20 00:15:33 -0800509 if (CC_UNLIKELY(mTraceGpuCompletion && mFlushTracer)) {
510 mFlushTracer->queueSync(eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr));
511 }
512
513 return waitSync(sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR);
514}
515
516bool GLESRenderEngine::waitSync(EGLSyncKHR sync, EGLint flags) {
517 EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync, flags, 2000000000 /*2 sec*/);
Peiyong Lin60bedb52018-09-05 10:47:31 -0700518 EGLint error = eglGetError();
519 eglDestroySyncKHR(mEGLDisplay, sync);
520 if (result != EGL_CONDITION_SATISFIED_KHR) {
521 if (result == EGL_TIMEOUT_EXPIRED_KHR) {
522 ALOGW("fence wait timed out");
523 } else {
524 ALOGW("error waiting on EGL fence: %#x", error);
525 }
526 return false;
527 }
528
529 return true;
530}
531
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800532bool GLESRenderEngine::waitFence(base::unique_fd fenceFd) {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700533 if (!GLExtensions::getInstance().hasNativeFenceSync() ||
534 !GLExtensions::getInstance().hasWaitSync()) {
535 return false;
536 }
537
Peiyong Lin35a114c2019-04-25 14:37:13 -0700538 // release the fd and transfer the ownership to EGLSync
539 EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceFd.release(), EGL_NONE};
Peiyong Lin60bedb52018-09-05 10:47:31 -0700540 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
541 if (sync == EGL_NO_SYNC_KHR) {
542 ALOGE("failed to create EGL native fence sync: %#x", eglGetError());
543 return false;
544 }
545
Peiyong Lin60bedb52018-09-05 10:47:31 -0700546 // XXX: The spec draft is inconsistent as to whether this should return an
547 // EGLint or void. Ignore the return value for now, as it's not strictly
548 // needed.
549 eglWaitSyncKHR(mEGLDisplay, sync, 0);
550 EGLint error = eglGetError();
551 eglDestroySyncKHR(mEGLDisplay, sync);
552 if (error != EGL_SUCCESS) {
553 ALOGE("failed to wait for EGL native fence sync: %#x", error);
554 return false;
555 }
556
557 return true;
558}
559
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800560void GLESRenderEngine::clearWithColor(float red, float green, float blue, float alpha) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000561 ATRACE_CALL();
562 glDisable(GL_BLEND);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700563 glClearColor(red, green, blue, alpha);
564 glClear(GL_COLOR_BUFFER_BIT);
565}
566
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800567void GLESRenderEngine::fillRegionWithColor(const Region& region, float red, float green, float blue,
568 float alpha) {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700569 size_t c;
570 Rect const* r = region.getArray(&c);
571 Mesh mesh(Mesh::TRIANGLES, c * 6, 2);
572 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
573 for (size_t i = 0; i < c; i++, r++) {
574 position[i * 6 + 0].x = r->left;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700575 position[i * 6 + 0].y = r->top;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700576 position[i * 6 + 1].x = r->left;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700577 position[i * 6 + 1].y = r->bottom;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700578 position[i * 6 + 2].x = r->right;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700579 position[i * 6 + 2].y = r->bottom;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700580 position[i * 6 + 3].x = r->left;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700581 position[i * 6 + 3].y = r->top;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700582 position[i * 6 + 4].x = r->right;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700583 position[i * 6 + 4].y = r->bottom;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700584 position[i * 6 + 5].x = r->right;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700585 position[i * 6 + 5].y = r->top;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700586 }
587 setupFillWithColor(red, green, blue, alpha);
588 drawMesh(mesh);
589}
590
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800591void GLESRenderEngine::setScissor(const Rect& region) {
Peiyong Lin1c097612019-03-22 16:21:46 -0700592 glScissor(region.left, region.top, region.getWidth(), region.getHeight());
Peiyong Lin60bedb52018-09-05 10:47:31 -0700593 glEnable(GL_SCISSOR_TEST);
594}
595
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800596void GLESRenderEngine::disableScissor() {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700597 glDisable(GL_SCISSOR_TEST);
598}
599
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800600void GLESRenderEngine::genTextures(size_t count, uint32_t* names) {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700601 glGenTextures(count, names);
602}
603
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800604void GLESRenderEngine::deleteTextures(size_t count, uint32_t const* names) {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700605 glDeleteTextures(count, names);
606}
607
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800608void GLESRenderEngine::bindExternalTextureImage(uint32_t texName, const Image& image) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000609 ATRACE_CALL();
Peiyong Linf1bada92018-08-29 09:39:31 -0700610 const GLImage& glImage = static_cast<const GLImage&>(image);
611 const GLenum target = GL_TEXTURE_EXTERNAL_OES;
612
613 glBindTexture(target, texName);
614 if (glImage.getEGLImage() != EGL_NO_IMAGE_KHR) {
Peiyong Lin46080ef2018-10-26 18:43:14 -0700615 glEGLImageTargetTexture2DOES(target, static_cast<GLeglImageOES>(glImage.getEGLImage()));
Peiyong Linf1bada92018-08-29 09:39:31 -0700616 }
Mathias Agopian3f844832013-08-07 21:24:32 -0700617}
618
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700619status_t GLESRenderEngine::bindExternalTextureBuffer(uint32_t texName,
620 const sp<GraphicBuffer>& buffer,
621 const sp<Fence>& bufferFence) {
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700622 ATRACE_CALL();
Alec Mouri3d7c5612019-07-09 13:51:37 -0700623 status_t cacheResult = cacheExternalTextureBuffer(buffer);
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700624
625 if (cacheResult != NO_ERROR) {
626 return cacheResult;
627 }
628
Alec Mouri3d7c5612019-07-09 13:51:37 -0700629 {
630 std::lock_guard<std::mutex> lock(mRenderingMutex);
631 auto cachedImage = mImageCache.find(buffer->getId());
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700632
Alec Mouri3d7c5612019-07-09 13:51:37 -0700633 if (cachedImage == mImageCache.end()) {
634 // We failed creating the image if we got here, so bail out.
635 bindExternalTextureImage(texName, *createImage());
636 return NO_INIT;
637 }
638
639 bindExternalTextureImage(texName, *cachedImage->second);
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800640 }
641
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800642 // Wait for the new buffer to be ready.
643 if (bufferFence != nullptr && bufferFence->isValid()) {
644 if (GLExtensions::getInstance().hasWaitSync()) {
645 base::unique_fd fenceFd(bufferFence->dup());
646 if (fenceFd == -1) {
647 ALOGE("error dup'ing fence fd: %d", errno);
648 return -errno;
649 }
650 if (!waitFence(std::move(fenceFd))) {
651 ALOGE("failed to wait on fence fd");
652 return UNKNOWN_ERROR;
653 }
654 } else {
655 status_t err = bufferFence->waitForever("RenderEngine::bindExternalTextureBuffer");
656 if (err != NO_ERROR) {
657 ALOGE("error waiting for fence: %d", err);
658 return err;
659 }
660 }
661 }
Alec Mouri539319f2018-12-19 17:56:23 -0800662
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800663 return NO_ERROR;
664}
665
Alec Mouri3d7c5612019-07-09 13:51:37 -0700666status_t GLESRenderEngine::cacheExternalTextureBuffer(const sp<GraphicBuffer>& buffer) {
667 if (buffer == nullptr) {
668 return BAD_VALUE;
669 }
670
671 {
672 std::lock_guard<std::mutex> lock(mRenderingMutex);
673 if (mImageCache.count(buffer->getId()) > 0) {
674 // If there's already an image then fail fast here.
675 return NO_ERROR;
676 }
677 }
678 ATRACE_CALL();
679
680 // Create the image without holding a lock so that we don't block anything.
681 std::unique_ptr<Image> newImage = createImage();
682
683 bool created = newImage->setNativeWindowBuffer(buffer->getNativeBuffer(),
684 buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
685 if (!created) {
686 ALOGE("Failed to create image. size=%ux%u st=%u usage=%#" PRIx64 " fmt=%d",
687 buffer->getWidth(), buffer->getHeight(), buffer->getStride(), buffer->getUsage(),
688 buffer->getPixelFormat());
689 return NO_INIT;
690 }
691
692 {
693 std::lock_guard<std::mutex> lock(mRenderingMutex);
694 if (mImageCache.count(buffer->getId()) > 0) {
695 // In theory it's possible for another thread to recache the image,
696 // so bail out if another thread won.
697 return NO_ERROR;
698 }
699 mImageCache.insert(std::make_pair(buffer->getId(), std::move(newImage)));
700 }
701
702 return NO_ERROR;
703}
704
Alec Mourib5c4f352019-02-19 19:46:38 -0800705void GLESRenderEngine::unbindExternalTextureBuffer(uint64_t bufferId) {
Alec Mourif0497272019-03-11 15:53:11 -0700706 std::lock_guard<std::mutex> lock(mRenderingMutex);
Alec Mourib5c4f352019-02-19 19:46:38 -0800707 const auto& cachedImage = mImageCache.find(bufferId);
708 if (cachedImage != mImageCache.end()) {
709 ALOGV("Destroying image for buffer: %" PRIu64, bufferId);
710 mImageCache.erase(bufferId);
711 return;
Alec Mouri539319f2018-12-19 17:56:23 -0800712 }
Alec Mourib5c4f352019-02-19 19:46:38 -0800713 ALOGV("Failed to find image for buffer: %" PRIu64, bufferId);
Alec Mouri539319f2018-12-19 17:56:23 -0800714}
715
Alec Mouri7c94edb2018-12-03 21:23:26 -0800716FloatRect GLESRenderEngine::setupLayerCropping(const LayerSettings& layer, Mesh& mesh) {
717 // Translate win by the rounded corners rect coordinates, to have all values in
718 // layer coordinate space.
719 FloatRect cropWin = layer.geometry.boundaries;
720 const FloatRect& roundedCornersCrop = layer.geometry.roundedCornersCrop;
721 cropWin.left -= roundedCornersCrop.left;
722 cropWin.right -= roundedCornersCrop.left;
723 cropWin.top -= roundedCornersCrop.top;
724 cropWin.bottom -= roundedCornersCrop.top;
725 Mesh::VertexArray<vec2> cropCoords(mesh.getCropCoordArray<vec2>());
726 cropCoords[0] = vec2(cropWin.left, cropWin.top);
727 cropCoords[1] = vec2(cropWin.left, cropWin.top + cropWin.getHeight());
728 cropCoords[2] = vec2(cropWin.right, cropWin.top + cropWin.getHeight());
729 cropCoords[3] = vec2(cropWin.right, cropWin.top);
730
731 setupCornerRadiusCropSize(roundedCornersCrop.getWidth(), roundedCornersCrop.getHeight());
732 return cropWin;
733}
734
Peiyong Lin1c097612019-03-22 16:21:46 -0700735void GLESRenderEngine::handleRoundedCorners(const DisplaySettings& display,
736 const LayerSettings& layer, const Mesh& mesh) {
737 // We separate the layer into 3 parts essentially, such that we only turn on blending for the
738 // top rectangle and the bottom rectangle, and turn off blending for the middle rectangle.
739 FloatRect bounds = layer.geometry.roundedCornersCrop;
Peiyong Linb1925962019-04-01 16:37:10 -0700740
741 // Firstly, we need to convert the coordination from layer native coordination space to
742 // device coordination space.
Peiyong Lin1c097612019-03-22 16:21:46 -0700743 const auto transformMatrix = display.globalTransform * layer.geometry.positionTransform;
744 const vec4 leftTopCoordinate(bounds.left, bounds.top, 1.0, 1.0);
745 const vec4 rightBottomCoordinate(bounds.right, bounds.bottom, 1.0, 1.0);
746 const vec4 leftTopCoordinateInBuffer = transformMatrix * leftTopCoordinate;
747 const vec4 rightBottomCoordinateInBuffer = transformMatrix * rightBottomCoordinate;
748 bounds = FloatRect(leftTopCoordinateInBuffer[0], leftTopCoordinateInBuffer[1],
749 rightBottomCoordinateInBuffer[0], rightBottomCoordinateInBuffer[1]);
Peiyong Lin1c097612019-03-22 16:21:46 -0700750
Peiyong Linb1925962019-04-01 16:37:10 -0700751 // Secondly, if the display is rotated, we need to undo the rotation on coordination and
752 // align the (left, top) and (right, bottom) coordination with the device coordination
753 // space.
754 switch (display.orientation) {
755 case ui::Transform::ROT_90:
756 std::swap(bounds.left, bounds.right);
757 break;
758 case ui::Transform::ROT_180:
759 std::swap(bounds.left, bounds.right);
760 std::swap(bounds.top, bounds.bottom);
761 break;
762 case ui::Transform::ROT_270:
763 std::swap(bounds.top, bounds.bottom);
764 break;
765 default:
766 break;
767 }
768
769 // Finally, we cut the layer into 3 parts, with top and bottom parts having rounded corners
770 // and the middle part without rounded corners.
771 const int32_t radius = ceil(layer.geometry.roundedCornersRadius);
Peiyong Lin1c097612019-03-22 16:21:46 -0700772 const Rect topRect(bounds.left, bounds.top, bounds.right, bounds.top + radius);
773 setScissor(topRect);
774 drawMesh(mesh);
775 const Rect bottomRect(bounds.left, bounds.bottom - radius, bounds.right, bounds.bottom);
776 setScissor(bottomRect);
777 drawMesh(mesh);
778
779 // The middle part of the layer can turn off blending.
780 const Rect middleRect(bounds.left, bounds.top + radius, bounds.right, bounds.bottom - radius);
781 setScissor(middleRect);
782 mState.cornerRadius = 0.0;
783 disableBlending();
784 drawMesh(mesh);
785 disableScissor();
786}
787
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800788status_t GLESRenderEngine::bindFrameBuffer(Framebuffer* framebuffer) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000789 ATRACE_CALL();
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700790 GLFramebuffer* glFramebuffer = static_cast<GLFramebuffer*>(framebuffer);
791 EGLImageKHR eglImage = glFramebuffer->getEGLImage();
792 uint32_t textureName = glFramebuffer->getTextureName();
793 uint32_t framebufferName = glFramebuffer->getFramebufferName();
794
795 // Bind the texture and turn our EGLImage into a texture
796 glBindTexture(GL_TEXTURE_2D, textureName);
797 glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)eglImage);
798
799 // Bind the Framebuffer to render into
800 glBindFramebuffer(GL_FRAMEBUFFER, framebufferName);
Peiyong Lin46080ef2018-10-26 18:43:14 -0700801 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureName, 0);
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700802
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700803 uint32_t glStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
804
Peiyong Lin46080ef2018-10-26 18:43:14 -0700805 ALOGE_IF(glStatus != GL_FRAMEBUFFER_COMPLETE_OES, "glCheckFramebufferStatusOES error %d",
806 glStatus);
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700807
808 return glStatus == GL_FRAMEBUFFER_COMPLETE_OES ? NO_ERROR : BAD_VALUE;
809}
810
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800811void GLESRenderEngine::unbindFrameBuffer(Framebuffer* /* framebuffer */) {
Alec Mouri820c7402019-01-23 13:02:39 -0800812 ATRACE_CALL();
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700813
814 // back to main framebuffer
815 glBindFramebuffer(GL_FRAMEBUFFER, 0);
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700816}
817
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800818void GLESRenderEngine::checkErrors() const {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700819 do {
820 // there could be more than one error flag
821 GLenum error = glGetError();
822 if (error == GL_NO_ERROR) break;
823 ALOGE("GL error 0x%04x", int(error));
824 } while (true);
825}
826
Peiyong Linfb530cf2018-12-15 05:07:38 +0000827bool GLESRenderEngine::supportsProtectedContent() const {
828 return mProtectedEGLContext != EGL_NO_CONTEXT;
829}
830
831bool GLESRenderEngine::useProtectedContext(bool useProtectedContext) {
832 if (useProtectedContext == mInProtectedContext) {
833 return true;
834 }
835 if (useProtectedContext && mProtectedEGLContext == EGL_NO_CONTEXT) {
836 return false;
837 }
838 const EGLSurface surface = useProtectedContext ? mProtectedDummySurface : mDummySurface;
839 const EGLContext context = useProtectedContext ? mProtectedEGLContext : mEGLContext;
840 const bool success = eglMakeCurrent(mEGLDisplay, surface, surface, context) == EGL_TRUE;
841 if (success) {
842 mInProtectedContext = useProtectedContext;
843 }
844 return success;
845}
Alec Mourida4cf3b2019-02-12 15:33:01 -0800846EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer* nativeBuffer,
Alec Mourife0d72b2019-03-21 14:05:56 -0700847 bool isProtected,
848 bool useFramebufferCache) {
Alec Mourida4cf3b2019-02-12 15:33:01 -0800849 sp<GraphicBuffer> graphicBuffer = GraphicBuffer::from(nativeBuffer);
Alec Mourife0d72b2019-03-21 14:05:56 -0700850 if (useFramebufferCache) {
Alec Mouri192a3752019-07-15 15:27:22 -0700851 std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
Alec Mourife0d72b2019-03-21 14:05:56 -0700852 for (const auto& image : mFramebufferImageCache) {
853 if (image.first == graphicBuffer->getId()) {
854 return image.second;
855 }
Alec Mourida4cf3b2019-02-12 15:33:01 -0800856 }
857 }
858 EGLint attributes[] = {
859 isProtected ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
860 isProtected ? EGL_TRUE : EGL_NONE,
861 EGL_NONE,
862 };
863 EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
864 nativeBuffer, attributes);
Alec Mourife0d72b2019-03-21 14:05:56 -0700865 if (useFramebufferCache) {
866 if (image != EGL_NO_IMAGE_KHR) {
Alec Mouri192a3752019-07-15 15:27:22 -0700867 std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
Alec Mourife0d72b2019-03-21 14:05:56 -0700868 if (mFramebufferImageCache.size() >= mFramebufferImageCacheSize) {
869 EGLImageKHR expired = mFramebufferImageCache.front().second;
870 mFramebufferImageCache.pop_front();
871 eglDestroyImageKHR(mEGLDisplay, expired);
Ady Abrahama3b08ef2019-07-15 18:43:10 -0700872 DEBUG_EGL_IMAGE_TRACKER_DESTROY();
Alec Mourife0d72b2019-03-21 14:05:56 -0700873 }
874 mFramebufferImageCache.push_back({graphicBuffer->getId(), image});
Alec Mourida4cf3b2019-02-12 15:33:01 -0800875 }
Alec Mourida4cf3b2019-02-12 15:33:01 -0800876 }
Ady Abrahama3b08ef2019-07-15 18:43:10 -0700877
878 if (image != EGL_NO_IMAGE_KHR) {
879 DEBUG_EGL_IMAGE_TRACKER_CREATE();
880 }
Alec Mourida4cf3b2019-02-12 15:33:01 -0800881 return image;
882}
Peiyong Linfb530cf2018-12-15 05:07:38 +0000883
Alec Mouri1089aed2018-10-25 21:33:57 -0700884status_t GLESRenderEngine::drawLayers(const DisplaySettings& display,
885 const std::vector<LayerSettings>& layers,
886 ANativeWindowBuffer* const buffer,
Alec Mourife0d72b2019-03-21 14:05:56 -0700887 const bool useFramebufferCache, base::unique_fd&& bufferFence,
888 base::unique_fd* drawFence) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000889 ATRACE_CALL();
Alec Mouri1089aed2018-10-25 21:33:57 -0700890 if (layers.empty()) {
891 ALOGV("Drawing empty layer stack");
892 return NO_ERROR;
893 }
894
Alec Mouri6338c9d2019-02-07 16:57:51 -0800895 if (bufferFence.get() >= 0 && !waitFence(std::move(bufferFence))) {
896 ATRACE_NAME("Waiting before draw");
897 sync_wait(bufferFence.get(), -1);
898 }
899
Alec Mourid43ccab2019-03-13 12:23:45 -0700900 if (buffer == nullptr) {
901 ALOGE("No output buffer provided. Aborting GPU composition.");
902 return BAD_VALUE;
903 }
904
Alec Mouri3d7c5612019-07-09 13:51:37 -0700905 BindNativeBufferAsFramebuffer fbo(*this, buffer, useFramebufferCache);
Alec Mouri1089aed2018-10-25 21:33:57 -0700906
Alec Mouri3d7c5612019-07-09 13:51:37 -0700907 if (fbo.getStatus() != NO_ERROR) {
908 ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",
909 buffer->handle);
Alec Mourif0497272019-03-11 15:53:11 -0700910 checkErrors();
Alec Mouri3d7c5612019-07-09 13:51:37 -0700911 return fbo.getStatus();
Alec Mourif0497272019-03-11 15:53:11 -0700912 }
Alec Mouri3d7c5612019-07-09 13:51:37 -0700913
914 // clear the entire buffer, sometimes when we reuse buffers we'd persist
915 // ghost images otherwise.
916 // we also require a full transparent framebuffer for overlays. This is
917 // probably not quite efficient on all GPUs, since we could filter out
918 // opaque layers.
919 clearWithColor(0.0, 0.0, 0.0, 0.0);
920
921 setViewportAndProjection(display.physicalDisplay, display.clip);
922
923 setOutputDataSpace(display.outputDataspace);
924 setDisplayMaxLuminance(display.maxLuminance);
925
926 mat4 projectionMatrix = mState.projectionMatrix * display.globalTransform;
927 mState.projectionMatrix = projectionMatrix;
928 if (!display.clearRegion.isEmpty()) {
929 glDisable(GL_BLEND);
930 fillRegionWithColor(display.clearRegion, 0.0, 0.0, 0.0, 1.0);
931 }
932
933 Mesh mesh(Mesh::TRIANGLE_FAN, 4, 2, 2);
934 for (auto layer : layers) {
935 mState.projectionMatrix = projectionMatrix * layer.geometry.positionTransform;
936
937 const FloatRect bounds = layer.geometry.boundaries;
938 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
939 position[0] = vec2(bounds.left, bounds.top);
940 position[1] = vec2(bounds.left, bounds.bottom);
941 position[2] = vec2(bounds.right, bounds.bottom);
942 position[3] = vec2(bounds.right, bounds.top);
943
944 setupLayerCropping(layer, mesh);
945 setColorTransform(display.colorTransform * layer.colorTransform);
946
947 bool usePremultipliedAlpha = true;
948 bool disableTexture = true;
949 bool isOpaque = false;
950
951 if (layer.source.buffer.buffer != nullptr) {
952 disableTexture = false;
953 isOpaque = layer.source.buffer.isOpaque;
954
955 sp<GraphicBuffer> gBuf = layer.source.buffer.buffer;
956 bindExternalTextureBuffer(layer.source.buffer.textureName, gBuf,
957 layer.source.buffer.fence);
958
959 usePremultipliedAlpha = layer.source.buffer.usePremultipliedAlpha;
960 Texture texture(Texture::TEXTURE_EXTERNAL, layer.source.buffer.textureName);
961 mat4 texMatrix = layer.source.buffer.textureTransform;
962
963 texture.setMatrix(texMatrix.asArray());
964 texture.setFiltering(layer.source.buffer.useTextureFiltering);
965
966 texture.setDimensions(gBuf->getWidth(), gBuf->getHeight());
967 setSourceY410BT2020(layer.source.buffer.isY410BT2020);
968
969 renderengine::Mesh::VertexArray<vec2> texCoords(mesh.getTexCoordArray<vec2>());
970 texCoords[0] = vec2(0.0, 0.0);
971 texCoords[1] = vec2(0.0, 1.0);
972 texCoords[2] = vec2(1.0, 1.0);
973 texCoords[3] = vec2(1.0, 0.0);
974 setupLayerTexturing(texture);
975 }
976
977 const half3 solidColor = layer.source.solidColor;
978 const half4 color = half4(solidColor.r, solidColor.g, solidColor.b, layer.alpha);
979 // Buffer sources will have a black solid color ignored in the shader,
980 // so in that scenario the solid color passed here is arbitrary.
981 setupLayerBlending(usePremultipliedAlpha, isOpaque, disableTexture, color,
982 layer.geometry.roundedCornersRadius);
983 if (layer.disableBlending) {
984 glDisable(GL_BLEND);
985 }
986 setSourceDataSpace(layer.sourceDataspace);
987
988 // We only want to do a special handling for rounded corners when having rounded corners
989 // is the only reason it needs to turn on blending, otherwise, we handle it like the
990 // usual way since it needs to turn on blending anyway.
991 if (layer.geometry.roundedCornersRadius > 0.0 && color.a >= 1.0f && isOpaque) {
992 handleRoundedCorners(display, layer, mesh);
993 } else {
994 drawMesh(mesh);
995 }
996
997 // Cleanup if there's a buffer source
998 if (layer.source.buffer.buffer != nullptr) {
999 disableBlending();
1000 setSourceY410BT2020(false);
1001 disableTexturing();
1002 }
1003 }
1004
1005 if (drawFence != nullptr) {
1006 *drawFence = flush();
1007 }
1008 // If flush failed or we don't support native fences, we need to force the
1009 // gl command stream to be executed.
1010 if (drawFence == nullptr || drawFence->get() < 0) {
1011 bool success = finish();
1012 if (!success) {
1013 ALOGE("Failed to flush RenderEngine commands");
1014 checkErrors();
1015 // Chances are, something illegal happened (either the caller passed
1016 // us bad parameters, or we messed up our shader generation).
1017 return INVALID_OPERATION;
1018 }
1019 }
1020
1021 checkErrors();
Alec Mouri6e57f682018-09-29 20:45:08 -07001022 return NO_ERROR;
1023}
1024
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001025void GLESRenderEngine::setViewportAndProjection(size_t vpw, size_t vph, Rect sourceCrop,
1026 ui::Transform::orientation_flags rotation) {
Alec Mouri1089aed2018-10-25 21:33:57 -07001027 setViewportAndProjection(Rect(vpw, vph), sourceCrop);
1028
1029 if (rotation == ui::Transform::ROT_0) {
1030 return;
1031 }
Mathias Agopian3f844832013-08-07 21:24:32 -07001032
Riley Andrewsc3ebe662014-09-04 16:20:31 -07001033 // Apply custom rotation to the projection.
1034 float rot90InRadians = 2.0f * static_cast<float>(M_PI) / 4.0f;
Alec Mouri1089aed2018-10-25 21:33:57 -07001035 mat4 m = mState.projectionMatrix;
Riley Andrewsc3ebe662014-09-04 16:20:31 -07001036 switch (rotation) {
Peiyong Linefefaac2018-08-17 12:27:51 -07001037 case ui::Transform::ROT_90:
Chia-I Wub027f802017-11-29 14:00:52 -08001038 m = mat4::rotate(rot90InRadians, vec3(0, 0, 1)) * m;
Riley Andrewsc3ebe662014-09-04 16:20:31 -07001039 break;
Peiyong Linefefaac2018-08-17 12:27:51 -07001040 case ui::Transform::ROT_180:
Chia-I Wub027f802017-11-29 14:00:52 -08001041 m = mat4::rotate(rot90InRadians * 2.0f, vec3(0, 0, 1)) * m;
Riley Andrewsc3ebe662014-09-04 16:20:31 -07001042 break;
Peiyong Linefefaac2018-08-17 12:27:51 -07001043 case ui::Transform::ROT_270:
Chia-I Wub027f802017-11-29 14:00:52 -08001044 m = mat4::rotate(rot90InRadians * 3.0f, vec3(0, 0, 1)) * m;
Riley Andrewsc3ebe662014-09-04 16:20:31 -07001045 break;
1046 default:
1047 break;
1048 }
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001049 mState.projectionMatrix = m;
Alec Mouri1089aed2018-10-25 21:33:57 -07001050}
1051
1052void GLESRenderEngine::setViewportAndProjection(Rect viewport, Rect clip) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001053 ATRACE_CALL();
Alec Mouri1089aed2018-10-25 21:33:57 -07001054 mVpWidth = viewport.getWidth();
1055 mVpHeight = viewport.getHeight();
1056
1057 // We pass the the top left corner instead of the bottom left corner,
1058 // because since we're rendering off-screen first.
1059 glViewport(viewport.left, viewport.top, mVpWidth, mVpHeight);
1060
1061 mState.projectionMatrix = mat4::ortho(clip.left, clip.right, clip.top, clip.bottom, 0, 1);
Mathias Agopian3f844832013-08-07 21:24:32 -07001062}
1063
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001064void GLESRenderEngine::setupLayerBlending(bool premultipliedAlpha, bool opaque, bool disableTexture,
1065 const half4& color, float cornerRadius) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001066 mState.isPremultipliedAlpha = premultipliedAlpha;
1067 mState.isOpaque = opaque;
1068 mState.color = color;
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001069 mState.cornerRadius = cornerRadius;
Dan Stoza9e56aa02015-11-02 13:00:03 -08001070
chaviw13fdc492017-06-27 12:40:18 -07001071 if (disableTexture) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001072 mState.textureEnabled = false;
chaviw13fdc492017-06-27 12:40:18 -07001073 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001074
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001075 if (color.a < 1.0f || !opaque || cornerRadius > 0.0f) {
Mathias Agopian3f844832013-08-07 21:24:32 -07001076 glEnable(GL_BLEND);
1077 glBlendFunc(premultipliedAlpha ? GL_ONE : GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1078 } else {
1079 glDisable(GL_BLEND);
1080 }
1081}
1082
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001083void GLESRenderEngine::setSourceY410BT2020(bool enable) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001084 mState.isY410BT2020 = enable;
Chia-I Wu131d3762018-01-11 14:35:27 -08001085}
1086
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001087void GLESRenderEngine::setSourceDataSpace(Dataspace source) {
Chia-I Wu69bf10f2018-02-20 13:04:50 -08001088 mDataSpace = source;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001089}
1090
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001091void GLESRenderEngine::setOutputDataSpace(Dataspace dataspace) {
Chia-I Wu69bf10f2018-02-20 13:04:50 -08001092 mOutputDataSpace = dataspace;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001093}
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001094
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001095void GLESRenderEngine::setDisplayMaxLuminance(const float maxLuminance) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001096 mState.displayMaxLuminance = maxLuminance;
Peiyong Linfb069302018-04-25 14:34:31 -07001097}
1098
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001099void GLESRenderEngine::setupLayerTexturing(const Texture& texture) {
Mathias Agopian49457ac2013-08-14 18:20:17 -07001100 GLuint target = texture.getTextureTarget();
1101 glBindTexture(target, texture.getTextureName());
Mathias Agopian3f844832013-08-07 21:24:32 -07001102 GLenum filter = GL_NEAREST;
Mathias Agopian49457ac2013-08-14 18:20:17 -07001103 if (texture.getFiltering()) {
Mathias Agopian3f844832013-08-07 21:24:32 -07001104 filter = GL_LINEAR;
1105 }
Mathias Agopian49457ac2013-08-14 18:20:17 -07001106 glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1107 glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1108 glTexParameteri(target, GL_TEXTURE_MAG_FILTER, filter);
1109 glTexParameteri(target, GL_TEXTURE_MIN_FILTER, filter);
Mathias Agopian3f844832013-08-07 21:24:32 -07001110
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001111 mState.texture = texture;
1112 mState.textureEnabled = true;
Mathias Agopian3f844832013-08-07 21:24:32 -07001113}
1114
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001115void GLESRenderEngine::setupLayerBlackedOut() {
Mathias Agopian3f844832013-08-07 21:24:32 -07001116 glBindTexture(GL_TEXTURE_2D, mProtectedTexName);
Mathias Agopian49457ac2013-08-14 18:20:17 -07001117 Texture texture(Texture::TEXTURE_2D, mProtectedTexName);
1118 texture.setDimensions(1, 1); // FIXME: we should get that from somewhere
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001119 mState.texture = texture;
1120 mState.textureEnabled = true;
Mathias Agopian3f844832013-08-07 21:24:32 -07001121}
1122
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001123void GLESRenderEngine::setColorTransform(const mat4& colorTransform) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001124 mState.colorMatrix = colorTransform;
Dan Stozaf0087992014-10-20 15:46:09 -07001125}
1126
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001127void GLESRenderEngine::disableTexturing() {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001128 mState.textureEnabled = false;
Mathias Agopian3f844832013-08-07 21:24:32 -07001129}
1130
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001131void GLESRenderEngine::disableBlending() {
Mathias Agopian3f844832013-08-07 21:24:32 -07001132 glDisable(GL_BLEND);
1133}
1134
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001135void GLESRenderEngine::setupFillWithColor(float r, float g, float b, float a) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001136 mState.isPremultipliedAlpha = true;
1137 mState.isOpaque = false;
1138 mState.color = half4(r, g, b, a);
1139 mState.textureEnabled = false;
Mathias Agopian3f844832013-08-07 21:24:32 -07001140 glDisable(GL_BLEND);
Mathias Agopian3f844832013-08-07 21:24:32 -07001141}
1142
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001143void GLESRenderEngine::setupCornerRadiusCropSize(float width, float height) {
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001144 mState.cropSize = half2(width, height);
1145}
1146
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001147void GLESRenderEngine::drawMesh(const Mesh& mesh) {
Dan Stoza2713c302018-03-28 17:07:36 -07001148 ATRACE_CALL();
Mathias Agopian3f844832013-08-07 21:24:32 -07001149 if (mesh.getTexCoordsSize()) {
1150 glEnableVertexAttribArray(Program::texCoords);
Chia-I Wub027f802017-11-29 14:00:52 -08001151 glVertexAttribPointer(Program::texCoords, mesh.getTexCoordsSize(), GL_FLOAT, GL_FALSE,
1152 mesh.getByteStride(), mesh.getTexCoords());
Mathias Agopian3f844832013-08-07 21:24:32 -07001153 }
1154
Chia-I Wub027f802017-11-29 14:00:52 -08001155 glVertexAttribPointer(Program::position, mesh.getVertexSize(), GL_FLOAT, GL_FALSE,
1156 mesh.getByteStride(), mesh.getPositions());
Mathias Agopian3f844832013-08-07 21:24:32 -07001157
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001158 if (mState.cornerRadius > 0.0f) {
1159 glEnableVertexAttribArray(Program::cropCoords);
1160 glVertexAttribPointer(Program::cropCoords, mesh.getVertexSize(), GL_FLOAT, GL_FALSE,
1161 mesh.getByteStride(), mesh.getCropCoords());
1162 }
1163
Peiyong Lina296b0c2018-04-30 16:55:29 -07001164 // By default, DISPLAY_P3 is the only supported wide color output. However,
1165 // when HDR content is present, hardware composer may be able to handle
1166 // BT2020 data space, in that case, the output data space is set to be
1167 // BT2020_HLG or BT2020_PQ respectively. In GPU fall back we need
1168 // to respect this and convert non-HDR content to HDR format.
Peiyong Lin13effd12018-07-24 17:01:47 -07001169 if (mUseColorManagement) {
1170 Description managedState = mState;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001171 Dataspace inputStandard = static_cast<Dataspace>(mDataSpace & Dataspace::STANDARD_MASK);
1172 Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK);
Peiyong Lin46080ef2018-10-26 18:43:14 -07001173 Dataspace outputStandard =
1174 static_cast<Dataspace>(mOutputDataSpace & Dataspace::STANDARD_MASK);
1175 Dataspace outputTransfer =
1176 static_cast<Dataspace>(mOutputDataSpace & Dataspace::TRANSFER_MASK);
Peiyong Lina296b0c2018-04-30 16:55:29 -07001177 bool needsXYZConversion = needsXYZTransformMatrix();
1178
Valerie Haueb8e0762018-11-06 10:10:42 -08001179 // NOTE: if the input standard of the input dataspace is not STANDARD_DCI_P3 or
1180 // STANDARD_BT2020, it will be treated as STANDARD_BT709
1181 if (inputStandard != Dataspace::STANDARD_DCI_P3 &&
1182 inputStandard != Dataspace::STANDARD_BT2020) {
1183 inputStandard = Dataspace::STANDARD_BT709;
1184 }
1185
Peiyong Lina296b0c2018-04-30 16:55:29 -07001186 if (needsXYZConversion) {
1187 // The supported input color spaces are standard RGB, Display P3 and BT2020.
1188 switch (inputStandard) {
1189 case Dataspace::STANDARD_DCI_P3:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001190 managedState.inputTransformMatrix = mDisplayP3ToXyz;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001191 break;
1192 case Dataspace::STANDARD_BT2020:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001193 managedState.inputTransformMatrix = mBt2020ToXyz;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001194 break;
1195 default:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001196 managedState.inputTransformMatrix = mSrgbToXyz;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001197 break;
1198 }
1199
Peiyong Lin9b03c732018-05-17 10:14:02 -07001200 // The supported output color spaces are BT2020, Display P3 and standard RGB.
Peiyong Lina296b0c2018-04-30 16:55:29 -07001201 switch (outputStandard) {
1202 case Dataspace::STANDARD_BT2020:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001203 managedState.outputTransformMatrix = mXyzToBt2020;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001204 break;
Peiyong Lin9b03c732018-05-17 10:14:02 -07001205 case Dataspace::STANDARD_DCI_P3:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001206 managedState.outputTransformMatrix = mXyzToDisplayP3;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001207 break;
Peiyong Lin9b03c732018-05-17 10:14:02 -07001208 default:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001209 managedState.outputTransformMatrix = mXyzToSrgb;
Peiyong Lin9b03c732018-05-17 10:14:02 -07001210 break;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001211 }
1212 } else if (inputStandard != outputStandard) {
1213 // At this point, the input data space and output data space could be both
1214 // HDR data spaces, but they match each other, we do nothing in this case.
1215 // In addition to the case above, the input data space could be
1216 // - scRGB linear
1217 // - scRGB non-linear
1218 // - sRGB
1219 // - Display P3
Valerie Haueb8e0762018-11-06 10:10:42 -08001220 // - BT2020
Peiyong Lina296b0c2018-04-30 16:55:29 -07001221 // The output data spaces could be
1222 // - sRGB
1223 // - Display P3
Valerie Haueb8e0762018-11-06 10:10:42 -08001224 // - BT2020
1225 switch (outputStandard) {
1226 case Dataspace::STANDARD_BT2020:
1227 if (inputStandard == Dataspace::STANDARD_BT709) {
1228 managedState.outputTransformMatrix = mSrgbToBt2020;
1229 } else if (inputStandard == Dataspace::STANDARD_DCI_P3) {
1230 managedState.outputTransformMatrix = mDisplayP3ToBt2020;
1231 }
1232 break;
1233 case Dataspace::STANDARD_DCI_P3:
1234 if (inputStandard == Dataspace::STANDARD_BT709) {
1235 managedState.outputTransformMatrix = mSrgbToDisplayP3;
1236 } else if (inputStandard == Dataspace::STANDARD_BT2020) {
1237 managedState.outputTransformMatrix = mBt2020ToDisplayP3;
1238 }
1239 break;
1240 default:
1241 if (inputStandard == Dataspace::STANDARD_DCI_P3) {
1242 managedState.outputTransformMatrix = mDisplayP3ToSrgb;
1243 } else if (inputStandard == Dataspace::STANDARD_BT2020) {
1244 managedState.outputTransformMatrix = mBt2020ToSrgb;
1245 }
1246 break;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001247 }
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001248 }
Peiyong Lina296b0c2018-04-30 16:55:29 -07001249
1250 // we need to convert the RGB value to linear space and convert it back when:
1251 // - there is a color matrix that is not an identity matrix, or
1252 // - there is an output transform matrix that is not an identity matrix, or
1253 // - the input transfer function doesn't match the output transfer function.
Peiyong Lin13effd12018-07-24 17:01:47 -07001254 if (managedState.hasColorMatrix() || managedState.hasOutputTransformMatrix() ||
Chia-I Wud49d6692018-06-27 07:17:41 +08001255 inputTransfer != outputTransfer) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001256 managedState.inputTransferFunction =
Peiyong Lin46080ef2018-10-26 18:43:14 -07001257 Description::dataSpaceToTransferFunction(inputTransfer);
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001258 managedState.outputTransferFunction =
Peiyong Lin46080ef2018-10-26 18:43:14 -07001259 Description::dataSpaceToTransferFunction(outputTransfer);
Peiyong Lina296b0c2018-04-30 16:55:29 -07001260 }
1261
Peiyong Linfb530cf2018-12-15 05:07:38 +00001262 ProgramCache::getInstance().useProgram(mInProtectedContext ? mProtectedEGLContext
1263 : mEGLContext,
1264 managedState);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001265
1266 glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());
1267
1268 if (outputDebugPPMs) {
Peiyong Lin13effd12018-07-24 17:01:47 -07001269 static uint64_t managedColorFrameCount = 0;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001270 std::ostringstream out;
Peiyong Lin13effd12018-07-24 17:01:47 -07001271 out << "/data/texture_out" << managedColorFrameCount++;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001272 writePPM(out.str().c_str(), mVpWidth, mVpHeight);
1273 }
1274 } else {
Peiyong Linfb530cf2018-12-15 05:07:38 +00001275 ProgramCache::getInstance().useProgram(mInProtectedContext ? mProtectedEGLContext
1276 : mEGLContext,
1277 mState);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001278
1279 glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());
1280 }
Mathias Agopian3f844832013-08-07 21:24:32 -07001281
1282 if (mesh.getTexCoordsSize()) {
1283 glDisableVertexAttribArray(Program::texCoords);
1284 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001285
1286 if (mState.cornerRadius > 0.0f) {
1287 glDisableVertexAttribArray(Program::cropCoords);
1288 }
Mathias Agopian3f844832013-08-07 21:24:32 -07001289}
1290
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001291size_t GLESRenderEngine::getMaxTextureSize() const {
Peiyong Linf1bada92018-08-29 09:39:31 -07001292 return mMaxTextureSize;
1293}
1294
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001295size_t GLESRenderEngine::getMaxViewportDims() const {
Peiyong Linf1bada92018-08-29 09:39:31 -07001296 return mMaxViewportDims[0] < mMaxViewportDims[1] ? mMaxViewportDims[0] : mMaxViewportDims[1];
1297}
1298
Yiwei Zhang5434a782018-12-05 18:06:32 -08001299void GLESRenderEngine::dump(std::string& result) {
Peiyong Linf11f39b2018-09-05 14:37:41 -07001300 const GLExtensions& extensions = GLExtensions::getInstance();
Peiyong Linfb530cf2018-12-15 05:07:38 +00001301 ProgramCache& cache = ProgramCache::getInstance();
Peiyong Linf11f39b2018-09-05 14:37:41 -07001302
Yiwei Zhang5434a782018-12-05 18:06:32 -08001303 StringAppendF(&result, "EGL implementation : %s\n", extensions.getEGLVersion());
1304 StringAppendF(&result, "%s\n", extensions.getEGLExtensions());
Yiwei Zhang5434a782018-12-05 18:06:32 -08001305 StringAppendF(&result, "GLES: %s, %s, %s\n", extensions.getVendor(), extensions.getRenderer(),
1306 extensions.getVersion());
1307 StringAppendF(&result, "%s\n", extensions.getExtensions());
Peiyong Line62c5cb2019-04-30 13:59:59 -07001308 StringAppendF(&result, "RenderEngine supports protected context: %d\n",
1309 supportsProtectedContent());
1310 StringAppendF(&result, "RenderEngine is in protected context: %d\n", mInProtectedContext);
Peiyong Linfb530cf2018-12-15 05:07:38 +00001311 StringAppendF(&result, "RenderEngine program cache size for unprotected context: %zu\n",
1312 cache.getSize(mEGLContext));
1313 StringAppendF(&result, "RenderEngine program cache size for protected context: %zu\n",
1314 cache.getSize(mProtectedEGLContext));
Yiwei Zhang5434a782018-12-05 18:06:32 -08001315 StringAppendF(&result, "RenderEngine last dataspace conversion: (%s) to (%s)\n",
1316 dataspaceDetails(static_cast<android_dataspace>(mDataSpace)).c_str(),
1317 dataspaceDetails(static_cast<android_dataspace>(mOutputDataSpace)).c_str());
Alec Mouri192a3752019-07-15 15:27:22 -07001318 {
1319 std::lock_guard<std::mutex> lock(mRenderingMutex);
1320 StringAppendF(&result, "RenderEngine image cache size: %zu\n", mImageCache.size());
1321 StringAppendF(&result, "Dumping buffer ids...\n");
1322 for (const auto& [id, unused] : mImageCache) {
1323 StringAppendF(&result, "0x%" PRIx64 "\n", id);
1324 }
1325 }
1326 {
1327 std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
1328 StringAppendF(&result, "RenderEngine framebuffer image cache size: %zu\n",
1329 mFramebufferImageCache.size());
1330 StringAppendF(&result, "Dumping buffer ids...\n");
1331 for (const auto& [id, unused] : mFramebufferImageCache) {
1332 StringAppendF(&result, "0x%" PRIx64 "\n", id);
1333 }
1334 }
Mathias Agopian3f844832013-08-07 21:24:32 -07001335}
1336
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001337GLESRenderEngine::GlesVersion GLESRenderEngine::parseGlesVersion(const char* str) {
Peiyong Linf11f39b2018-09-05 14:37:41 -07001338 int major, minor;
1339 if (sscanf(str, "OpenGL ES-CM %d.%d", &major, &minor) != 2) {
1340 if (sscanf(str, "OpenGL ES %d.%d", &major, &minor) != 2) {
1341 ALOGW("Unable to parse GL_VERSION string: \"%s\"", str);
1342 return GLES_VERSION_1_0;
1343 }
1344 }
1345
1346 if (major == 1 && minor == 0) return GLES_VERSION_1_0;
1347 if (major == 1 && minor >= 1) return GLES_VERSION_1_1;
1348 if (major == 2 && minor >= 0) return GLES_VERSION_2_0;
1349 if (major == 3 && minor >= 0) return GLES_VERSION_3_0;
1350
1351 ALOGW("Unrecognized OpenGL ES version: %d.%d", major, minor);
1352 return GLES_VERSION_1_0;
1353}
1354
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001355EGLContext GLESRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,
Peiyong Linfb530cf2018-12-15 05:07:38 +00001356 EGLContext shareContext, bool useContextPriority,
1357 Protection protection) {
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001358 EGLint renderableType = 0;
1359 if (config == EGL_NO_CONFIG) {
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001360 renderableType = EGL_OPENGL_ES3_BIT;
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001361 } else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) {
1362 LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");
1363 }
1364 EGLint contextClientVersion = 0;
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001365 if (renderableType & EGL_OPENGL_ES3_BIT) {
1366 contextClientVersion = 3;
1367 } else if (renderableType & EGL_OPENGL_ES2_BIT) {
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001368 contextClientVersion = 2;
1369 } else if (renderableType & EGL_OPENGL_ES_BIT) {
1370 contextClientVersion = 1;
1371 } else {
1372 LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs");
1373 }
1374
1375 std::vector<EGLint> contextAttributes;
Peiyong Linfb530cf2018-12-15 05:07:38 +00001376 contextAttributes.reserve(7);
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001377 contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
1378 contextAttributes.push_back(contextClientVersion);
1379 if (useContextPriority) {
1380 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG);
1381 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG);
1382 }
Peiyong Linfb530cf2018-12-15 05:07:38 +00001383 if (protection == Protection::PROTECTED) {
1384 contextAttributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1385 contextAttributes.push_back(EGL_TRUE);
1386 }
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001387 contextAttributes.push_back(EGL_NONE);
1388
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001389 EGLContext context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1390
1391 if (contextClientVersion == 3 && context == EGL_NO_CONTEXT) {
1392 // eglGetConfigAttrib indicated we can create GLES 3 context, but we failed, thus
1393 // EGL_NO_CONTEXT so that we can abort.
1394 if (config != EGL_NO_CONFIG) {
1395 return context;
1396 }
1397 // If |config| is EGL_NO_CONFIG, we speculatively try to create GLES 3 context, so we should
1398 // try to fall back to GLES 2.
1399 contextAttributes[1] = 2;
1400 context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1401 }
1402
1403 return context;
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001404}
1405
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001406EGLSurface GLESRenderEngine::createDummyEglPbufferSurface(EGLDisplay display, EGLConfig config,
Peiyong Linfb530cf2018-12-15 05:07:38 +00001407 int hwcFormat, Protection protection) {
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001408 EGLConfig dummyConfig = config;
1409 if (dummyConfig == EGL_NO_CONFIG) {
1410 dummyConfig = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);
1411 }
1412 std::vector<EGLint> attributes;
Peiyong Linfb530cf2018-12-15 05:07:38 +00001413 attributes.reserve(7);
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001414 attributes.push_back(EGL_WIDTH);
1415 attributes.push_back(1);
1416 attributes.push_back(EGL_HEIGHT);
1417 attributes.push_back(1);
Peiyong Linfb530cf2018-12-15 05:07:38 +00001418 if (protection == Protection::PROTECTED) {
1419 attributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1420 attributes.push_back(EGL_TRUE);
1421 }
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001422 attributes.push_back(EGL_NONE);
1423
1424 return eglCreatePbufferSurface(display, dummyConfig, attributes.data());
1425}
1426
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001427bool GLESRenderEngine::isHdrDataSpace(const Dataspace dataSpace) const {
Peiyong Lina296b0c2018-04-30 16:55:29 -07001428 const Dataspace standard = static_cast<Dataspace>(dataSpace & Dataspace::STANDARD_MASK);
1429 const Dataspace transfer = static_cast<Dataspace>(dataSpace & Dataspace::TRANSFER_MASK);
1430 return standard == Dataspace::STANDARD_BT2020 &&
Peiyong Lin46080ef2018-10-26 18:43:14 -07001431 (transfer == Dataspace::TRANSFER_ST2084 || transfer == Dataspace::TRANSFER_HLG);
Peiyong Lina296b0c2018-04-30 16:55:29 -07001432}
1433
1434// For convenience, we want to convert the input color space to XYZ color space first,
1435// and then convert from XYZ color space to output color space when
1436// - SDR and HDR contents are mixed, either SDR content will be converted to HDR or
1437// HDR content will be tone-mapped to SDR; Or,
1438// - there are HDR PQ and HLG contents presented at the same time, where we want to convert
1439// HLG content to PQ content.
1440// In either case above, we need to operate the Y value in XYZ color space. Thus, when either
1441// input data space or output data space is HDR data space, and the input transfer function
1442// doesn't match the output transfer function, we would enable an intermediate transfrom to
1443// XYZ color space.
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001444bool GLESRenderEngine::needsXYZTransformMatrix() const {
Peiyong Lina296b0c2018-04-30 16:55:29 -07001445 const bool isInputHdrDataSpace = isHdrDataSpace(mDataSpace);
1446 const bool isOutputHdrDataSpace = isHdrDataSpace(mOutputDataSpace);
1447 const Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK);
Peiyong Lin46080ef2018-10-26 18:43:14 -07001448 const Dataspace outputTransfer =
1449 static_cast<Dataspace>(mOutputDataSpace & Dataspace::TRANSFER_MASK);
Peiyong Lina296b0c2018-04-30 16:55:29 -07001450
1451 return (isInputHdrDataSpace || isOutputHdrDataSpace) && inputTransfer != outputTransfer;
1452}
1453
Alec Mourid43ccab2019-03-13 12:23:45 -07001454bool GLESRenderEngine::isImageCachedForTesting(uint64_t bufferId) {
1455 std::lock_guard<std::mutex> lock(mRenderingMutex);
1456 const auto& cachedImage = mImageCache.find(bufferId);
1457 return cachedImage != mImageCache.end();
1458}
1459
1460bool GLESRenderEngine::isFramebufferImageCachedForTesting(uint64_t bufferId) {
Alec Mouri192a3752019-07-15 15:27:22 -07001461 std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
Alec Mourid43ccab2019-03-13 12:23:45 -07001462 return std::any_of(mFramebufferImageCache.cbegin(), mFramebufferImageCache.cend(),
1463 [=](std::pair<uint64_t, EGLImageKHR> image) {
1464 return image.first == bufferId;
1465 });
1466}
1467
Alec Mouri554d06e2018-12-20 00:15:33 -08001468// FlushTracer implementation
1469GLESRenderEngine::FlushTracer::FlushTracer(GLESRenderEngine* engine) : mEngine(engine) {
1470 mThread = std::thread(&GLESRenderEngine::FlushTracer::loop, this);
1471}
1472
1473GLESRenderEngine::FlushTracer::~FlushTracer() {
1474 {
1475 std::lock_guard<std::mutex> lock(mMutex);
1476 mRunning = false;
1477 }
1478 mCondition.notify_all();
1479 if (mThread.joinable()) {
1480 mThread.join();
1481 }
1482}
1483
1484void GLESRenderEngine::FlushTracer::queueSync(EGLSyncKHR sync) {
1485 std::lock_guard<std::mutex> lock(mMutex);
1486 char name[64];
1487 const uint64_t frameNum = mFramesQueued++;
1488 snprintf(name, sizeof(name), "Queueing sync for frame: %lu",
1489 static_cast<unsigned long>(frameNum));
1490 ATRACE_NAME(name);
1491 mQueue.push({sync, frameNum});
1492 ATRACE_INT("GPU Frames Outstanding", mQueue.size());
1493 mCondition.notify_one();
1494}
1495
1496void GLESRenderEngine::FlushTracer::loop() {
1497 while (mRunning) {
1498 QueueEntry entry;
1499 {
1500 std::lock_guard<std::mutex> lock(mMutex);
1501
1502 mCondition.wait(mMutex,
Alec Mouric15dd012019-01-15 15:30:38 -08001503 [&]() REQUIRES(mMutex) { return !mQueue.empty() || !mRunning; });
Alec Mouri554d06e2018-12-20 00:15:33 -08001504
1505 if (!mRunning) {
1506 // if mRunning is false, then FlushTracer is being destroyed, so
1507 // bail out now.
1508 break;
1509 }
1510 entry = mQueue.front();
1511 mQueue.pop();
1512 }
1513 {
1514 char name[64];
1515 snprintf(name, sizeof(name), "waiting for frame %lu",
1516 static_cast<unsigned long>(entry.mFrameNum));
1517 ATRACE_NAME(name);
1518 mEngine->waitSync(entry.mSync, 0);
1519 }
1520 }
1521}
1522
Peiyong Lin46080ef2018-10-26 18:43:14 -07001523} // namespace gl
1524} // namespace renderengine
1525} // namespace android