blob: 3d6ac8f19859b8b50c85486f0b7a5041b94d1991 [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>
Peiyong Lincbc184f2018-08-22 13:24:10 -070034#include <renderengine/Mesh.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070035#include <renderengine/Texture.h>
Peiyong Lin833074a2018-08-28 11:53:54 -070036#include <renderengine/private/Description.h>
Alec Mouri0d5e1eb2018-11-10 20:40:12 -080037#include <sync/sync.h>
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -060038#include <ui/ColorSpace.h>
39#include <ui/DebugUtils.h>
Dan Stozac1879002014-05-22 15:59:05 -070040#include <ui/Rect.h>
Peiyong Lin60bedb52018-09-05 10:47:31 -070041#include <ui/Region.h>
Chia-I Wu56d7b0a2018-10-01 15:13:11 -070042#include <utils/KeyedVector.h>
Mathias Agopian3f844832013-08-07 21:24:32 -070043#include <utils/Trace.h>
Peiyong Linf1bada92018-08-29 09:39:31 -070044#include "GLExtensions.h"
Peiyong Line5a9a7f2018-08-30 15:32:13 -070045#include "GLFramebuffer.h"
Peiyong Linf1bada92018-08-29 09:39:31 -070046#include "GLImage.h"
Peiyong Lin833074a2018-08-28 11:53:54 -070047#include "Program.h"
48#include "ProgramCache.h"
Mathias Agopian3f844832013-08-07 21:24:32 -070049
Peiyong Linf11f39b2018-09-05 14:37:41 -070050extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
51
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -060052bool checkGlError(const char* op, int lineNumber) {
53 bool errorFound = false;
54 GLint error = glGetError();
55 while (error != GL_NO_ERROR) {
56 errorFound = true;
57 error = glGetError();
58 ALOGV("after %s() (line # %d) glError (0x%x)\n", op, lineNumber, error);
59 }
60 return errorFound;
61}
62
Courtney Goeltzenleuchter4f20f9c2017-04-06 08:18:34 -060063static constexpr bool outputDebugPPMs = false;
64
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -060065void writePPM(const char* basename, GLuint width, GLuint height) {
66 ALOGV("writePPM #%s: %d x %d", basename, width, height);
67
68 std::vector<GLubyte> pixels(width * height * 4);
69 std::vector<GLubyte> outBuffer(width * height * 3);
70
71 // TODO(courtneygo): We can now have float formats, need
72 // to remove this code or update to support.
73 // Make returned pixels fit in uint32_t, one byte per component
74 glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
75 if (checkGlError(__FUNCTION__, __LINE__)) {
76 return;
77 }
78
79 std::string filename(basename);
80 filename.append(".ppm");
81 std::ofstream file(filename.c_str(), std::ios::binary);
82 if (!file.is_open()) {
83 ALOGE("Unable to open file: %s", filename.c_str());
84 ALOGE("You may need to do: \"adb shell setenforce 0\" to enable "
85 "surfaceflinger to write debug images");
86 return;
87 }
88
89 file << "P6\n";
90 file << width << "\n";
91 file << height << "\n";
92 file << 255 << "\n";
93
94 auto ptr = reinterpret_cast<char*>(pixels.data());
95 auto outPtr = reinterpret_cast<char*>(outBuffer.data());
96 for (int y = height - 1; y >= 0; y--) {
97 char* data = ptr + y * width * sizeof(uint32_t);
98
99 for (GLuint x = 0; x < width; x++) {
100 // Only copy R, G and B components
101 outPtr[0] = data[0];
102 outPtr[1] = data[1];
103 outPtr[2] = data[2];
104 data += sizeof(uint32_t);
105 outPtr += 3;
106 }
107 }
108 file.write(reinterpret_cast<char*>(outBuffer.data()), outBuffer.size());
109}
110
Mathias Agopian3f844832013-08-07 21:24:32 -0700111namespace android {
Peiyong Lin833074a2018-08-28 11:53:54 -0700112namespace renderengine {
113namespace gl {
Mathias Agopian3f844832013-08-07 21:24:32 -0700114
Yiwei Zhang5434a782018-12-05 18:06:32 -0800115using base::StringAppendF;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700116using ui::Dataspace;
117
Peiyong Linf11f39b2018-09-05 14:37:41 -0700118static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs, EGLint attribute,
119 EGLint wanted, EGLConfig* outConfig) {
120 EGLint numConfigs = -1, n = 0;
121 eglGetConfigs(dpy, nullptr, 0, &numConfigs);
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700122 std::vector<EGLConfig> configs(numConfigs, EGL_NO_CONFIG_KHR);
123 eglChooseConfig(dpy, attrs, configs.data(), configs.size(), &n);
124 configs.resize(n);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700125
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700126 if (!configs.empty()) {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700127 if (attribute != EGL_NONE) {
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700128 for (EGLConfig config : configs) {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700129 EGLint value = 0;
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700130 eglGetConfigAttrib(dpy, config, attribute, &value);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700131 if (wanted == value) {
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700132 *outConfig = config;
Peiyong Linf11f39b2018-09-05 14:37:41 -0700133 return NO_ERROR;
134 }
135 }
136 } else {
137 // just pick the first one
138 *outConfig = configs[0];
Peiyong Linf11f39b2018-09-05 14:37:41 -0700139 return NO_ERROR;
140 }
141 }
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700142
Peiyong Linf11f39b2018-09-05 14:37:41 -0700143 return NAME_NOT_FOUND;
144}
145
146class EGLAttributeVector {
147 struct Attribute;
148 class Adder;
149 friend class Adder;
150 KeyedVector<Attribute, EGLint> mList;
151 struct Attribute {
152 Attribute() : v(0){};
153 explicit Attribute(EGLint v) : v(v) {}
154 EGLint v;
155 bool operator<(const Attribute& other) const {
156 // this places EGL_NONE at the end
157 EGLint lhs(v);
158 EGLint rhs(other.v);
159 if (lhs == EGL_NONE) lhs = 0x7FFFFFFF;
160 if (rhs == EGL_NONE) rhs = 0x7FFFFFFF;
161 return lhs < rhs;
162 }
163 };
164 class Adder {
165 friend class EGLAttributeVector;
166 EGLAttributeVector& v;
167 EGLint attribute;
168 Adder(EGLAttributeVector& v, EGLint attribute) : v(v), attribute(attribute) {}
169
170 public:
171 void operator=(EGLint value) {
172 if (attribute != EGL_NONE) {
173 v.mList.add(Attribute(attribute), value);
174 }
175 }
176 operator EGLint() const { return v.mList[attribute]; }
177 };
178
179public:
180 EGLAttributeVector() { mList.add(Attribute(EGL_NONE), EGL_NONE); }
181 void remove(EGLint attribute) {
182 if (attribute != EGL_NONE) {
183 mList.removeItem(Attribute(attribute));
184 }
185 }
186 Adder operator[](EGLint attribute) { return Adder(*this, attribute); }
187 EGLint operator[](EGLint attribute) const { return mList[attribute]; }
188 // cast-operator to (EGLint const*)
189 operator EGLint const*() const { return &mList.keyAt(0).v; }
190};
191
192static status_t selectEGLConfig(EGLDisplay display, EGLint format, EGLint renderableType,
193 EGLConfig* config) {
194 // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if
195 // it is to be used with WIFI displays
196 status_t err;
197 EGLint wantedAttribute;
198 EGLint wantedAttributeValue;
199
200 EGLAttributeVector attribs;
201 if (renderableType) {
202 attribs[EGL_RENDERABLE_TYPE] = renderableType;
203 attribs[EGL_RECORDABLE_ANDROID] = EGL_TRUE;
204 attribs[EGL_SURFACE_TYPE] = EGL_WINDOW_BIT | EGL_PBUFFER_BIT;
205 attribs[EGL_FRAMEBUFFER_TARGET_ANDROID] = EGL_TRUE;
206 attribs[EGL_RED_SIZE] = 8;
207 attribs[EGL_GREEN_SIZE] = 8;
208 attribs[EGL_BLUE_SIZE] = 8;
209 attribs[EGL_ALPHA_SIZE] = 8;
210 wantedAttribute = EGL_NONE;
211 wantedAttributeValue = EGL_NONE;
212 } else {
213 // if no renderable type specified, fallback to a simplified query
214 wantedAttribute = EGL_NATIVE_VISUAL_ID;
215 wantedAttributeValue = format;
216 }
217
218 err = selectConfigForAttribute(display, attribs, wantedAttribute, wantedAttributeValue, config);
219 if (err == NO_ERROR) {
220 EGLint caveat;
221 if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat))
222 ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!");
223 }
224
225 return err;
226}
227
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800228std::unique_ptr<GLESRenderEngine> GLESRenderEngine::create(int hwcFormat, uint32_t featureFlags) {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700229 // initialize EGL for the default display
230 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
231 if (!eglInitialize(display, nullptr, nullptr)) {
232 LOG_ALWAYS_FATAL("failed to initialize EGL");
233 }
234
235 GLExtensions& extensions = GLExtensions::getInstance();
236 extensions.initWithEGLStrings(eglQueryStringImplementationANDROID(display, EGL_VERSION),
237 eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS));
238
239 // The code assumes that ES2 or later is available if this extension is
240 // supported.
241 EGLConfig config = EGL_NO_CONFIG;
242 if (!extensions.hasNoConfigContext()) {
243 config = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);
244 }
245
Peiyong Linf11f39b2018-09-05 14:37:41 -0700246 bool useContextPriority = extensions.hasContextPriority() &&
Peiyong Lin46080ef2018-10-26 18:43:14 -0700247 (featureFlags & RenderEngine::USE_HIGH_PRIORITY_CONTEXT);
Peiyong Linfb530cf2018-12-15 05:07:38 +0000248 EGLContext protectedContext = EGL_NO_CONTEXT;
249 if (extensions.hasProtectedContent()) {
250 protectedContext = createEglContext(display, config, nullptr, useContextPriority,
251 Protection::PROTECTED);
252 ALOGE_IF(protectedContext == EGL_NO_CONTEXT, "Can't create protected context");
253 }
254
255 EGLContext ctxt = createEglContext(display, config, protectedContext, useContextPriority,
256 Protection::UNPROTECTED);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700257
258 // if can't create a GL context, we can only abort.
259 LOG_ALWAYS_FATAL_IF(ctxt == EGL_NO_CONTEXT, "EGLContext creation failed");
260
Peiyong Lina5e9f1b2018-11-27 22:49:37 -0800261 EGLSurface dummy = EGL_NO_SURFACE;
262 if (!extensions.hasSurfacelessContext()) {
Peiyong Linfb530cf2018-12-15 05:07:38 +0000263 dummy = createDummyEglPbufferSurface(display, config, hwcFormat, Protection::UNPROTECTED);
Peiyong Lina5e9f1b2018-11-27 22:49:37 -0800264 LOG_ALWAYS_FATAL_IF(dummy == EGL_NO_SURFACE, "can't create dummy pbuffer");
Peiyong Linf11f39b2018-09-05 14:37:41 -0700265 }
Peiyong Linf11f39b2018-09-05 14:37:41 -0700266 EGLBoolean success = eglMakeCurrent(display, dummy, dummy, ctxt);
267 LOG_ALWAYS_FATAL_IF(!success, "can't make dummy pbuffer current");
Peiyong Linf11f39b2018-09-05 14:37:41 -0700268 extensions.initWithGLStrings(glGetString(GL_VENDOR), glGetString(GL_RENDERER),
269 glGetString(GL_VERSION), glGetString(GL_EXTENSIONS));
270
Peiyong Linfb530cf2018-12-15 05:07:38 +0000271 // In order to have protected contents in GPU composition, the OpenGL ES extension
272 // GL_EXT_protected_textures must be supported. If it's not supported, reset
273 // protected context to EGL_NO_CONTEXT to indicate that protected contents is not supported.
274 if (!extensions.hasProtectedTexture()) {
275 protectedContext = EGL_NO_CONTEXT;
276 }
277
278 EGLSurface protectedDummy = EGL_NO_SURFACE;
279 if (protectedContext != EGL_NO_CONTEXT && !extensions.hasSurfacelessContext()) {
280 protectedDummy =
281 createDummyEglPbufferSurface(display, config, hwcFormat, Protection::PROTECTED);
282 ALOGE_IF(protectedDummy == EGL_NO_SURFACE, "can't create protected dummy pbuffer");
283 }
284
Peiyong Lina5e9f1b2018-11-27 22:49:37 -0800285 // now figure out what version of GL did we actually get
Peiyong Linf11f39b2018-09-05 14:37:41 -0700286 GlesVersion version = parseGlesVersion(extensions.getVersion());
287
288 // initialize the renderer while GL is current
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800289 std::unique_ptr<GLESRenderEngine> engine;
Peiyong Linf11f39b2018-09-05 14:37:41 -0700290 switch (version) {
291 case GLES_VERSION_1_0:
292 case GLES_VERSION_1_1:
293 LOG_ALWAYS_FATAL("SurfaceFlinger requires OpenGL ES 2.0 minimum to run.");
294 break;
295 case GLES_VERSION_2_0:
296 case GLES_VERSION_3_0:
Peiyong Linfb530cf2018-12-15 05:07:38 +0000297 engine = std::make_unique<GLESRenderEngine>(featureFlags, display, config, ctxt, dummy,
298 protectedContext, protectedDummy);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700299 break;
300 }
Peiyong Linf11f39b2018-09-05 14:37:41 -0700301
302 ALOGI("OpenGL ES informations:");
303 ALOGI("vendor : %s", extensions.getVendor());
304 ALOGI("renderer : %s", extensions.getRenderer());
305 ALOGI("version : %s", extensions.getVersion());
306 ALOGI("extensions: %s", extensions.getExtensions());
307 ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize());
308 ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims());
309
Peiyong Linf11f39b2018-09-05 14:37:41 -0700310 return engine;
311}
312
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800313EGLConfig GLESRenderEngine::chooseEglConfig(EGLDisplay display, int format, bool logConfig) {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700314 status_t err;
315 EGLConfig config;
316
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800317 // First try to get an ES3 config
318 err = selectEGLConfig(display, format, EGL_OPENGL_ES3_BIT, &config);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700319 if (err != NO_ERROR) {
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800320 // If ES3 fails, try to get an ES2 config
321 err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700322 if (err != NO_ERROR) {
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800323 // If ES2 still doesn't work, probably because we're on the emulator.
Peiyong Linf11f39b2018-09-05 14:37:41 -0700324 // try a simplified query
325 ALOGW("no suitable EGLConfig found, trying a simpler query");
326 err = selectEGLConfig(display, format, 0, &config);
327 if (err != NO_ERROR) {
328 // this EGL is too lame for android
329 LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up");
330 }
331 }
332 }
333
334 if (logConfig) {
335 // print some debugging info
336 EGLint r, g, b, a;
337 eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r);
338 eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
339 eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);
340 eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);
341 ALOGI("EGL information:");
342 ALOGI("vendor : %s", eglQueryString(display, EGL_VENDOR));
343 ALOGI("version : %s", eglQueryString(display, EGL_VERSION));
344 ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS));
345 ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS) ?: "Not Supported");
346 ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);
347 }
348
349 return config;
350}
351
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800352GLESRenderEngine::GLESRenderEngine(uint32_t featureFlags, EGLDisplay display, EGLConfig config,
Peiyong Linfb530cf2018-12-15 05:07:38 +0000353 EGLContext ctxt, EGLSurface dummy, EGLContext protectedContext,
354 EGLSurface protectedDummy)
Peiyong Linf11f39b2018-09-05 14:37:41 -0700355 : renderengine::impl::RenderEngine(featureFlags),
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800356 mEGLDisplay(display),
357 mEGLConfig(config),
358 mEGLContext(ctxt),
359 mDummySurface(dummy),
Peiyong Linfb530cf2018-12-15 05:07:38 +0000360 mProtectedEGLContext(protectedContext),
361 mProtectedDummySurface(protectedDummy),
Chia-I Wu93e14df2018-06-04 10:10:17 -0700362 mVpWidth(0),
363 mVpHeight(0),
Peiyong Lin13effd12018-07-24 17:01:47 -0700364 mUseColorManagement(featureFlags & USE_COLOR_MANAGEMENT) {
Mathias Agopian3f844832013-08-07 21:24:32 -0700365 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
366 glGetIntegerv(GL_MAX_VIEWPORT_DIMS, mMaxViewportDims);
367
368 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
369 glPixelStorei(GL_PACK_ALIGNMENT, 4);
370
Peiyong Linfb530cf2018-12-15 05:07:38 +0000371 // Initialize protected EGL Context.
372 if (mProtectedEGLContext != EGL_NO_CONTEXT) {
373 EGLBoolean success = eglMakeCurrent(display, mProtectedDummySurface, mProtectedDummySurface,
374 mProtectedEGLContext);
375 ALOGE_IF(!success, "can't make protected context current");
376 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
377 glPixelStorei(GL_PACK_ALIGNMENT, 4);
378 success = eglMakeCurrent(display, mDummySurface, mDummySurface, mEGLContext);
379 LOG_ALWAYS_FATAL_IF(!success, "can't make default context current");
380 }
381
Chia-I Wub027f802017-11-29 14:00:52 -0800382 const uint16_t protTexData[] = {0};
Mathias Agopian3f844832013-08-07 21:24:32 -0700383 glGenTextures(1, &mProtectedTexName);
384 glBindTexture(GL_TEXTURE_2D, mProtectedTexName);
385 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
386 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
387 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
388 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
Chia-I Wub027f802017-11-29 14:00:52 -0800389 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 -0700390
Chia-I Wub027f802017-11-29 14:00:52 -0800391 // mColorBlindnessCorrection = M;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600392
Peiyong Lin13effd12018-07-24 17:01:47 -0700393 if (mUseColorManagement) {
Valerie Haueb8e0762018-11-06 10:10:42 -0800394 const ColorSpace srgb(ColorSpace::sRGB());
395 const ColorSpace displayP3(ColorSpace::DisplayP3());
396 const ColorSpace bt2020(ColorSpace::BT2020());
Peiyong Lina296b0c2018-04-30 16:55:29 -0700397
398 // no chromatic adaptation needed since all color spaces use D65 for their white points.
Peiyong Lin70b26ce2018-09-18 19:02:39 -0700399 mSrgbToXyz = mat4(srgb.getRGBtoXYZ());
400 mDisplayP3ToXyz = mat4(displayP3.getRGBtoXYZ());
401 mBt2020ToXyz = mat4(bt2020.getRGBtoXYZ());
Peiyong Lin9b03c732018-05-17 10:14:02 -0700402 mXyzToSrgb = mat4(srgb.getXYZtoRGB());
Peiyong Lina296b0c2018-04-30 16:55:29 -0700403 mXyzToDisplayP3 = mat4(displayP3.getXYZtoRGB());
404 mXyzToBt2020 = mat4(bt2020.getXYZtoRGB());
Valerie Haueb8e0762018-11-06 10:10:42 -0800405
406 // Compute sRGB to Display P3 and BT2020 transform matrix.
407 // NOTE: For now, we are limiting output wide color space support to
408 // Display-P3 and BT2020 only.
409 mSrgbToDisplayP3 = mXyzToDisplayP3 * mSrgbToXyz;
410 mSrgbToBt2020 = mXyzToBt2020 * mSrgbToXyz;
411
412 // Compute Display P3 to sRGB and BT2020 transform matrix.
413 mDisplayP3ToSrgb = mXyzToSrgb * mDisplayP3ToXyz;
414 mDisplayP3ToBt2020 = mXyzToBt2020 * mDisplayP3ToXyz;
415
416 // Compute BT2020 to sRGB and Display P3 transform matrix
417 mBt2020ToSrgb = mXyzToSrgb * mBt2020ToXyz;
418 mBt2020ToDisplayP3 = mXyzToDisplayP3 * mBt2020ToXyz;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600419 }
Alec Mouri554d06e2018-12-20 00:15:33 -0800420
421 char value[PROPERTY_VALUE_MAX];
422 property_get("debug.egl.traceGpuCompletion", value, "0");
423 if (atoi(value)) {
424 mTraceGpuCompletion = true;
425 mFlushTracer = std::make_unique<FlushTracer>(this);
426 }
Mathias Agopian3f844832013-08-07 21:24:32 -0700427}
428
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800429GLESRenderEngine::~GLESRenderEngine() {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700430 eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
431 eglTerminate(mEGLDisplay);
432}
Mathias Agopian3f844832013-08-07 21:24:32 -0700433
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800434std::unique_ptr<Framebuffer> GLESRenderEngine::createFramebuffer() {
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700435 return std::make_unique<GLFramebuffer>(*this);
436}
437
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800438std::unique_ptr<Image> GLESRenderEngine::createImage() {
Peiyong Linf1bada92018-08-29 09:39:31 -0700439 return std::make_unique<GLImage>(*this);
440}
441
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800442void GLESRenderEngine::primeCache() const {
Peiyong Linfb530cf2018-12-15 05:07:38 +0000443 ProgramCache::getInstance().primeCache(mInProtectedContext ? mProtectedEGLContext : mEGLContext,
444 mFeatureFlags & USE_COLOR_MANAGEMENT);
Peiyong Linf1bada92018-08-29 09:39:31 -0700445}
446
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800447bool GLESRenderEngine::isCurrent() const {
Peiyong Linf1bada92018-08-29 09:39:31 -0700448 return mEGLDisplay == eglGetCurrentDisplay() && mEGLContext == eglGetCurrentContext();
449}
450
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800451base::unique_fd GLESRenderEngine::flush() {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000452 ATRACE_CALL();
Peiyong Lin60bedb52018-09-05 10:47:31 -0700453 if (!GLExtensions::getInstance().hasNativeFenceSync()) {
454 return base::unique_fd();
455 }
456
457 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
458 if (sync == EGL_NO_SYNC_KHR) {
459 ALOGW("failed to create EGL native fence sync: %#x", eglGetError());
460 return base::unique_fd();
461 }
462
463 // native fence fd will not be populated until flush() is done.
464 glFlush();
465
466 // get the fence fd
467 base::unique_fd fenceFd(eglDupNativeFenceFDANDROID(mEGLDisplay, sync));
468 eglDestroySyncKHR(mEGLDisplay, sync);
469 if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
470 ALOGW("failed to dup EGL native fence sync: %#x", eglGetError());
471 }
472
Alec Mouri554d06e2018-12-20 00:15:33 -0800473 // Only trace if we have a valid fence, as current usage falls back to
474 // calling finish() if the fence fd is invalid.
475 if (CC_UNLIKELY(mTraceGpuCompletion && mFlushTracer) && fenceFd.get() >= 0) {
476 mFlushTracer->queueSync(eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr));
477 }
478
Peiyong Lin60bedb52018-09-05 10:47:31 -0700479 return fenceFd;
480}
481
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800482bool GLESRenderEngine::finish() {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000483 ATRACE_CALL();
Peiyong Lin60bedb52018-09-05 10:47:31 -0700484 if (!GLExtensions::getInstance().hasFenceSync()) {
485 ALOGW("no synchronization support");
486 return false;
487 }
488
489 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr);
490 if (sync == EGL_NO_SYNC_KHR) {
491 ALOGW("failed to create EGL fence sync: %#x", eglGetError());
492 return false;
493 }
494
Alec Mouri554d06e2018-12-20 00:15:33 -0800495 if (CC_UNLIKELY(mTraceGpuCompletion && mFlushTracer)) {
496 mFlushTracer->queueSync(eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr));
497 }
498
499 return waitSync(sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR);
500}
501
502bool GLESRenderEngine::waitSync(EGLSyncKHR sync, EGLint flags) {
503 EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync, flags, 2000000000 /*2 sec*/);
Peiyong Lin60bedb52018-09-05 10:47:31 -0700504 EGLint error = eglGetError();
505 eglDestroySyncKHR(mEGLDisplay, sync);
506 if (result != EGL_CONDITION_SATISFIED_KHR) {
507 if (result == EGL_TIMEOUT_EXPIRED_KHR) {
508 ALOGW("fence wait timed out");
509 } else {
510 ALOGW("error waiting on EGL fence: %#x", error);
511 }
512 return false;
513 }
514
515 return true;
516}
517
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800518bool GLESRenderEngine::waitFence(base::unique_fd fenceFd) {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700519 if (!GLExtensions::getInstance().hasNativeFenceSync() ||
520 !GLExtensions::getInstance().hasWaitSync()) {
521 return false;
522 }
523
524 EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceFd, EGL_NONE};
525 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
526 if (sync == EGL_NO_SYNC_KHR) {
527 ALOGE("failed to create EGL native fence sync: %#x", eglGetError());
528 return false;
529 }
530
531 // fenceFd is now owned by EGLSync
532 (void)fenceFd.release();
533
534 // XXX: The spec draft is inconsistent as to whether this should return an
535 // EGLint or void. Ignore the return value for now, as it's not strictly
536 // needed.
537 eglWaitSyncKHR(mEGLDisplay, sync, 0);
538 EGLint error = eglGetError();
539 eglDestroySyncKHR(mEGLDisplay, sync);
540 if (error != EGL_SUCCESS) {
541 ALOGE("failed to wait for EGL native fence sync: %#x", error);
542 return false;
543 }
544
545 return true;
546}
547
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800548void GLESRenderEngine::clearWithColor(float red, float green, float blue, float alpha) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000549 ATRACE_CALL();
550 glDisable(GL_BLEND);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700551 glClearColor(red, green, blue, alpha);
552 glClear(GL_COLOR_BUFFER_BIT);
553}
554
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800555void GLESRenderEngine::fillRegionWithColor(const Region& region, float red, float green, float blue,
556 float alpha) {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700557 size_t c;
558 Rect const* r = region.getArray(&c);
559 Mesh mesh(Mesh::TRIANGLES, c * 6, 2);
560 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
561 for (size_t i = 0; i < c; i++, r++) {
562 position[i * 6 + 0].x = r->left;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700563 position[i * 6 + 0].y = r->top;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700564 position[i * 6 + 1].x = r->left;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700565 position[i * 6 + 1].y = r->bottom;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700566 position[i * 6 + 2].x = r->right;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700567 position[i * 6 + 2].y = r->bottom;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700568 position[i * 6 + 3].x = r->left;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700569 position[i * 6 + 3].y = r->top;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700570 position[i * 6 + 4].x = r->right;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700571 position[i * 6 + 4].y = r->bottom;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700572 position[i * 6 + 5].x = r->right;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700573 position[i * 6 + 5].y = r->top;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700574 }
575 setupFillWithColor(red, green, blue, alpha);
576 drawMesh(mesh);
577}
578
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800579void GLESRenderEngine::setScissor(const Rect& region) {
Alec Mouri05483a02018-09-10 21:03:42 +0000580 // Invert y-coordinate to map to GL-space.
Alec Mouri7e593912018-11-17 04:57:33 +0000581 int32_t canvasHeight = mFboHeight;
Alec Mouri05483a02018-09-10 21:03:42 +0000582 int32_t glBottom = canvasHeight - region.bottom;
583
584 glScissor(region.left, glBottom, region.getWidth(), region.getHeight());
Peiyong Lin60bedb52018-09-05 10:47:31 -0700585 glEnable(GL_SCISSOR_TEST);
586}
587
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800588void GLESRenderEngine::disableScissor() {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700589 glDisable(GL_SCISSOR_TEST);
590}
591
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800592void GLESRenderEngine::genTextures(size_t count, uint32_t* names) {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700593 glGenTextures(count, names);
594}
595
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800596void GLESRenderEngine::deleteTextures(size_t count, uint32_t const* names) {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700597 glDeleteTextures(count, names);
598}
599
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800600void GLESRenderEngine::bindExternalTextureImage(uint32_t texName, const Image& image) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000601 ATRACE_CALL();
Peiyong Linf1bada92018-08-29 09:39:31 -0700602 const GLImage& glImage = static_cast<const GLImage&>(image);
603 const GLenum target = GL_TEXTURE_EXTERNAL_OES;
604
605 glBindTexture(target, texName);
Peiyong Linfb530cf2018-12-15 05:07:38 +0000606 if (supportsProtectedContent()) {
607 glTexParameteri(target, GL_TEXTURE_PROTECTED_EXT,
608 glImage.isProtected() ? GL_TRUE : GL_FALSE);
609 }
Peiyong Linf1bada92018-08-29 09:39:31 -0700610 if (glImage.getEGLImage() != EGL_NO_IMAGE_KHR) {
Peiyong Lin46080ef2018-10-26 18:43:14 -0700611 glEGLImageTargetTexture2DOES(target, static_cast<GLeglImageOES>(glImage.getEGLImage()));
Peiyong Linf1bada92018-08-29 09:39:31 -0700612 }
Mathias Agopian3f844832013-08-07 21:24:32 -0700613}
614
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800615status_t GLESRenderEngine::bindExternalTextureBuffer(uint32_t texName, sp<GraphicBuffer> buffer,
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000616 sp<Fence> bufferFence, bool readCache) {
617 return bindExternalTextureBuffer(texName, buffer, bufferFence, readCache,
618 /*persistCache=*/false);
619}
620
621status_t GLESRenderEngine::bindExternalTextureBuffer(uint32_t texName, sp<GraphicBuffer> buffer,
Alec Mouri539319f2018-12-19 17:56:23 -0800622 sp<Fence> bufferFence, bool readCache,
623 bool persistCache) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000624 ATRACE_CALL();
Alec Mouri539319f2018-12-19 17:56:23 -0800625 if (readCache) {
626 auto cachedImage = mImageCache.find(buffer->getId());
627
628 if (cachedImage != mImageCache.end()) {
629 bindExternalTextureImage(texName, *cachedImage->second);
630 return NO_ERROR;
631 }
632 }
633
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800634 std::unique_ptr<Image> newImage = createImage();
635
636 bool created = newImage->setNativeWindowBuffer(buffer->getNativeBuffer(),
637 buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
638 if (!created) {
639 ALOGE("Failed to create image. size=%ux%u st=%u usage=%#" PRIx64 " fmt=%d",
640 buffer->getWidth(), buffer->getHeight(), buffer->getStride(), buffer->getUsage(),
641 buffer->getPixelFormat());
642 bindExternalTextureImage(texName, *createImage());
643 return NO_INIT;
644 }
645
646 bindExternalTextureImage(texName, *newImage);
647
648 // Wait for the new buffer to be ready.
649 if (bufferFence != nullptr && bufferFence->isValid()) {
650 if (GLExtensions::getInstance().hasWaitSync()) {
651 base::unique_fd fenceFd(bufferFence->dup());
652 if (fenceFd == -1) {
653 ALOGE("error dup'ing fence fd: %d", errno);
654 return -errno;
655 }
656 if (!waitFence(std::move(fenceFd))) {
657 ALOGE("failed to wait on fence fd");
658 return UNKNOWN_ERROR;
659 }
660 } else {
661 status_t err = bufferFence->waitForever("RenderEngine::bindExternalTextureBuffer");
662 if (err != NO_ERROR) {
663 ALOGE("error waiting for fence: %d", err);
664 return err;
665 }
666 }
667 }
668
Alec Mouri539319f2018-12-19 17:56:23 -0800669 // We don't always want to persist to the cache, e.g. on older devices we
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000670 // might bind for synchronization purposes, but that might leak if we never
Alec Mouri539319f2018-12-19 17:56:23 -0800671 // call drawLayers again, so it's just better to recreate the image again
672 // if needed when we draw.
673 if (persistCache) {
674 mImageCache.insert(std::make_pair(buffer->getId(), std::move(newImage)));
675 }
676
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800677 return NO_ERROR;
678}
679
Alec Mouri539319f2018-12-19 17:56:23 -0800680void GLESRenderEngine::evictImages(const std::vector<LayerSettings>& layers) {
681 // destroy old image references that we're not going to draw with.
682 std::unordered_set<uint64_t> bufIds;
683 for (auto layer : layers) {
684 if (layer.source.buffer.buffer != nullptr) {
685 bufIds.emplace(layer.source.buffer.buffer->getId());
686 }
687 }
688
689 for (auto it = mImageCache.begin(); it != mImageCache.end();) {
690 if (bufIds.count(it->first) == 0) {
691 it = mImageCache.erase(it);
692 } else {
693 it++;
694 }
695 }
696}
697
Alec Mouri7c94edb2018-12-03 21:23:26 -0800698FloatRect GLESRenderEngine::setupLayerCropping(const LayerSettings& layer, Mesh& mesh) {
699 // Translate win by the rounded corners rect coordinates, to have all values in
700 // layer coordinate space.
701 FloatRect cropWin = layer.geometry.boundaries;
702 const FloatRect& roundedCornersCrop = layer.geometry.roundedCornersCrop;
703 cropWin.left -= roundedCornersCrop.left;
704 cropWin.right -= roundedCornersCrop.left;
705 cropWin.top -= roundedCornersCrop.top;
706 cropWin.bottom -= roundedCornersCrop.top;
707 Mesh::VertexArray<vec2> cropCoords(mesh.getCropCoordArray<vec2>());
708 cropCoords[0] = vec2(cropWin.left, cropWin.top);
709 cropCoords[1] = vec2(cropWin.left, cropWin.top + cropWin.getHeight());
710 cropCoords[2] = vec2(cropWin.right, cropWin.top + cropWin.getHeight());
711 cropCoords[3] = vec2(cropWin.right, cropWin.top);
712
713 setupCornerRadiusCropSize(roundedCornersCrop.getWidth(), roundedCornersCrop.getHeight());
714 return cropWin;
715}
716
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800717status_t GLESRenderEngine::bindFrameBuffer(Framebuffer* framebuffer) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000718 ATRACE_CALL();
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700719 GLFramebuffer* glFramebuffer = static_cast<GLFramebuffer*>(framebuffer);
720 EGLImageKHR eglImage = glFramebuffer->getEGLImage();
721 uint32_t textureName = glFramebuffer->getTextureName();
722 uint32_t framebufferName = glFramebuffer->getFramebufferName();
723
724 // Bind the texture and turn our EGLImage into a texture
725 glBindTexture(GL_TEXTURE_2D, textureName);
Peiyong Linfb530cf2018-12-15 05:07:38 +0000726 if (supportsProtectedContent()) {
727 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_PROTECTED_EXT,
728 mInProtectedContext ? GL_TRUE : GL_FALSE);
729 }
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700730 glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)eglImage);
731
732 // Bind the Framebuffer to render into
733 glBindFramebuffer(GL_FRAMEBUFFER, framebufferName);
Peiyong Lin46080ef2018-10-26 18:43:14 -0700734 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureName, 0);
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700735
Alec Mouri05483a02018-09-10 21:03:42 +0000736 mFboHeight = glFramebuffer->getBufferHeight();
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700737
738 uint32_t glStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
739
Peiyong Lin46080ef2018-10-26 18:43:14 -0700740 ALOGE_IF(glStatus != GL_FRAMEBUFFER_COMPLETE_OES, "glCheckFramebufferStatusOES error %d",
741 glStatus);
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700742
743 return glStatus == GL_FRAMEBUFFER_COMPLETE_OES ? NO_ERROR : BAD_VALUE;
744}
745
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800746void GLESRenderEngine::unbindFrameBuffer(Framebuffer* /* framebuffer */) {
Alec Mouri05483a02018-09-10 21:03:42 +0000747 mFboHeight = 0;
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700748
749 // back to main framebuffer
750 glBindFramebuffer(GL_FRAMEBUFFER, 0);
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700751}
752
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800753void GLESRenderEngine::checkErrors() const {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700754 do {
755 // there could be more than one error flag
756 GLenum error = glGetError();
757 if (error == GL_NO_ERROR) break;
758 ALOGE("GL error 0x%04x", int(error));
759 } while (true);
760}
761
Peiyong Linfb530cf2018-12-15 05:07:38 +0000762bool GLESRenderEngine::supportsProtectedContent() const {
763 return mProtectedEGLContext != EGL_NO_CONTEXT;
764}
765
766bool GLESRenderEngine::useProtectedContext(bool useProtectedContext) {
767 if (useProtectedContext == mInProtectedContext) {
768 return true;
769 }
770 if (useProtectedContext && mProtectedEGLContext == EGL_NO_CONTEXT) {
771 return false;
772 }
773 const EGLSurface surface = useProtectedContext ? mProtectedDummySurface : mDummySurface;
774 const EGLContext context = useProtectedContext ? mProtectedEGLContext : mEGLContext;
775 const bool success = eglMakeCurrent(mEGLDisplay, surface, surface, context) == EGL_TRUE;
776 if (success) {
777 mInProtectedContext = useProtectedContext;
778 }
779 return success;
780}
781
Alec Mouri1089aed2018-10-25 21:33:57 -0700782status_t GLESRenderEngine::drawLayers(const DisplaySettings& display,
783 const std::vector<LayerSettings>& layers,
784 ANativeWindowBuffer* const buffer,
785 base::unique_fd* drawFence) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000786 ATRACE_CALL();
Alec Mouri1089aed2018-10-25 21:33:57 -0700787 if (layers.empty()) {
788 ALOGV("Drawing empty layer stack");
789 return NO_ERROR;
790 }
791
792 BindNativeBufferAsFramebuffer fbo(*this, buffer);
793
794 if (fbo.getStatus() != NO_ERROR) {
795 ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",
796 buffer->handle);
797 checkErrors();
798 return fbo.getStatus();
799 }
800
Alec Mouri539319f2018-12-19 17:56:23 -0800801 evictImages(layers);
802
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000803 // clear the entire buffer, sometimes when we reuse buffers we'd persist
804 // ghost images otherwise.
805 // we also require a full transparent framebuffer for overlays. This is
806 // probably not quite efficient on all GPUs, since we could filter out
807 // opaque layers.
808 clearWithColor(0.0, 0.0, 0.0, 0.0);
809
Alec Mouri1089aed2018-10-25 21:33:57 -0700810 setViewportAndProjection(display.physicalDisplay, display.clip);
811
812 setOutputDataSpace(display.outputDataspace);
813 setDisplayMaxLuminance(display.maxLuminance);
814
815 mat4 projectionMatrix = mState.projectionMatrix * display.globalTransform;
Alec Mouriac335532018-11-12 15:01:33 -0800816 mState.projectionMatrix = projectionMatrix;
817 if (!display.clearRegion.isEmpty()) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000818 glDisable(GL_BLEND);
Alec Mouriac335532018-11-12 15:01:33 -0800819 fillRegionWithColor(display.clearRegion, 0.0, 0.0, 0.0, 1.0);
820 }
Alec Mouri1089aed2018-10-25 21:33:57 -0700821
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800822 Mesh mesh(Mesh::TRIANGLE_FAN, 4, 2, 2);
Alec Mouri1089aed2018-10-25 21:33:57 -0700823 for (auto layer : layers) {
Alec Mouri1089aed2018-10-25 21:33:57 -0700824 mState.projectionMatrix = projectionMatrix * layer.geometry.positionTransform;
825
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800826 const FloatRect bounds = layer.geometry.boundaries;
Alec Mouri1089aed2018-10-25 21:33:57 -0700827 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
828 position[0] = vec2(bounds.left, bounds.top);
829 position[1] = vec2(bounds.left, bounds.bottom);
830 position[2] = vec2(bounds.right, bounds.bottom);
831 position[3] = vec2(bounds.right, bounds.top);
832
Alec Mouri7c94edb2018-12-03 21:23:26 -0800833 setupLayerCropping(layer, mesh);
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800834 setColorTransform(display.colorTransform * layer.colorTransform);
835
836 bool usePremultipliedAlpha = true;
837 bool disableTexture = true;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000838 bool isOpaque = false;
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800839
840 if (layer.source.buffer.buffer != nullptr) {
841 disableTexture = false;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000842 isOpaque = layer.source.buffer.isOpaque;
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800843
844 sp<GraphicBuffer> gBuf = layer.source.buffer.buffer;
845
Alec Mouri539319f2018-12-19 17:56:23 -0800846 bool readCache = layer.source.buffer.cacheHint == Buffer::CachingHint::USE_CACHE;
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800847 bindExternalTextureBuffer(layer.source.buffer.textureName, gBuf,
Alec Mouri539319f2018-12-19 17:56:23 -0800848 layer.source.buffer.fence, readCache, /*persistCache=*/true);
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800849
850 usePremultipliedAlpha = layer.source.buffer.usePremultipliedAlpha;
851 Texture texture(Texture::TEXTURE_EXTERNAL, layer.source.buffer.textureName);
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000852 mat4 texMatrix = layer.source.buffer.textureTransform;
853
854 texture.setMatrix(texMatrix.asArray());
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800855 texture.setFiltering(layer.source.buffer.useTextureFiltering);
856
857 texture.setDimensions(gBuf->getWidth(), gBuf->getHeight());
858 setSourceY410BT2020(layer.source.buffer.isY410BT2020);
859
860 renderengine::Mesh::VertexArray<vec2> texCoords(mesh.getTexCoordArray<vec2>());
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000861 texCoords[0] = vec2(0.0, 0.0);
862 texCoords[1] = vec2(0.0, 1.0);
863 texCoords[2] = vec2(1.0, 1.0);
864 texCoords[3] = vec2(1.0, 0.0);
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800865 setupLayerTexturing(texture);
866 }
867
868 const half3 solidColor = layer.source.solidColor;
869 const half4 color = half4(solidColor.r, solidColor.g, solidColor.b, layer.alpha);
870 // Buffer sources will have a black solid color ignored in the shader,
871 // so in that scenario the solid color passed here is arbitrary.
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000872 setupLayerBlending(usePremultipliedAlpha, isOpaque, disableTexture, color,
873 layer.geometry.roundedCornersRadius);
874 if (layer.disableBlending) {
875 glDisable(GL_BLEND);
876 }
Alec Mouri1089aed2018-10-25 21:33:57 -0700877 setSourceDataSpace(layer.sourceDataspace);
878
879 drawMesh(mesh);
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800880
881 // Cleanup if there's a buffer source
882 if (layer.source.buffer.buffer != nullptr) {
883 disableBlending();
884 setSourceY410BT2020(false);
885 disableTexturing();
886 }
Alec Mouri1089aed2018-10-25 21:33:57 -0700887 }
888
889 *drawFence = flush();
890 // If flush failed or we don't support native fences, we need to force the
891 // gl command stream to be executed.
892 if (drawFence->get() < 0) {
893 bool success = finish();
894 if (!success) {
895 ALOGE("Failed to flush RenderEngine commands");
896 checkErrors();
897 // Chances are, something illegal happened (either the caller passed
898 // us bad parameters, or we messed up our shader generation).
899 return INVALID_OPERATION;
900 }
901 }
902
903 checkErrors();
Alec Mouri6e57f682018-09-29 20:45:08 -0700904 return NO_ERROR;
905}
906
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800907void GLESRenderEngine::setViewportAndProjection(size_t vpw, size_t vph, Rect sourceCrop,
908 ui::Transform::orientation_flags rotation) {
Alec Mouri1089aed2018-10-25 21:33:57 -0700909 setViewportAndProjection(Rect(vpw, vph), sourceCrop);
910
911 if (rotation == ui::Transform::ROT_0) {
912 return;
913 }
Mathias Agopian3f844832013-08-07 21:24:32 -0700914
Riley Andrewsc3ebe662014-09-04 16:20:31 -0700915 // Apply custom rotation to the projection.
916 float rot90InRadians = 2.0f * static_cast<float>(M_PI) / 4.0f;
Alec Mouri1089aed2018-10-25 21:33:57 -0700917 mat4 m = mState.projectionMatrix;
Riley Andrewsc3ebe662014-09-04 16:20:31 -0700918 switch (rotation) {
Peiyong Linefefaac2018-08-17 12:27:51 -0700919 case ui::Transform::ROT_90:
Chia-I Wub027f802017-11-29 14:00:52 -0800920 m = mat4::rotate(rot90InRadians, vec3(0, 0, 1)) * m;
Riley Andrewsc3ebe662014-09-04 16:20:31 -0700921 break;
Peiyong Linefefaac2018-08-17 12:27:51 -0700922 case ui::Transform::ROT_180:
Chia-I Wub027f802017-11-29 14:00:52 -0800923 m = mat4::rotate(rot90InRadians * 2.0f, vec3(0, 0, 1)) * m;
Riley Andrewsc3ebe662014-09-04 16:20:31 -0700924 break;
Peiyong Linefefaac2018-08-17 12:27:51 -0700925 case ui::Transform::ROT_270:
Chia-I Wub027f802017-11-29 14:00:52 -0800926 m = mat4::rotate(rot90InRadians * 3.0f, vec3(0, 0, 1)) * m;
Riley Andrewsc3ebe662014-09-04 16:20:31 -0700927 break;
928 default:
929 break;
930 }
Peiyong Lin70b26ce2018-09-18 19:02:39 -0700931 mState.projectionMatrix = m;
Alec Mouri1089aed2018-10-25 21:33:57 -0700932}
933
934void GLESRenderEngine::setViewportAndProjection(Rect viewport, Rect clip) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000935 ATRACE_CALL();
Alec Mouri1089aed2018-10-25 21:33:57 -0700936 mVpWidth = viewport.getWidth();
937 mVpHeight = viewport.getHeight();
938
939 // We pass the the top left corner instead of the bottom left corner,
940 // because since we're rendering off-screen first.
941 glViewport(viewport.left, viewport.top, mVpWidth, mVpHeight);
942
943 mState.projectionMatrix = mat4::ortho(clip.left, clip.right, clip.top, clip.bottom, 0, 1);
Mathias Agopian3f844832013-08-07 21:24:32 -0700944}
945
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800946void GLESRenderEngine::setupLayerBlending(bool premultipliedAlpha, bool opaque, bool disableTexture,
947 const half4& color, float cornerRadius) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -0700948 mState.isPremultipliedAlpha = premultipliedAlpha;
949 mState.isOpaque = opaque;
950 mState.color = color;
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700951 mState.cornerRadius = cornerRadius;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800952
chaviw13fdc492017-06-27 12:40:18 -0700953 if (disableTexture) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -0700954 mState.textureEnabled = false;
chaviw13fdc492017-06-27 12:40:18 -0700955 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000956
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700957 if (color.a < 1.0f || !opaque || cornerRadius > 0.0f) {
Mathias Agopian3f844832013-08-07 21:24:32 -0700958 glEnable(GL_BLEND);
959 glBlendFunc(premultipliedAlpha ? GL_ONE : GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
960 } else {
961 glDisable(GL_BLEND);
962 }
963}
964
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800965void GLESRenderEngine::setSourceY410BT2020(bool enable) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -0700966 mState.isY410BT2020 = enable;
Chia-I Wu131d3762018-01-11 14:35:27 -0800967}
968
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800969void GLESRenderEngine::setSourceDataSpace(Dataspace source) {
Chia-I Wu69bf10f2018-02-20 13:04:50 -0800970 mDataSpace = source;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600971}
972
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800973void GLESRenderEngine::setOutputDataSpace(Dataspace dataspace) {
Chia-I Wu69bf10f2018-02-20 13:04:50 -0800974 mOutputDataSpace = dataspace;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600975}
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600976
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800977void GLESRenderEngine::setDisplayMaxLuminance(const float maxLuminance) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -0700978 mState.displayMaxLuminance = maxLuminance;
Peiyong Linfb069302018-04-25 14:34:31 -0700979}
980
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800981void GLESRenderEngine::setupLayerTexturing(const Texture& texture) {
Mathias Agopian49457ac2013-08-14 18:20:17 -0700982 GLuint target = texture.getTextureTarget();
983 glBindTexture(target, texture.getTextureName());
Mathias Agopian3f844832013-08-07 21:24:32 -0700984 GLenum filter = GL_NEAREST;
Mathias Agopian49457ac2013-08-14 18:20:17 -0700985 if (texture.getFiltering()) {
Mathias Agopian3f844832013-08-07 21:24:32 -0700986 filter = GL_LINEAR;
987 }
Mathias Agopian49457ac2013-08-14 18:20:17 -0700988 glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
989 glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
990 glTexParameteri(target, GL_TEXTURE_MAG_FILTER, filter);
991 glTexParameteri(target, GL_TEXTURE_MIN_FILTER, filter);
Mathias Agopian3f844832013-08-07 21:24:32 -0700992
Peiyong Lin70b26ce2018-09-18 19:02:39 -0700993 mState.texture = texture;
994 mState.textureEnabled = true;
Mathias Agopian3f844832013-08-07 21:24:32 -0700995}
996
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800997void GLESRenderEngine::setupLayerBlackedOut() {
Mathias Agopian3f844832013-08-07 21:24:32 -0700998 glBindTexture(GL_TEXTURE_2D, mProtectedTexName);
Mathias Agopian49457ac2013-08-14 18:20:17 -0700999 Texture texture(Texture::TEXTURE_2D, mProtectedTexName);
1000 texture.setDimensions(1, 1); // FIXME: we should get that from somewhere
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001001 mState.texture = texture;
1002 mState.textureEnabled = true;
Mathias Agopian3f844832013-08-07 21:24:32 -07001003}
1004
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001005void GLESRenderEngine::setColorTransform(const mat4& colorTransform) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001006 mState.colorMatrix = colorTransform;
Dan Stozaf0087992014-10-20 15:46:09 -07001007}
1008
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001009void GLESRenderEngine::disableTexturing() {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001010 mState.textureEnabled = false;
Mathias Agopian3f844832013-08-07 21:24:32 -07001011}
1012
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001013void GLESRenderEngine::disableBlending() {
Mathias Agopian3f844832013-08-07 21:24:32 -07001014 glDisable(GL_BLEND);
1015}
1016
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001017void GLESRenderEngine::setupFillWithColor(float r, float g, float b, float a) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001018 mState.isPremultipliedAlpha = true;
1019 mState.isOpaque = false;
1020 mState.color = half4(r, g, b, a);
1021 mState.textureEnabled = false;
Mathias Agopian3f844832013-08-07 21:24:32 -07001022 glDisable(GL_BLEND);
Mathias Agopian3f844832013-08-07 21:24:32 -07001023}
1024
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001025void GLESRenderEngine::setupCornerRadiusCropSize(float width, float height) {
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001026 mState.cropSize = half2(width, height);
1027}
1028
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001029void GLESRenderEngine::drawMesh(const Mesh& mesh) {
Dan Stoza2713c302018-03-28 17:07:36 -07001030 ATRACE_CALL();
Mathias Agopian3f844832013-08-07 21:24:32 -07001031 if (mesh.getTexCoordsSize()) {
1032 glEnableVertexAttribArray(Program::texCoords);
Chia-I Wub027f802017-11-29 14:00:52 -08001033 glVertexAttribPointer(Program::texCoords, mesh.getTexCoordsSize(), GL_FLOAT, GL_FALSE,
1034 mesh.getByteStride(), mesh.getTexCoords());
Mathias Agopian3f844832013-08-07 21:24:32 -07001035 }
1036
Chia-I Wub027f802017-11-29 14:00:52 -08001037 glVertexAttribPointer(Program::position, mesh.getVertexSize(), GL_FLOAT, GL_FALSE,
1038 mesh.getByteStride(), mesh.getPositions());
Mathias Agopian3f844832013-08-07 21:24:32 -07001039
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001040 if (mState.cornerRadius > 0.0f) {
1041 glEnableVertexAttribArray(Program::cropCoords);
1042 glVertexAttribPointer(Program::cropCoords, mesh.getVertexSize(), GL_FLOAT, GL_FALSE,
1043 mesh.getByteStride(), mesh.getCropCoords());
1044 }
1045
Peiyong Lina296b0c2018-04-30 16:55:29 -07001046 // By default, DISPLAY_P3 is the only supported wide color output. However,
1047 // when HDR content is present, hardware composer may be able to handle
1048 // BT2020 data space, in that case, the output data space is set to be
1049 // BT2020_HLG or BT2020_PQ respectively. In GPU fall back we need
1050 // to respect this and convert non-HDR content to HDR format.
Peiyong Lin13effd12018-07-24 17:01:47 -07001051 if (mUseColorManagement) {
1052 Description managedState = mState;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001053 Dataspace inputStandard = static_cast<Dataspace>(mDataSpace & Dataspace::STANDARD_MASK);
1054 Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK);
Peiyong Lin46080ef2018-10-26 18:43:14 -07001055 Dataspace outputStandard =
1056 static_cast<Dataspace>(mOutputDataSpace & Dataspace::STANDARD_MASK);
1057 Dataspace outputTransfer =
1058 static_cast<Dataspace>(mOutputDataSpace & Dataspace::TRANSFER_MASK);
Peiyong Lina296b0c2018-04-30 16:55:29 -07001059 bool needsXYZConversion = needsXYZTransformMatrix();
1060
Valerie Haueb8e0762018-11-06 10:10:42 -08001061 // NOTE: if the input standard of the input dataspace is not STANDARD_DCI_P3 or
1062 // STANDARD_BT2020, it will be treated as STANDARD_BT709
1063 if (inputStandard != Dataspace::STANDARD_DCI_P3 &&
1064 inputStandard != Dataspace::STANDARD_BT2020) {
1065 inputStandard = Dataspace::STANDARD_BT709;
1066 }
1067
Peiyong Lina296b0c2018-04-30 16:55:29 -07001068 if (needsXYZConversion) {
1069 // The supported input color spaces are standard RGB, Display P3 and BT2020.
1070 switch (inputStandard) {
1071 case Dataspace::STANDARD_DCI_P3:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001072 managedState.inputTransformMatrix = mDisplayP3ToXyz;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001073 break;
1074 case Dataspace::STANDARD_BT2020:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001075 managedState.inputTransformMatrix = mBt2020ToXyz;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001076 break;
1077 default:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001078 managedState.inputTransformMatrix = mSrgbToXyz;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001079 break;
1080 }
1081
Peiyong Lin9b03c732018-05-17 10:14:02 -07001082 // The supported output color spaces are BT2020, Display P3 and standard RGB.
Peiyong Lina296b0c2018-04-30 16:55:29 -07001083 switch (outputStandard) {
1084 case Dataspace::STANDARD_BT2020:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001085 managedState.outputTransformMatrix = mXyzToBt2020;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001086 break;
Peiyong Lin9b03c732018-05-17 10:14:02 -07001087 case Dataspace::STANDARD_DCI_P3:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001088 managedState.outputTransformMatrix = mXyzToDisplayP3;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001089 break;
Peiyong Lin9b03c732018-05-17 10:14:02 -07001090 default:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001091 managedState.outputTransformMatrix = mXyzToSrgb;
Peiyong Lin9b03c732018-05-17 10:14:02 -07001092 break;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001093 }
1094 } else if (inputStandard != outputStandard) {
1095 // At this point, the input data space and output data space could be both
1096 // HDR data spaces, but they match each other, we do nothing in this case.
1097 // In addition to the case above, the input data space could be
1098 // - scRGB linear
1099 // - scRGB non-linear
1100 // - sRGB
1101 // - Display P3
Valerie Haueb8e0762018-11-06 10:10:42 -08001102 // - BT2020
Peiyong Lina296b0c2018-04-30 16:55:29 -07001103 // The output data spaces could be
1104 // - sRGB
1105 // - Display P3
Valerie Haueb8e0762018-11-06 10:10:42 -08001106 // - BT2020
1107 switch (outputStandard) {
1108 case Dataspace::STANDARD_BT2020:
1109 if (inputStandard == Dataspace::STANDARD_BT709) {
1110 managedState.outputTransformMatrix = mSrgbToBt2020;
1111 } else if (inputStandard == Dataspace::STANDARD_DCI_P3) {
1112 managedState.outputTransformMatrix = mDisplayP3ToBt2020;
1113 }
1114 break;
1115 case Dataspace::STANDARD_DCI_P3:
1116 if (inputStandard == Dataspace::STANDARD_BT709) {
1117 managedState.outputTransformMatrix = mSrgbToDisplayP3;
1118 } else if (inputStandard == Dataspace::STANDARD_BT2020) {
1119 managedState.outputTransformMatrix = mBt2020ToDisplayP3;
1120 }
1121 break;
1122 default:
1123 if (inputStandard == Dataspace::STANDARD_DCI_P3) {
1124 managedState.outputTransformMatrix = mDisplayP3ToSrgb;
1125 } else if (inputStandard == Dataspace::STANDARD_BT2020) {
1126 managedState.outputTransformMatrix = mBt2020ToSrgb;
1127 }
1128 break;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001129 }
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001130 }
Peiyong Lina296b0c2018-04-30 16:55:29 -07001131
1132 // we need to convert the RGB value to linear space and convert it back when:
1133 // - there is a color matrix that is not an identity matrix, or
1134 // - there is an output transform matrix that is not an identity matrix, or
1135 // - the input transfer function doesn't match the output transfer function.
Peiyong Lin13effd12018-07-24 17:01:47 -07001136 if (managedState.hasColorMatrix() || managedState.hasOutputTransformMatrix() ||
Chia-I Wud49d6692018-06-27 07:17:41 +08001137 inputTransfer != outputTransfer) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001138 managedState.inputTransferFunction =
Peiyong Lin46080ef2018-10-26 18:43:14 -07001139 Description::dataSpaceToTransferFunction(inputTransfer);
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001140 managedState.outputTransferFunction =
Peiyong Lin46080ef2018-10-26 18:43:14 -07001141 Description::dataSpaceToTransferFunction(outputTransfer);
Peiyong Lina296b0c2018-04-30 16:55:29 -07001142 }
1143
Peiyong Linfb530cf2018-12-15 05:07:38 +00001144 ProgramCache::getInstance().useProgram(mInProtectedContext ? mProtectedEGLContext
1145 : mEGLContext,
1146 managedState);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001147
1148 glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());
1149
1150 if (outputDebugPPMs) {
Peiyong Lin13effd12018-07-24 17:01:47 -07001151 static uint64_t managedColorFrameCount = 0;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001152 std::ostringstream out;
Peiyong Lin13effd12018-07-24 17:01:47 -07001153 out << "/data/texture_out" << managedColorFrameCount++;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001154 writePPM(out.str().c_str(), mVpWidth, mVpHeight);
1155 }
1156 } else {
Peiyong Linfb530cf2018-12-15 05:07:38 +00001157 ProgramCache::getInstance().useProgram(mInProtectedContext ? mProtectedEGLContext
1158 : mEGLContext,
1159 mState);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001160
1161 glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());
1162 }
Mathias Agopian3f844832013-08-07 21:24:32 -07001163
1164 if (mesh.getTexCoordsSize()) {
1165 glDisableVertexAttribArray(Program::texCoords);
1166 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001167
1168 if (mState.cornerRadius > 0.0f) {
1169 glDisableVertexAttribArray(Program::cropCoords);
1170 }
Mathias Agopian3f844832013-08-07 21:24:32 -07001171}
1172
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001173size_t GLESRenderEngine::getMaxTextureSize() const {
Peiyong Linf1bada92018-08-29 09:39:31 -07001174 return mMaxTextureSize;
1175}
1176
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001177size_t GLESRenderEngine::getMaxViewportDims() const {
Peiyong Linf1bada92018-08-29 09:39:31 -07001178 return mMaxViewportDims[0] < mMaxViewportDims[1] ? mMaxViewportDims[0] : mMaxViewportDims[1];
1179}
1180
Yiwei Zhang5434a782018-12-05 18:06:32 -08001181void GLESRenderEngine::dump(std::string& result) {
Peiyong Linf11f39b2018-09-05 14:37:41 -07001182 const GLExtensions& extensions = GLExtensions::getInstance();
Peiyong Linfb530cf2018-12-15 05:07:38 +00001183 ProgramCache& cache = ProgramCache::getInstance();
Peiyong Linf11f39b2018-09-05 14:37:41 -07001184
Yiwei Zhang5434a782018-12-05 18:06:32 -08001185 StringAppendF(&result, "EGL implementation : %s\n", extensions.getEGLVersion());
1186 StringAppendF(&result, "%s\n", extensions.getEGLExtensions());
Yiwei Zhang5434a782018-12-05 18:06:32 -08001187 StringAppendF(&result, "GLES: %s, %s, %s\n", extensions.getVendor(), extensions.getRenderer(),
1188 extensions.getVersion());
1189 StringAppendF(&result, "%s\n", extensions.getExtensions());
Peiyong Linfb530cf2018-12-15 05:07:38 +00001190 StringAppendF(&result, "RenderEngine is in protected context : %d\n", mInProtectedContext);
1191 StringAppendF(&result, "RenderEngine program cache size for unprotected context: %zu\n",
1192 cache.getSize(mEGLContext));
1193 StringAppendF(&result, "RenderEngine program cache size for protected context: %zu\n",
1194 cache.getSize(mProtectedEGLContext));
Yiwei Zhang5434a782018-12-05 18:06:32 -08001195 StringAppendF(&result, "RenderEngine last dataspace conversion: (%s) to (%s)\n",
1196 dataspaceDetails(static_cast<android_dataspace>(mDataSpace)).c_str(),
1197 dataspaceDetails(static_cast<android_dataspace>(mOutputDataSpace)).c_str());
Mathias Agopian3f844832013-08-07 21:24:32 -07001198}
1199
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001200GLESRenderEngine::GlesVersion GLESRenderEngine::parseGlesVersion(const char* str) {
Peiyong Linf11f39b2018-09-05 14:37:41 -07001201 int major, minor;
1202 if (sscanf(str, "OpenGL ES-CM %d.%d", &major, &minor) != 2) {
1203 if (sscanf(str, "OpenGL ES %d.%d", &major, &minor) != 2) {
1204 ALOGW("Unable to parse GL_VERSION string: \"%s\"", str);
1205 return GLES_VERSION_1_0;
1206 }
1207 }
1208
1209 if (major == 1 && minor == 0) return GLES_VERSION_1_0;
1210 if (major == 1 && minor >= 1) return GLES_VERSION_1_1;
1211 if (major == 2 && minor >= 0) return GLES_VERSION_2_0;
1212 if (major == 3 && minor >= 0) return GLES_VERSION_3_0;
1213
1214 ALOGW("Unrecognized OpenGL ES version: %d.%d", major, minor);
1215 return GLES_VERSION_1_0;
1216}
1217
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001218EGLContext GLESRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,
Peiyong Linfb530cf2018-12-15 05:07:38 +00001219 EGLContext shareContext, bool useContextPriority,
1220 Protection protection) {
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001221 EGLint renderableType = 0;
1222 if (config == EGL_NO_CONFIG) {
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001223 renderableType = EGL_OPENGL_ES3_BIT;
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001224 } else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) {
1225 LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");
1226 }
1227 EGLint contextClientVersion = 0;
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001228 if (renderableType & EGL_OPENGL_ES3_BIT) {
1229 contextClientVersion = 3;
1230 } else if (renderableType & EGL_OPENGL_ES2_BIT) {
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001231 contextClientVersion = 2;
1232 } else if (renderableType & EGL_OPENGL_ES_BIT) {
1233 contextClientVersion = 1;
1234 } else {
1235 LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs");
1236 }
1237
1238 std::vector<EGLint> contextAttributes;
Peiyong Linfb530cf2018-12-15 05:07:38 +00001239 contextAttributes.reserve(7);
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001240 contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
1241 contextAttributes.push_back(contextClientVersion);
1242 if (useContextPriority) {
1243 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG);
1244 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG);
1245 }
Peiyong Linfb530cf2018-12-15 05:07:38 +00001246 if (protection == Protection::PROTECTED) {
1247 contextAttributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1248 contextAttributes.push_back(EGL_TRUE);
1249 }
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001250 contextAttributes.push_back(EGL_NONE);
1251
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001252 EGLContext context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1253
1254 if (contextClientVersion == 3 && context == EGL_NO_CONTEXT) {
1255 // eglGetConfigAttrib indicated we can create GLES 3 context, but we failed, thus
1256 // EGL_NO_CONTEXT so that we can abort.
1257 if (config != EGL_NO_CONFIG) {
1258 return context;
1259 }
1260 // If |config| is EGL_NO_CONFIG, we speculatively try to create GLES 3 context, so we should
1261 // try to fall back to GLES 2.
1262 contextAttributes[1] = 2;
1263 context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1264 }
1265
1266 return context;
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001267}
1268
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001269EGLSurface GLESRenderEngine::createDummyEglPbufferSurface(EGLDisplay display, EGLConfig config,
Peiyong Linfb530cf2018-12-15 05:07:38 +00001270 int hwcFormat, Protection protection) {
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001271 EGLConfig dummyConfig = config;
1272 if (dummyConfig == EGL_NO_CONFIG) {
1273 dummyConfig = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);
1274 }
1275 std::vector<EGLint> attributes;
Peiyong Linfb530cf2018-12-15 05:07:38 +00001276 attributes.reserve(7);
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001277 attributes.push_back(EGL_WIDTH);
1278 attributes.push_back(1);
1279 attributes.push_back(EGL_HEIGHT);
1280 attributes.push_back(1);
Peiyong Linfb530cf2018-12-15 05:07:38 +00001281 if (protection == Protection::PROTECTED) {
1282 attributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1283 attributes.push_back(EGL_TRUE);
1284 }
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001285 attributes.push_back(EGL_NONE);
1286
1287 return eglCreatePbufferSurface(display, dummyConfig, attributes.data());
1288}
1289
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001290bool GLESRenderEngine::isHdrDataSpace(const Dataspace dataSpace) const {
Peiyong Lina296b0c2018-04-30 16:55:29 -07001291 const Dataspace standard = static_cast<Dataspace>(dataSpace & Dataspace::STANDARD_MASK);
1292 const Dataspace transfer = static_cast<Dataspace>(dataSpace & Dataspace::TRANSFER_MASK);
1293 return standard == Dataspace::STANDARD_BT2020 &&
Peiyong Lin46080ef2018-10-26 18:43:14 -07001294 (transfer == Dataspace::TRANSFER_ST2084 || transfer == Dataspace::TRANSFER_HLG);
Peiyong Lina296b0c2018-04-30 16:55:29 -07001295}
1296
1297// For convenience, we want to convert the input color space to XYZ color space first,
1298// and then convert from XYZ color space to output color space when
1299// - SDR and HDR contents are mixed, either SDR content will be converted to HDR or
1300// HDR content will be tone-mapped to SDR; Or,
1301// - there are HDR PQ and HLG contents presented at the same time, where we want to convert
1302// HLG content to PQ content.
1303// In either case above, we need to operate the Y value in XYZ color space. Thus, when either
1304// input data space or output data space is HDR data space, and the input transfer function
1305// doesn't match the output transfer function, we would enable an intermediate transfrom to
1306// XYZ color space.
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001307bool GLESRenderEngine::needsXYZTransformMatrix() const {
Peiyong Lina296b0c2018-04-30 16:55:29 -07001308 const bool isInputHdrDataSpace = isHdrDataSpace(mDataSpace);
1309 const bool isOutputHdrDataSpace = isHdrDataSpace(mOutputDataSpace);
1310 const Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK);
Peiyong Lin46080ef2018-10-26 18:43:14 -07001311 const Dataspace outputTransfer =
1312 static_cast<Dataspace>(mOutputDataSpace & Dataspace::TRANSFER_MASK);
Peiyong Lina296b0c2018-04-30 16:55:29 -07001313
1314 return (isInputHdrDataSpace || isOutputHdrDataSpace) && inputTransfer != outputTransfer;
1315}
1316
Alec Mouri554d06e2018-12-20 00:15:33 -08001317// FlushTracer implementation
1318GLESRenderEngine::FlushTracer::FlushTracer(GLESRenderEngine* engine) : mEngine(engine) {
1319 mThread = std::thread(&GLESRenderEngine::FlushTracer::loop, this);
1320}
1321
1322GLESRenderEngine::FlushTracer::~FlushTracer() {
1323 {
1324 std::lock_guard<std::mutex> lock(mMutex);
1325 mRunning = false;
1326 }
1327 mCondition.notify_all();
1328 if (mThread.joinable()) {
1329 mThread.join();
1330 }
1331}
1332
1333void GLESRenderEngine::FlushTracer::queueSync(EGLSyncKHR sync) {
1334 std::lock_guard<std::mutex> lock(mMutex);
1335 char name[64];
1336 const uint64_t frameNum = mFramesQueued++;
1337 snprintf(name, sizeof(name), "Queueing sync for frame: %lu",
1338 static_cast<unsigned long>(frameNum));
1339 ATRACE_NAME(name);
1340 mQueue.push({sync, frameNum});
1341 ATRACE_INT("GPU Frames Outstanding", mQueue.size());
1342 mCondition.notify_one();
1343}
1344
1345void GLESRenderEngine::FlushTracer::loop() {
1346 while (mRunning) {
1347 QueueEntry entry;
1348 {
1349 std::lock_guard<std::mutex> lock(mMutex);
1350
1351 mCondition.wait(mMutex,
Alec Mouric15dd012019-01-15 15:30:38 -08001352 [&]() REQUIRES(mMutex) { return !mQueue.empty() || !mRunning; });
Alec Mouri554d06e2018-12-20 00:15:33 -08001353
1354 if (!mRunning) {
1355 // if mRunning is false, then FlushTracer is being destroyed, so
1356 // bail out now.
1357 break;
1358 }
1359 entry = mQueue.front();
1360 mQueue.pop();
1361 }
1362 {
1363 char name[64];
1364 snprintf(name, sizeof(name), "waiting for frame %lu",
1365 static_cast<unsigned long>(entry.mFrameNum));
1366 ATRACE_NAME(name);
1367 mEngine->waitSync(entry.mSync, 0);
1368 }
1369 }
1370}
1371
Peiyong Lin46080ef2018-10-26 18:43:14 -07001372} // namespace gl
1373} // namespace renderengine
1374} // namespace android