blob: d0127b81782ab74390534a70c895521bff478c87 [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>
Alec Mourida4cf3b2019-02-12 15:33:01 -080040#include <ui/GraphicBuffer.h>
Dan Stozac1879002014-05-22 15:59:05 -070041#include <ui/Rect.h>
Peiyong Lin60bedb52018-09-05 10:47:31 -070042#include <ui/Region.h>
Chia-I Wu56d7b0a2018-10-01 15:13:11 -070043#include <utils/KeyedVector.h>
Mathias Agopian3f844832013-08-07 21:24:32 -070044#include <utils/Trace.h>
Peiyong Linf1bada92018-08-29 09:39:31 -070045#include "GLExtensions.h"
Peiyong Line5a9a7f2018-08-30 15:32:13 -070046#include "GLFramebuffer.h"
Peiyong Linf1bada92018-08-29 09:39:31 -070047#include "GLImage.h"
Peiyong Lin833074a2018-08-28 11:53:54 -070048#include "Program.h"
49#include "ProgramCache.h"
Mathias Agopian3f844832013-08-07 21:24:32 -070050
Peiyong Linf11f39b2018-09-05 14:37:41 -070051extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
52
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -060053bool checkGlError(const char* op, int lineNumber) {
54 bool errorFound = false;
55 GLint error = glGetError();
56 while (error != GL_NO_ERROR) {
57 errorFound = true;
58 error = glGetError();
59 ALOGV("after %s() (line # %d) glError (0x%x)\n", op, lineNumber, error);
60 }
61 return errorFound;
62}
63
Courtney Goeltzenleuchter4f20f9c2017-04-06 08:18:34 -060064static constexpr bool outputDebugPPMs = false;
65
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -060066void writePPM(const char* basename, GLuint width, GLuint height) {
67 ALOGV("writePPM #%s: %d x %d", basename, width, height);
68
69 std::vector<GLubyte> pixels(width * height * 4);
70 std::vector<GLubyte> outBuffer(width * height * 3);
71
72 // TODO(courtneygo): We can now have float formats, need
73 // to remove this code or update to support.
74 // Make returned pixels fit in uint32_t, one byte per component
75 glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
76 if (checkGlError(__FUNCTION__, __LINE__)) {
77 return;
78 }
79
80 std::string filename(basename);
81 filename.append(".ppm");
82 std::ofstream file(filename.c_str(), std::ios::binary);
83 if (!file.is_open()) {
84 ALOGE("Unable to open file: %s", filename.c_str());
85 ALOGE("You may need to do: \"adb shell setenforce 0\" to enable "
86 "surfaceflinger to write debug images");
87 return;
88 }
89
90 file << "P6\n";
91 file << width << "\n";
92 file << height << "\n";
93 file << 255 << "\n";
94
95 auto ptr = reinterpret_cast<char*>(pixels.data());
96 auto outPtr = reinterpret_cast<char*>(outBuffer.data());
97 for (int y = height - 1; y >= 0; y--) {
98 char* data = ptr + y * width * sizeof(uint32_t);
99
100 for (GLuint x = 0; x < width; x++) {
101 // Only copy R, G and B components
102 outPtr[0] = data[0];
103 outPtr[1] = data[1];
104 outPtr[2] = data[2];
105 data += sizeof(uint32_t);
106 outPtr += 3;
107 }
108 }
109 file.write(reinterpret_cast<char*>(outBuffer.data()), outBuffer.size());
110}
111
Mathias Agopian3f844832013-08-07 21:24:32 -0700112namespace android {
Peiyong Lin833074a2018-08-28 11:53:54 -0700113namespace renderengine {
114namespace gl {
Mathias Agopian3f844832013-08-07 21:24:32 -0700115
Yiwei Zhang5434a782018-12-05 18:06:32 -0800116using base::StringAppendF;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700117using ui::Dataspace;
118
Peiyong Linf11f39b2018-09-05 14:37:41 -0700119static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs, EGLint attribute,
120 EGLint wanted, EGLConfig* outConfig) {
121 EGLint numConfigs = -1, n = 0;
122 eglGetConfigs(dpy, nullptr, 0, &numConfigs);
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700123 std::vector<EGLConfig> configs(numConfigs, EGL_NO_CONFIG_KHR);
124 eglChooseConfig(dpy, attrs, configs.data(), configs.size(), &n);
125 configs.resize(n);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700126
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700127 if (!configs.empty()) {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700128 if (attribute != EGL_NONE) {
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700129 for (EGLConfig config : configs) {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700130 EGLint value = 0;
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700131 eglGetConfigAttrib(dpy, config, attribute, &value);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700132 if (wanted == value) {
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700133 *outConfig = config;
Peiyong Linf11f39b2018-09-05 14:37:41 -0700134 return NO_ERROR;
135 }
136 }
137 } else {
138 // just pick the first one
139 *outConfig = configs[0];
Peiyong Linf11f39b2018-09-05 14:37:41 -0700140 return NO_ERROR;
141 }
142 }
Chia-I Wud3b13cb2018-09-13 13:31:26 -0700143
Peiyong Linf11f39b2018-09-05 14:37:41 -0700144 return NAME_NOT_FOUND;
145}
146
147class EGLAttributeVector {
148 struct Attribute;
149 class Adder;
150 friend class Adder;
151 KeyedVector<Attribute, EGLint> mList;
152 struct Attribute {
153 Attribute() : v(0){};
154 explicit Attribute(EGLint v) : v(v) {}
155 EGLint v;
156 bool operator<(const Attribute& other) const {
157 // this places EGL_NONE at the end
158 EGLint lhs(v);
159 EGLint rhs(other.v);
160 if (lhs == EGL_NONE) lhs = 0x7FFFFFFF;
161 if (rhs == EGL_NONE) rhs = 0x7FFFFFFF;
162 return lhs < rhs;
163 }
164 };
165 class Adder {
166 friend class EGLAttributeVector;
167 EGLAttributeVector& v;
168 EGLint attribute;
169 Adder(EGLAttributeVector& v, EGLint attribute) : v(v), attribute(attribute) {}
170
171 public:
172 void operator=(EGLint value) {
173 if (attribute != EGL_NONE) {
174 v.mList.add(Attribute(attribute), value);
175 }
176 }
177 operator EGLint() const { return v.mList[attribute]; }
178 };
179
180public:
181 EGLAttributeVector() { mList.add(Attribute(EGL_NONE), EGL_NONE); }
182 void remove(EGLint attribute) {
183 if (attribute != EGL_NONE) {
184 mList.removeItem(Attribute(attribute));
185 }
186 }
187 Adder operator[](EGLint attribute) { return Adder(*this, attribute); }
188 EGLint operator[](EGLint attribute) const { return mList[attribute]; }
189 // cast-operator to (EGLint const*)
190 operator EGLint const*() const { return &mList.keyAt(0).v; }
191};
192
193static status_t selectEGLConfig(EGLDisplay display, EGLint format, EGLint renderableType,
194 EGLConfig* config) {
195 // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if
196 // it is to be used with WIFI displays
197 status_t err;
198 EGLint wantedAttribute;
199 EGLint wantedAttributeValue;
200
201 EGLAttributeVector attribs;
202 if (renderableType) {
203 attribs[EGL_RENDERABLE_TYPE] = renderableType;
204 attribs[EGL_RECORDABLE_ANDROID] = EGL_TRUE;
205 attribs[EGL_SURFACE_TYPE] = EGL_WINDOW_BIT | EGL_PBUFFER_BIT;
206 attribs[EGL_FRAMEBUFFER_TARGET_ANDROID] = EGL_TRUE;
207 attribs[EGL_RED_SIZE] = 8;
208 attribs[EGL_GREEN_SIZE] = 8;
209 attribs[EGL_BLUE_SIZE] = 8;
210 attribs[EGL_ALPHA_SIZE] = 8;
211 wantedAttribute = EGL_NONE;
212 wantedAttributeValue = EGL_NONE;
213 } else {
214 // if no renderable type specified, fallback to a simplified query
215 wantedAttribute = EGL_NATIVE_VISUAL_ID;
216 wantedAttributeValue = format;
217 }
218
219 err = selectConfigForAttribute(display, attribs, wantedAttribute, wantedAttributeValue, config);
220 if (err == NO_ERROR) {
221 EGLint caveat;
222 if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat))
223 ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!");
224 }
225
226 return err;
227}
228
Alec Mourida4cf3b2019-02-12 15:33:01 -0800229std::unique_ptr<GLESRenderEngine> GLESRenderEngine::create(int hwcFormat, uint32_t featureFlags,
230 uint32_t imageCacheSize) {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700231 // initialize EGL for the default display
232 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
233 if (!eglInitialize(display, nullptr, nullptr)) {
234 LOG_ALWAYS_FATAL("failed to initialize EGL");
235 }
236
237 GLExtensions& extensions = GLExtensions::getInstance();
238 extensions.initWithEGLStrings(eglQueryStringImplementationANDROID(display, EGL_VERSION),
239 eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS));
240
241 // The code assumes that ES2 or later is available if this extension is
242 // supported.
243 EGLConfig config = EGL_NO_CONFIG;
244 if (!extensions.hasNoConfigContext()) {
245 config = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);
246 }
247
Peiyong Linf11f39b2018-09-05 14:37:41 -0700248 bool useContextPriority = extensions.hasContextPriority() &&
Peiyong Lin46080ef2018-10-26 18:43:14 -0700249 (featureFlags & RenderEngine::USE_HIGH_PRIORITY_CONTEXT);
Peiyong Linfb530cf2018-12-15 05:07:38 +0000250 EGLContext protectedContext = EGL_NO_CONTEXT;
251 if (extensions.hasProtectedContent()) {
252 protectedContext = createEglContext(display, config, nullptr, useContextPriority,
253 Protection::PROTECTED);
254 ALOGE_IF(protectedContext == EGL_NO_CONTEXT, "Can't create protected context");
255 }
256
257 EGLContext ctxt = createEglContext(display, config, protectedContext, useContextPriority,
258 Protection::UNPROTECTED);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700259
260 // if can't create a GL context, we can only abort.
261 LOG_ALWAYS_FATAL_IF(ctxt == EGL_NO_CONTEXT, "EGLContext creation failed");
262
Peiyong Lina5e9f1b2018-11-27 22:49:37 -0800263 EGLSurface dummy = EGL_NO_SURFACE;
264 if (!extensions.hasSurfacelessContext()) {
Peiyong Linfb530cf2018-12-15 05:07:38 +0000265 dummy = createDummyEglPbufferSurface(display, config, hwcFormat, Protection::UNPROTECTED);
Peiyong Lina5e9f1b2018-11-27 22:49:37 -0800266 LOG_ALWAYS_FATAL_IF(dummy == EGL_NO_SURFACE, "can't create dummy pbuffer");
Peiyong Linf11f39b2018-09-05 14:37:41 -0700267 }
Peiyong Linf11f39b2018-09-05 14:37:41 -0700268 EGLBoolean success = eglMakeCurrent(display, dummy, dummy, ctxt);
269 LOG_ALWAYS_FATAL_IF(!success, "can't make dummy pbuffer current");
Peiyong Linf11f39b2018-09-05 14:37:41 -0700270 extensions.initWithGLStrings(glGetString(GL_VENDOR), glGetString(GL_RENDERER),
271 glGetString(GL_VERSION), glGetString(GL_EXTENSIONS));
272
Peiyong Linfb530cf2018-12-15 05:07:38 +0000273 // In order to have protected contents in GPU composition, the OpenGL ES extension
274 // GL_EXT_protected_textures must be supported. If it's not supported, reset
275 // protected context to EGL_NO_CONTEXT to indicate that protected contents is not supported.
276 if (!extensions.hasProtectedTexture()) {
277 protectedContext = EGL_NO_CONTEXT;
278 }
279
280 EGLSurface protectedDummy = EGL_NO_SURFACE;
281 if (protectedContext != EGL_NO_CONTEXT && !extensions.hasSurfacelessContext()) {
282 protectedDummy =
283 createDummyEglPbufferSurface(display, config, hwcFormat, Protection::PROTECTED);
284 ALOGE_IF(protectedDummy == EGL_NO_SURFACE, "can't create protected dummy pbuffer");
285 }
286
Peiyong Lina5e9f1b2018-11-27 22:49:37 -0800287 // now figure out what version of GL did we actually get
Peiyong Linf11f39b2018-09-05 14:37:41 -0700288 GlesVersion version = parseGlesVersion(extensions.getVersion());
289
290 // initialize the renderer while GL is current
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800291 std::unique_ptr<GLESRenderEngine> engine;
Peiyong Linf11f39b2018-09-05 14:37:41 -0700292 switch (version) {
293 case GLES_VERSION_1_0:
294 case GLES_VERSION_1_1:
295 LOG_ALWAYS_FATAL("SurfaceFlinger requires OpenGL ES 2.0 minimum to run.");
296 break;
297 case GLES_VERSION_2_0:
298 case GLES_VERSION_3_0:
Peiyong Linfb530cf2018-12-15 05:07:38 +0000299 engine = std::make_unique<GLESRenderEngine>(featureFlags, display, config, ctxt, dummy,
Alec Mourida4cf3b2019-02-12 15:33:01 -0800300 protectedContext, protectedDummy,
301 imageCacheSize);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700302 break;
303 }
Peiyong Linf11f39b2018-09-05 14:37:41 -0700304
305 ALOGI("OpenGL ES informations:");
306 ALOGI("vendor : %s", extensions.getVendor());
307 ALOGI("renderer : %s", extensions.getRenderer());
308 ALOGI("version : %s", extensions.getVersion());
309 ALOGI("extensions: %s", extensions.getExtensions());
310 ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize());
311 ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims());
312
Peiyong Linf11f39b2018-09-05 14:37:41 -0700313 return engine;
314}
315
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800316EGLConfig GLESRenderEngine::chooseEglConfig(EGLDisplay display, int format, bool logConfig) {
Peiyong Linf11f39b2018-09-05 14:37:41 -0700317 status_t err;
318 EGLConfig config;
319
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800320 // First try to get an ES3 config
321 err = selectEGLConfig(display, format, EGL_OPENGL_ES3_BIT, &config);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700322 if (err != NO_ERROR) {
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800323 // If ES3 fails, try to get an ES2 config
324 err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700325 if (err != NO_ERROR) {
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800326 // If ES2 still doesn't work, probably because we're on the emulator.
Peiyong Linf11f39b2018-09-05 14:37:41 -0700327 // try a simplified query
328 ALOGW("no suitable EGLConfig found, trying a simpler query");
329 err = selectEGLConfig(display, format, 0, &config);
330 if (err != NO_ERROR) {
331 // this EGL is too lame for android
332 LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up");
333 }
334 }
335 }
336
337 if (logConfig) {
338 // print some debugging info
339 EGLint r, g, b, a;
340 eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r);
341 eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
342 eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);
343 eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);
344 ALOGI("EGL information:");
345 ALOGI("vendor : %s", eglQueryString(display, EGL_VENDOR));
346 ALOGI("version : %s", eglQueryString(display, EGL_VERSION));
347 ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS));
348 ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS) ?: "Not Supported");
349 ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);
350 }
351
352 return config;
353}
354
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800355GLESRenderEngine::GLESRenderEngine(uint32_t featureFlags, EGLDisplay display, EGLConfig config,
Peiyong Linfb530cf2018-12-15 05:07:38 +0000356 EGLContext ctxt, EGLSurface dummy, EGLContext protectedContext,
Alec Mourida4cf3b2019-02-12 15:33:01 -0800357 EGLSurface protectedDummy, uint32_t imageCacheSize)
Peiyong Linf11f39b2018-09-05 14:37:41 -0700358 : renderengine::impl::RenderEngine(featureFlags),
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800359 mEGLDisplay(display),
360 mEGLConfig(config),
361 mEGLContext(ctxt),
362 mDummySurface(dummy),
Peiyong Linfb530cf2018-12-15 05:07:38 +0000363 mProtectedEGLContext(protectedContext),
364 mProtectedDummySurface(protectedDummy),
Chia-I Wu93e14df2018-06-04 10:10:17 -0700365 mVpWidth(0),
366 mVpHeight(0),
Alec Mourida4cf3b2019-02-12 15:33:01 -0800367 mFramebufferImageCacheSize(imageCacheSize),
Peiyong Lin13effd12018-07-24 17:01:47 -0700368 mUseColorManagement(featureFlags & USE_COLOR_MANAGEMENT) {
Mathias Agopian3f844832013-08-07 21:24:32 -0700369 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
370 glGetIntegerv(GL_MAX_VIEWPORT_DIMS, mMaxViewportDims);
371
372 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
373 glPixelStorei(GL_PACK_ALIGNMENT, 4);
374
Peiyong Linfb530cf2018-12-15 05:07:38 +0000375 // Initialize protected EGL Context.
376 if (mProtectedEGLContext != EGL_NO_CONTEXT) {
377 EGLBoolean success = eglMakeCurrent(display, mProtectedDummySurface, mProtectedDummySurface,
378 mProtectedEGLContext);
379 ALOGE_IF(!success, "can't make protected context current");
380 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
381 glPixelStorei(GL_PACK_ALIGNMENT, 4);
382 success = eglMakeCurrent(display, mDummySurface, mDummySurface, mEGLContext);
383 LOG_ALWAYS_FATAL_IF(!success, "can't make default context current");
384 }
385
Chia-I Wub027f802017-11-29 14:00:52 -0800386 const uint16_t protTexData[] = {0};
Mathias Agopian3f844832013-08-07 21:24:32 -0700387 glGenTextures(1, &mProtectedTexName);
388 glBindTexture(GL_TEXTURE_2D, mProtectedTexName);
389 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
390 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
391 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
392 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
Chia-I Wub027f802017-11-29 14:00:52 -0800393 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 -0700394
Chia-I Wub027f802017-11-29 14:00:52 -0800395 // mColorBlindnessCorrection = M;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600396
Peiyong Lin13effd12018-07-24 17:01:47 -0700397 if (mUseColorManagement) {
Valerie Haueb8e0762018-11-06 10:10:42 -0800398 const ColorSpace srgb(ColorSpace::sRGB());
399 const ColorSpace displayP3(ColorSpace::DisplayP3());
400 const ColorSpace bt2020(ColorSpace::BT2020());
Peiyong Lina296b0c2018-04-30 16:55:29 -0700401
402 // no chromatic adaptation needed since all color spaces use D65 for their white points.
Peiyong Lin70b26ce2018-09-18 19:02:39 -0700403 mSrgbToXyz = mat4(srgb.getRGBtoXYZ());
404 mDisplayP3ToXyz = mat4(displayP3.getRGBtoXYZ());
405 mBt2020ToXyz = mat4(bt2020.getRGBtoXYZ());
Peiyong Lin9b03c732018-05-17 10:14:02 -0700406 mXyzToSrgb = mat4(srgb.getXYZtoRGB());
Peiyong Lina296b0c2018-04-30 16:55:29 -0700407 mXyzToDisplayP3 = mat4(displayP3.getXYZtoRGB());
408 mXyzToBt2020 = mat4(bt2020.getXYZtoRGB());
Valerie Haueb8e0762018-11-06 10:10:42 -0800409
410 // Compute sRGB to Display P3 and BT2020 transform matrix.
411 // NOTE: For now, we are limiting output wide color space support to
412 // Display-P3 and BT2020 only.
413 mSrgbToDisplayP3 = mXyzToDisplayP3 * mSrgbToXyz;
414 mSrgbToBt2020 = mXyzToBt2020 * mSrgbToXyz;
415
416 // Compute Display P3 to sRGB and BT2020 transform matrix.
417 mDisplayP3ToSrgb = mXyzToSrgb * mDisplayP3ToXyz;
418 mDisplayP3ToBt2020 = mXyzToBt2020 * mDisplayP3ToXyz;
419
420 // Compute BT2020 to sRGB and Display P3 transform matrix
421 mBt2020ToSrgb = mXyzToSrgb * mBt2020ToXyz;
422 mBt2020ToDisplayP3 = mXyzToDisplayP3 * mBt2020ToXyz;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600423 }
Alec Mouri554d06e2018-12-20 00:15:33 -0800424
425 char value[PROPERTY_VALUE_MAX];
426 property_get("debug.egl.traceGpuCompletion", value, "0");
427 if (atoi(value)) {
428 mTraceGpuCompletion = true;
429 mFlushTracer = std::make_unique<FlushTracer>(this);
430 }
Alec Mouri820c7402019-01-23 13:02:39 -0800431 mDrawingBuffer = createFramebuffer();
Mathias Agopian3f844832013-08-07 21:24:32 -0700432}
433
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800434GLESRenderEngine::~GLESRenderEngine() {
Alec Mourid43ccab2019-03-13 12:23:45 -0700435 std::lock_guard<std::mutex> lock(mRenderingMutex);
436 unbindFrameBuffer(mDrawingBuffer.get());
437 mDrawingBuffer = nullptr;
438 while (!mFramebufferImageCache.empty()) {
439 EGLImageKHR expired = mFramebufferImageCache.front().second;
440 mFramebufferImageCache.pop_front();
441 eglDestroyImageKHR(mEGLDisplay, expired);
Alec Mourida4cf3b2019-02-12 15:33:01 -0800442 }
Alec Mourid43ccab2019-03-13 12:23:45 -0700443 mImageCache.clear();
Peiyong Linf11f39b2018-09-05 14:37:41 -0700444 eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
445 eglTerminate(mEGLDisplay);
446}
Mathias Agopian3f844832013-08-07 21:24:32 -0700447
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800448std::unique_ptr<Framebuffer> GLESRenderEngine::createFramebuffer() {
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700449 return std::make_unique<GLFramebuffer>(*this);
450}
451
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800452std::unique_ptr<Image> GLESRenderEngine::createImage() {
Peiyong Linf1bada92018-08-29 09:39:31 -0700453 return std::make_unique<GLImage>(*this);
454}
455
Alec Mouri820c7402019-01-23 13:02:39 -0800456Framebuffer* GLESRenderEngine::getFramebufferForDrawing() {
457 return mDrawingBuffer.get();
458}
459
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800460void GLESRenderEngine::primeCache() const {
Peiyong Linfb530cf2018-12-15 05:07:38 +0000461 ProgramCache::getInstance().primeCache(mInProtectedContext ? mProtectedEGLContext : mEGLContext,
462 mFeatureFlags & USE_COLOR_MANAGEMENT);
Peiyong Linf1bada92018-08-29 09:39:31 -0700463}
464
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800465bool GLESRenderEngine::isCurrent() const {
Peiyong Linf1bada92018-08-29 09:39:31 -0700466 return mEGLDisplay == eglGetCurrentDisplay() && mEGLContext == eglGetCurrentContext();
467}
468
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800469base::unique_fd GLESRenderEngine::flush() {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000470 ATRACE_CALL();
Peiyong Lin60bedb52018-09-05 10:47:31 -0700471 if (!GLExtensions::getInstance().hasNativeFenceSync()) {
472 return base::unique_fd();
473 }
474
475 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
476 if (sync == EGL_NO_SYNC_KHR) {
477 ALOGW("failed to create EGL native fence sync: %#x", eglGetError());
478 return base::unique_fd();
479 }
480
481 // native fence fd will not be populated until flush() is done.
482 glFlush();
483
484 // get the fence fd
485 base::unique_fd fenceFd(eglDupNativeFenceFDANDROID(mEGLDisplay, sync));
486 eglDestroySyncKHR(mEGLDisplay, sync);
487 if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
488 ALOGW("failed to dup EGL native fence sync: %#x", eglGetError());
489 }
490
Alec Mouri554d06e2018-12-20 00:15:33 -0800491 // Only trace if we have a valid fence, as current usage falls back to
492 // calling finish() if the fence fd is invalid.
493 if (CC_UNLIKELY(mTraceGpuCompletion && mFlushTracer) && fenceFd.get() >= 0) {
494 mFlushTracer->queueSync(eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr));
495 }
496
Peiyong Lin60bedb52018-09-05 10:47:31 -0700497 return fenceFd;
498}
499
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800500bool GLESRenderEngine::finish() {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000501 ATRACE_CALL();
Peiyong Lin60bedb52018-09-05 10:47:31 -0700502 if (!GLExtensions::getInstance().hasFenceSync()) {
503 ALOGW("no synchronization support");
504 return false;
505 }
506
507 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr);
508 if (sync == EGL_NO_SYNC_KHR) {
509 ALOGW("failed to create EGL fence sync: %#x", eglGetError());
510 return false;
511 }
512
Alec Mouri554d06e2018-12-20 00:15:33 -0800513 if (CC_UNLIKELY(mTraceGpuCompletion && mFlushTracer)) {
514 mFlushTracer->queueSync(eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr));
515 }
516
517 return waitSync(sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR);
518}
519
520bool GLESRenderEngine::waitSync(EGLSyncKHR sync, EGLint flags) {
521 EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync, flags, 2000000000 /*2 sec*/);
Peiyong Lin60bedb52018-09-05 10:47:31 -0700522 EGLint error = eglGetError();
523 eglDestroySyncKHR(mEGLDisplay, sync);
524 if (result != EGL_CONDITION_SATISFIED_KHR) {
525 if (result == EGL_TIMEOUT_EXPIRED_KHR) {
526 ALOGW("fence wait timed out");
527 } else {
528 ALOGW("error waiting on EGL fence: %#x", error);
529 }
530 return false;
531 }
532
533 return true;
534}
535
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800536bool GLESRenderEngine::waitFence(base::unique_fd fenceFd) {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700537 if (!GLExtensions::getInstance().hasNativeFenceSync() ||
538 !GLExtensions::getInstance().hasWaitSync()) {
539 return false;
540 }
541
542 EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceFd, EGL_NONE};
543 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
544 if (sync == EGL_NO_SYNC_KHR) {
545 ALOGE("failed to create EGL native fence sync: %#x", eglGetError());
546 return false;
547 }
548
549 // fenceFd is now owned by EGLSync
550 (void)fenceFd.release();
551
552 // XXX: The spec draft is inconsistent as to whether this should return an
553 // EGLint or void. Ignore the return value for now, as it's not strictly
554 // needed.
555 eglWaitSyncKHR(mEGLDisplay, sync, 0);
556 EGLint error = eglGetError();
557 eglDestroySyncKHR(mEGLDisplay, sync);
558 if (error != EGL_SUCCESS) {
559 ALOGE("failed to wait for EGL native fence sync: %#x", error);
560 return false;
561 }
562
563 return true;
564}
565
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800566void GLESRenderEngine::clearWithColor(float red, float green, float blue, float alpha) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000567 ATRACE_CALL();
568 glDisable(GL_BLEND);
Peiyong Linf11f39b2018-09-05 14:37:41 -0700569 glClearColor(red, green, blue, alpha);
570 glClear(GL_COLOR_BUFFER_BIT);
571}
572
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800573void GLESRenderEngine::fillRegionWithColor(const Region& region, float red, float green, float blue,
574 float alpha) {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700575 size_t c;
576 Rect const* r = region.getArray(&c);
577 Mesh mesh(Mesh::TRIANGLES, c * 6, 2);
578 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
579 for (size_t i = 0; i < c; i++, r++) {
580 position[i * 6 + 0].x = r->left;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700581 position[i * 6 + 0].y = r->top;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700582 position[i * 6 + 1].x = r->left;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700583 position[i * 6 + 1].y = r->bottom;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700584 position[i * 6 + 2].x = r->right;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700585 position[i * 6 + 2].y = r->bottom;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700586 position[i * 6 + 3].x = r->left;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700587 position[i * 6 + 3].y = r->top;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700588 position[i * 6 + 4].x = r->right;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700589 position[i * 6 + 4].y = r->bottom;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700590 position[i * 6 + 5].x = r->right;
Chia-I Wu28e3a252018-09-07 12:05:02 -0700591 position[i * 6 + 5].y = r->top;
Peiyong Lin60bedb52018-09-05 10:47:31 -0700592 }
593 setupFillWithColor(red, green, blue, alpha);
594 drawMesh(mesh);
595}
596
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800597void GLESRenderEngine::setScissor(const Rect& region) {
Peiyong Lin1c097612019-03-22 16:21:46 -0700598 glScissor(region.left, region.top, region.getWidth(), region.getHeight());
Peiyong Lin60bedb52018-09-05 10:47:31 -0700599 glEnable(GL_SCISSOR_TEST);
600}
601
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800602void GLESRenderEngine::disableScissor() {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700603 glDisable(GL_SCISSOR_TEST);
604}
605
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800606void GLESRenderEngine::genTextures(size_t count, uint32_t* names) {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700607 glGenTextures(count, names);
608}
609
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800610void GLESRenderEngine::deleteTextures(size_t count, uint32_t const* names) {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700611 glDeleteTextures(count, names);
612}
613
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800614void GLESRenderEngine::bindExternalTextureImage(uint32_t texName, const Image& image) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000615 ATRACE_CALL();
Peiyong Linf1bada92018-08-29 09:39:31 -0700616 const GLImage& glImage = static_cast<const GLImage&>(image);
617 const GLenum target = GL_TEXTURE_EXTERNAL_OES;
618
619 glBindTexture(target, texName);
Peiyong Linfb530cf2018-12-15 05:07:38 +0000620 if (supportsProtectedContent()) {
621 glTexParameteri(target, GL_TEXTURE_PROTECTED_EXT,
622 glImage.isProtected() ? GL_TRUE : GL_FALSE);
623 }
Peiyong Linf1bada92018-08-29 09:39:31 -0700624 if (glImage.getEGLImage() != EGL_NO_IMAGE_KHR) {
Peiyong Lin46080ef2018-10-26 18:43:14 -0700625 glEGLImageTargetTexture2DOES(target, static_cast<GLeglImageOES>(glImage.getEGLImage()));
Peiyong Linf1bada92018-08-29 09:39:31 -0700626 }
Mathias Agopian3f844832013-08-07 21:24:32 -0700627}
628
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700629status_t GLESRenderEngine::cacheExternalTextureBuffer(const sp<GraphicBuffer>& buffer) {
630 std::lock_guard<std::mutex> lock(mRenderingMutex);
631 return cacheExternalTextureBufferLocked(buffer);
632}
633
634status_t GLESRenderEngine::bindExternalTextureBuffer(uint32_t texName,
635 const sp<GraphicBuffer>& buffer,
636 const sp<Fence>& bufferFence) {
Alec Mourif0497272019-03-11 15:53:11 -0700637 std::lock_guard<std::mutex> lock(mRenderingMutex);
638 return bindExternalTextureBufferLocked(texName, buffer, bufferFence);
639}
640
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700641status_t GLESRenderEngine::cacheExternalTextureBufferLocked(const sp<GraphicBuffer>& buffer) {
Alec Mourid43ccab2019-03-13 12:23:45 -0700642 if (buffer == nullptr) {
643 return BAD_VALUE;
644 }
Alec Mouri539319f2018-12-19 17:56:23 -0800645
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700646 ATRACE_CALL();
647
648 if (mImageCache.count(buffer->getId()) > 0) {
Alec Mourib5c4f352019-02-19 19:46:38 -0800649 return NO_ERROR;
Alec Mouri539319f2018-12-19 17:56:23 -0800650 }
651
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800652 std::unique_ptr<Image> newImage = createImage();
653
654 bool created = newImage->setNativeWindowBuffer(buffer->getNativeBuffer(),
655 buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
656 if (!created) {
657 ALOGE("Failed to create image. size=%ux%u st=%u usage=%#" PRIx64 " fmt=%d",
658 buffer->getWidth(), buffer->getHeight(), buffer->getStride(), buffer->getUsage(),
659 buffer->getPixelFormat());
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700660 return NO_INIT;
661 }
662 mImageCache.insert(std::make_pair(buffer->getId(), std::move(newImage)));
663
664 return NO_ERROR;
665}
666
667status_t GLESRenderEngine::bindExternalTextureBufferLocked(uint32_t texName,
668 const sp<GraphicBuffer>& buffer,
669 const sp<Fence>& bufferFence) {
670 ATRACE_CALL();
671 status_t cacheResult = cacheExternalTextureBufferLocked(buffer);
672
673 if (cacheResult != NO_ERROR) {
674 return cacheResult;
675 }
676
677 auto cachedImage = mImageCache.find(buffer->getId());
678
679 if (cachedImage == mImageCache.end()) {
680 // We failed creating the image if we got here, so bail out.
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800681 bindExternalTextureImage(texName, *createImage());
682 return NO_INIT;
683 }
684
Alec Mourid7b3a8b2019-03-21 11:44:18 -0700685 bindExternalTextureImage(texName, *cachedImage->second);
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800686
687 // Wait for the new buffer to be ready.
688 if (bufferFence != nullptr && bufferFence->isValid()) {
689 if (GLExtensions::getInstance().hasWaitSync()) {
690 base::unique_fd fenceFd(bufferFence->dup());
691 if (fenceFd == -1) {
692 ALOGE("error dup'ing fence fd: %d", errno);
693 return -errno;
694 }
695 if (!waitFence(std::move(fenceFd))) {
696 ALOGE("failed to wait on fence fd");
697 return UNKNOWN_ERROR;
698 }
699 } else {
700 status_t err = bufferFence->waitForever("RenderEngine::bindExternalTextureBuffer");
701 if (err != NO_ERROR) {
702 ALOGE("error waiting for fence: %d", err);
703 return err;
704 }
705 }
706 }
Alec Mouri539319f2018-12-19 17:56:23 -0800707
Alec Mouri0d5e1eb2018-11-10 20:40:12 -0800708 return NO_ERROR;
709}
710
Alec Mourib5c4f352019-02-19 19:46:38 -0800711void GLESRenderEngine::unbindExternalTextureBuffer(uint64_t bufferId) {
Alec Mourif0497272019-03-11 15:53:11 -0700712 std::lock_guard<std::mutex> lock(mRenderingMutex);
Alec Mourib5c4f352019-02-19 19:46:38 -0800713 const auto& cachedImage = mImageCache.find(bufferId);
714 if (cachedImage != mImageCache.end()) {
715 ALOGV("Destroying image for buffer: %" PRIu64, bufferId);
716 mImageCache.erase(bufferId);
717 return;
Alec Mouri539319f2018-12-19 17:56:23 -0800718 }
Alec Mourib5c4f352019-02-19 19:46:38 -0800719 ALOGV("Failed to find image for buffer: %" PRIu64, bufferId);
Alec Mouri539319f2018-12-19 17:56:23 -0800720}
721
Alec Mouri7c94edb2018-12-03 21:23:26 -0800722FloatRect GLESRenderEngine::setupLayerCropping(const LayerSettings& layer, Mesh& mesh) {
723 // Translate win by the rounded corners rect coordinates, to have all values in
724 // layer coordinate space.
725 FloatRect cropWin = layer.geometry.boundaries;
726 const FloatRect& roundedCornersCrop = layer.geometry.roundedCornersCrop;
727 cropWin.left -= roundedCornersCrop.left;
728 cropWin.right -= roundedCornersCrop.left;
729 cropWin.top -= roundedCornersCrop.top;
730 cropWin.bottom -= roundedCornersCrop.top;
731 Mesh::VertexArray<vec2> cropCoords(mesh.getCropCoordArray<vec2>());
732 cropCoords[0] = vec2(cropWin.left, cropWin.top);
733 cropCoords[1] = vec2(cropWin.left, cropWin.top + cropWin.getHeight());
734 cropCoords[2] = vec2(cropWin.right, cropWin.top + cropWin.getHeight());
735 cropCoords[3] = vec2(cropWin.right, cropWin.top);
736
737 setupCornerRadiusCropSize(roundedCornersCrop.getWidth(), roundedCornersCrop.getHeight());
738 return cropWin;
739}
740
Peiyong Lin1c097612019-03-22 16:21:46 -0700741void GLESRenderEngine::handleRoundedCorners(const DisplaySettings& display,
742 const LayerSettings& layer, const Mesh& mesh) {
743 // We separate the layer into 3 parts essentially, such that we only turn on blending for the
744 // top rectangle and the bottom rectangle, and turn off blending for the middle rectangle.
745 FloatRect bounds = layer.geometry.roundedCornersCrop;
746 const auto transformMatrix = display.globalTransform * layer.geometry.positionTransform;
747 const vec4 leftTopCoordinate(bounds.left, bounds.top, 1.0, 1.0);
748 const vec4 rightBottomCoordinate(bounds.right, bounds.bottom, 1.0, 1.0);
749 const vec4 leftTopCoordinateInBuffer = transformMatrix * leftTopCoordinate;
750 const vec4 rightBottomCoordinateInBuffer = transformMatrix * rightBottomCoordinate;
751 bounds = FloatRect(leftTopCoordinateInBuffer[0], leftTopCoordinateInBuffer[1],
752 rightBottomCoordinateInBuffer[0], rightBottomCoordinateInBuffer[1]);
753 const int32_t radius = ceil(layer.geometry.roundedCornersRadius);
754
755 const Rect topRect(bounds.left, bounds.top, bounds.right, bounds.top + radius);
756 setScissor(topRect);
757 drawMesh(mesh);
758 const Rect bottomRect(bounds.left, bounds.bottom - radius, bounds.right, bounds.bottom);
759 setScissor(bottomRect);
760 drawMesh(mesh);
761
762 // The middle part of the layer can turn off blending.
763 const Rect middleRect(bounds.left, bounds.top + radius, bounds.right, bounds.bottom - radius);
764 setScissor(middleRect);
765 mState.cornerRadius = 0.0;
766 disableBlending();
767 drawMesh(mesh);
768 disableScissor();
769}
770
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800771status_t GLESRenderEngine::bindFrameBuffer(Framebuffer* framebuffer) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000772 ATRACE_CALL();
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700773 GLFramebuffer* glFramebuffer = static_cast<GLFramebuffer*>(framebuffer);
774 EGLImageKHR eglImage = glFramebuffer->getEGLImage();
775 uint32_t textureName = glFramebuffer->getTextureName();
776 uint32_t framebufferName = glFramebuffer->getFramebufferName();
777
778 // Bind the texture and turn our EGLImage into a texture
779 glBindTexture(GL_TEXTURE_2D, textureName);
Peiyong Linfb530cf2018-12-15 05:07:38 +0000780 if (supportsProtectedContent()) {
781 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_PROTECTED_EXT,
782 mInProtectedContext ? GL_TRUE : GL_FALSE);
783 }
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700784 glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)eglImage);
785
786 // Bind the Framebuffer to render into
787 glBindFramebuffer(GL_FRAMEBUFFER, framebufferName);
Peiyong Lin46080ef2018-10-26 18:43:14 -0700788 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureName, 0);
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700789
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700790 uint32_t glStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
791
Peiyong Lin46080ef2018-10-26 18:43:14 -0700792 ALOGE_IF(glStatus != GL_FRAMEBUFFER_COMPLETE_OES, "glCheckFramebufferStatusOES error %d",
793 glStatus);
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700794
795 return glStatus == GL_FRAMEBUFFER_COMPLETE_OES ? NO_ERROR : BAD_VALUE;
796}
797
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800798void GLESRenderEngine::unbindFrameBuffer(Framebuffer* /* framebuffer */) {
Alec Mouri820c7402019-01-23 13:02:39 -0800799 ATRACE_CALL();
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700800
801 // back to main framebuffer
802 glBindFramebuffer(GL_FRAMEBUFFER, 0);
Peiyong Line5a9a7f2018-08-30 15:32:13 -0700803}
804
Peiyong Lin7e219eb2018-12-03 05:40:42 -0800805void GLESRenderEngine::checkErrors() const {
Peiyong Lin60bedb52018-09-05 10:47:31 -0700806 do {
807 // there could be more than one error flag
808 GLenum error = glGetError();
809 if (error == GL_NO_ERROR) break;
810 ALOGE("GL error 0x%04x", int(error));
811 } while (true);
812}
813
Peiyong Linfb530cf2018-12-15 05:07:38 +0000814bool GLESRenderEngine::supportsProtectedContent() const {
815 return mProtectedEGLContext != EGL_NO_CONTEXT;
816}
817
818bool GLESRenderEngine::useProtectedContext(bool useProtectedContext) {
819 if (useProtectedContext == mInProtectedContext) {
820 return true;
821 }
822 if (useProtectedContext && mProtectedEGLContext == EGL_NO_CONTEXT) {
823 return false;
824 }
825 const EGLSurface surface = useProtectedContext ? mProtectedDummySurface : mDummySurface;
826 const EGLContext context = useProtectedContext ? mProtectedEGLContext : mEGLContext;
827 const bool success = eglMakeCurrent(mEGLDisplay, surface, surface, context) == EGL_TRUE;
828 if (success) {
829 mInProtectedContext = useProtectedContext;
830 }
831 return success;
832}
Alec Mourida4cf3b2019-02-12 15:33:01 -0800833EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer* nativeBuffer,
Alec Mourife0d72b2019-03-21 14:05:56 -0700834 bool isProtected,
835 bool useFramebufferCache) {
Alec Mourida4cf3b2019-02-12 15:33:01 -0800836 sp<GraphicBuffer> graphicBuffer = GraphicBuffer::from(nativeBuffer);
Alec Mourife0d72b2019-03-21 14:05:56 -0700837 if (useFramebufferCache) {
838 for (const auto& image : mFramebufferImageCache) {
839 if (image.first == graphicBuffer->getId()) {
840 return image.second;
841 }
Alec Mourida4cf3b2019-02-12 15:33:01 -0800842 }
843 }
844 EGLint attributes[] = {
845 isProtected ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
846 isProtected ? EGL_TRUE : EGL_NONE,
847 EGL_NONE,
848 };
849 EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
850 nativeBuffer, attributes);
Alec Mourife0d72b2019-03-21 14:05:56 -0700851 if (useFramebufferCache) {
852 if (image != EGL_NO_IMAGE_KHR) {
853 if (mFramebufferImageCache.size() >= mFramebufferImageCacheSize) {
854 EGLImageKHR expired = mFramebufferImageCache.front().second;
855 mFramebufferImageCache.pop_front();
856 eglDestroyImageKHR(mEGLDisplay, expired);
857 }
858 mFramebufferImageCache.push_back({graphicBuffer->getId(), image});
Alec Mourida4cf3b2019-02-12 15:33:01 -0800859 }
Alec Mourida4cf3b2019-02-12 15:33:01 -0800860 }
861 return image;
862}
Peiyong Linfb530cf2018-12-15 05:07:38 +0000863
Alec Mouri1089aed2018-10-25 21:33:57 -0700864status_t GLESRenderEngine::drawLayers(const DisplaySettings& display,
865 const std::vector<LayerSettings>& layers,
866 ANativeWindowBuffer* const buffer,
Alec Mourife0d72b2019-03-21 14:05:56 -0700867 const bool useFramebufferCache, base::unique_fd&& bufferFence,
868 base::unique_fd* drawFence) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000869 ATRACE_CALL();
Alec Mouri1089aed2018-10-25 21:33:57 -0700870 if (layers.empty()) {
871 ALOGV("Drawing empty layer stack");
872 return NO_ERROR;
873 }
874
Alec Mouri6338c9d2019-02-07 16:57:51 -0800875 if (bufferFence.get() >= 0 && !waitFence(std::move(bufferFence))) {
876 ATRACE_NAME("Waiting before draw");
877 sync_wait(bufferFence.get(), -1);
878 }
879
Alec Mourid43ccab2019-03-13 12:23:45 -0700880 if (buffer == nullptr) {
881 ALOGE("No output buffer provided. Aborting GPU composition.");
882 return BAD_VALUE;
883 }
884
Alec Mourif0497272019-03-11 15:53:11 -0700885 {
886 std::lock_guard<std::mutex> lock(mRenderingMutex);
Alec Mouri1089aed2018-10-25 21:33:57 -0700887
Alec Mourife0d72b2019-03-21 14:05:56 -0700888 BindNativeBufferAsFramebuffer fbo(*this, buffer, useFramebufferCache);
Alec Mouri1089aed2018-10-25 21:33:57 -0700889
Alec Mourif0497272019-03-11 15:53:11 -0700890 if (fbo.getStatus() != NO_ERROR) {
891 ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",
892 buffer->handle);
Alec Mouri1089aed2018-10-25 21:33:57 -0700893 checkErrors();
Alec Mourif0497272019-03-11 15:53:11 -0700894 return fbo.getStatus();
Alec Mouri1089aed2018-10-25 21:33:57 -0700895 }
Alec Mouri1089aed2018-10-25 21:33:57 -0700896
Alec Mourif0497272019-03-11 15:53:11 -0700897 // clear the entire buffer, sometimes when we reuse buffers we'd persist
898 // ghost images otherwise.
899 // we also require a full transparent framebuffer for overlays. This is
900 // probably not quite efficient on all GPUs, since we could filter out
901 // opaque layers.
902 clearWithColor(0.0, 0.0, 0.0, 0.0);
903
904 setViewportAndProjection(display.physicalDisplay, display.clip);
905
906 setOutputDataSpace(display.outputDataspace);
907 setDisplayMaxLuminance(display.maxLuminance);
908
909 mat4 projectionMatrix = mState.projectionMatrix * display.globalTransform;
910 mState.projectionMatrix = projectionMatrix;
911 if (!display.clearRegion.isEmpty()) {
912 glDisable(GL_BLEND);
913 fillRegionWithColor(display.clearRegion, 0.0, 0.0, 0.0, 1.0);
914 }
915
916 Mesh mesh(Mesh::TRIANGLE_FAN, 4, 2, 2);
917 for (auto layer : layers) {
918 mState.projectionMatrix = projectionMatrix * layer.geometry.positionTransform;
919
920 const FloatRect bounds = layer.geometry.boundaries;
921 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
922 position[0] = vec2(bounds.left, bounds.top);
923 position[1] = vec2(bounds.left, bounds.bottom);
924 position[2] = vec2(bounds.right, bounds.bottom);
925 position[3] = vec2(bounds.right, bounds.top);
926
927 setupLayerCropping(layer, mesh);
928 setColorTransform(display.colorTransform * layer.colorTransform);
929
930 bool usePremultipliedAlpha = true;
931 bool disableTexture = true;
932 bool isOpaque = false;
933
934 if (layer.source.buffer.buffer != nullptr) {
935 disableTexture = false;
936 isOpaque = layer.source.buffer.isOpaque;
937
938 sp<GraphicBuffer> gBuf = layer.source.buffer.buffer;
939 bindExternalTextureBufferLocked(layer.source.buffer.textureName, gBuf,
940 layer.source.buffer.fence);
941
942 usePremultipliedAlpha = layer.source.buffer.usePremultipliedAlpha;
943 Texture texture(Texture::TEXTURE_EXTERNAL, layer.source.buffer.textureName);
944 mat4 texMatrix = layer.source.buffer.textureTransform;
945
946 texture.setMatrix(texMatrix.asArray());
947 texture.setFiltering(layer.source.buffer.useTextureFiltering);
948
949 texture.setDimensions(gBuf->getWidth(), gBuf->getHeight());
950 setSourceY410BT2020(layer.source.buffer.isY410BT2020);
951
952 renderengine::Mesh::VertexArray<vec2> texCoords(mesh.getTexCoordArray<vec2>());
953 texCoords[0] = vec2(0.0, 0.0);
954 texCoords[1] = vec2(0.0, 1.0);
955 texCoords[2] = vec2(1.0, 1.0);
956 texCoords[3] = vec2(1.0, 0.0);
957 setupLayerTexturing(texture);
958 }
959
960 const half3 solidColor = layer.source.solidColor;
961 const half4 color = half4(solidColor.r, solidColor.g, solidColor.b, layer.alpha);
962 // Buffer sources will have a black solid color ignored in the shader,
963 // so in that scenario the solid color passed here is arbitrary.
964 setupLayerBlending(usePremultipliedAlpha, isOpaque, disableTexture, color,
965 layer.geometry.roundedCornersRadius);
966 if (layer.disableBlending) {
967 glDisable(GL_BLEND);
968 }
969 setSourceDataSpace(layer.sourceDataspace);
970
Peiyong Lin1c097612019-03-22 16:21:46 -0700971 // We only want to do a special handling for rounded corners when having rounded corners
972 // is the only reason it needs to turn on blending, otherwise, we handle it like the
973 // usual way since it needs to turn on blending anyway.
974 if (layer.geometry.roundedCornersRadius > 0.0 && color.a >= 1.0f && isOpaque) {
975 handleRoundedCorners(display, layer, mesh);
976 } else {
977 drawMesh(mesh);
978 }
Alec Mourif0497272019-03-11 15:53:11 -0700979
980 // Cleanup if there's a buffer source
981 if (layer.source.buffer.buffer != nullptr) {
982 disableBlending();
983 setSourceY410BT2020(false);
984 disableTexturing();
985 }
986 }
987
Alec Mourid43ccab2019-03-13 12:23:45 -0700988 if (drawFence != nullptr) {
989 *drawFence = flush();
990 }
Alec Mourif0497272019-03-11 15:53:11 -0700991 // If flush failed or we don't support native fences, we need to force the
992 // gl command stream to be executed.
Alec Mourid43ccab2019-03-13 12:23:45 -0700993 if (drawFence == nullptr || drawFence->get() < 0) {
Alec Mourif0497272019-03-11 15:53:11 -0700994 bool success = finish();
995 if (!success) {
996 ALOGE("Failed to flush RenderEngine commands");
997 checkErrors();
998 // Chances are, something illegal happened (either the caller passed
999 // us bad parameters, or we messed up our shader generation).
1000 return INVALID_OPERATION;
1001 }
1002 }
1003
1004 checkErrors();
1005 }
Alec Mouri6e57f682018-09-29 20:45:08 -07001006 return NO_ERROR;
1007}
1008
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001009void GLESRenderEngine::setViewportAndProjection(size_t vpw, size_t vph, Rect sourceCrop,
1010 ui::Transform::orientation_flags rotation) {
Alec Mouri1089aed2018-10-25 21:33:57 -07001011 setViewportAndProjection(Rect(vpw, vph), sourceCrop);
1012
1013 if (rotation == ui::Transform::ROT_0) {
1014 return;
1015 }
Mathias Agopian3f844832013-08-07 21:24:32 -07001016
Riley Andrewsc3ebe662014-09-04 16:20:31 -07001017 // Apply custom rotation to the projection.
1018 float rot90InRadians = 2.0f * static_cast<float>(M_PI) / 4.0f;
Alec Mouri1089aed2018-10-25 21:33:57 -07001019 mat4 m = mState.projectionMatrix;
Riley Andrewsc3ebe662014-09-04 16:20:31 -07001020 switch (rotation) {
Peiyong Linefefaac2018-08-17 12:27:51 -07001021 case ui::Transform::ROT_90:
Chia-I Wub027f802017-11-29 14:00:52 -08001022 m = mat4::rotate(rot90InRadians, vec3(0, 0, 1)) * m;
Riley Andrewsc3ebe662014-09-04 16:20:31 -07001023 break;
Peiyong Linefefaac2018-08-17 12:27:51 -07001024 case ui::Transform::ROT_180:
Chia-I Wub027f802017-11-29 14:00:52 -08001025 m = mat4::rotate(rot90InRadians * 2.0f, vec3(0, 0, 1)) * m;
Riley Andrewsc3ebe662014-09-04 16:20:31 -07001026 break;
Peiyong Linefefaac2018-08-17 12:27:51 -07001027 case ui::Transform::ROT_270:
Chia-I Wub027f802017-11-29 14:00:52 -08001028 m = mat4::rotate(rot90InRadians * 3.0f, vec3(0, 0, 1)) * m;
Riley Andrewsc3ebe662014-09-04 16:20:31 -07001029 break;
1030 default:
1031 break;
1032 }
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001033 mState.projectionMatrix = m;
Alec Mouri1089aed2018-10-25 21:33:57 -07001034}
1035
1036void GLESRenderEngine::setViewportAndProjection(Rect viewport, Rect clip) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001037 ATRACE_CALL();
Alec Mouri1089aed2018-10-25 21:33:57 -07001038 mVpWidth = viewport.getWidth();
1039 mVpHeight = viewport.getHeight();
1040
1041 // We pass the the top left corner instead of the bottom left corner,
1042 // because since we're rendering off-screen first.
1043 glViewport(viewport.left, viewport.top, mVpWidth, mVpHeight);
1044
1045 mState.projectionMatrix = mat4::ortho(clip.left, clip.right, clip.top, clip.bottom, 0, 1);
Mathias Agopian3f844832013-08-07 21:24:32 -07001046}
1047
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001048void GLESRenderEngine::setupLayerBlending(bool premultipliedAlpha, bool opaque, bool disableTexture,
1049 const half4& color, float cornerRadius) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001050 mState.isPremultipliedAlpha = premultipliedAlpha;
1051 mState.isOpaque = opaque;
1052 mState.color = color;
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001053 mState.cornerRadius = cornerRadius;
Dan Stoza9e56aa02015-11-02 13:00:03 -08001054
chaviw13fdc492017-06-27 12:40:18 -07001055 if (disableTexture) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001056 mState.textureEnabled = false;
chaviw13fdc492017-06-27 12:40:18 -07001057 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001058
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001059 if (color.a < 1.0f || !opaque || cornerRadius > 0.0f) {
Mathias Agopian3f844832013-08-07 21:24:32 -07001060 glEnable(GL_BLEND);
1061 glBlendFunc(premultipliedAlpha ? GL_ONE : GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1062 } else {
1063 glDisable(GL_BLEND);
1064 }
1065}
1066
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001067void GLESRenderEngine::setSourceY410BT2020(bool enable) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001068 mState.isY410BT2020 = enable;
Chia-I Wu131d3762018-01-11 14:35:27 -08001069}
1070
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001071void GLESRenderEngine::setSourceDataSpace(Dataspace source) {
Chia-I Wu69bf10f2018-02-20 13:04:50 -08001072 mDataSpace = source;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001073}
1074
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001075void GLESRenderEngine::setOutputDataSpace(Dataspace dataspace) {
Chia-I Wu69bf10f2018-02-20 13:04:50 -08001076 mOutputDataSpace = dataspace;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001077}
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001078
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001079void GLESRenderEngine::setDisplayMaxLuminance(const float maxLuminance) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001080 mState.displayMaxLuminance = maxLuminance;
Peiyong Linfb069302018-04-25 14:34:31 -07001081}
1082
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001083void GLESRenderEngine::setupLayerTexturing(const Texture& texture) {
Mathias Agopian49457ac2013-08-14 18:20:17 -07001084 GLuint target = texture.getTextureTarget();
1085 glBindTexture(target, texture.getTextureName());
Mathias Agopian3f844832013-08-07 21:24:32 -07001086 GLenum filter = GL_NEAREST;
Mathias Agopian49457ac2013-08-14 18:20:17 -07001087 if (texture.getFiltering()) {
Mathias Agopian3f844832013-08-07 21:24:32 -07001088 filter = GL_LINEAR;
1089 }
Mathias Agopian49457ac2013-08-14 18:20:17 -07001090 glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1091 glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1092 glTexParameteri(target, GL_TEXTURE_MAG_FILTER, filter);
1093 glTexParameteri(target, GL_TEXTURE_MIN_FILTER, filter);
Mathias Agopian3f844832013-08-07 21:24:32 -07001094
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001095 mState.texture = texture;
1096 mState.textureEnabled = true;
Mathias Agopian3f844832013-08-07 21:24:32 -07001097}
1098
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001099void GLESRenderEngine::setupLayerBlackedOut() {
Mathias Agopian3f844832013-08-07 21:24:32 -07001100 glBindTexture(GL_TEXTURE_2D, mProtectedTexName);
Mathias Agopian49457ac2013-08-14 18:20:17 -07001101 Texture texture(Texture::TEXTURE_2D, mProtectedTexName);
1102 texture.setDimensions(1, 1); // FIXME: we should get that from somewhere
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001103 mState.texture = texture;
1104 mState.textureEnabled = true;
Mathias Agopian3f844832013-08-07 21:24:32 -07001105}
1106
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001107void GLESRenderEngine::setColorTransform(const mat4& colorTransform) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001108 mState.colorMatrix = colorTransform;
Dan Stozaf0087992014-10-20 15:46:09 -07001109}
1110
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001111void GLESRenderEngine::disableTexturing() {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001112 mState.textureEnabled = false;
Mathias Agopian3f844832013-08-07 21:24:32 -07001113}
1114
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001115void GLESRenderEngine::disableBlending() {
Mathias Agopian3f844832013-08-07 21:24:32 -07001116 glDisable(GL_BLEND);
1117}
1118
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001119void GLESRenderEngine::setupFillWithColor(float r, float g, float b, float a) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001120 mState.isPremultipliedAlpha = true;
1121 mState.isOpaque = false;
1122 mState.color = half4(r, g, b, a);
1123 mState.textureEnabled = false;
Mathias Agopian3f844832013-08-07 21:24:32 -07001124 glDisable(GL_BLEND);
Mathias Agopian3f844832013-08-07 21:24:32 -07001125}
1126
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001127void GLESRenderEngine::setupCornerRadiusCropSize(float width, float height) {
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001128 mState.cropSize = half2(width, height);
1129}
1130
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001131void GLESRenderEngine::drawMesh(const Mesh& mesh) {
Dan Stoza2713c302018-03-28 17:07:36 -07001132 ATRACE_CALL();
Mathias Agopian3f844832013-08-07 21:24:32 -07001133 if (mesh.getTexCoordsSize()) {
1134 glEnableVertexAttribArray(Program::texCoords);
Chia-I Wub027f802017-11-29 14:00:52 -08001135 glVertexAttribPointer(Program::texCoords, mesh.getTexCoordsSize(), GL_FLOAT, GL_FALSE,
1136 mesh.getByteStride(), mesh.getTexCoords());
Mathias Agopian3f844832013-08-07 21:24:32 -07001137 }
1138
Chia-I Wub027f802017-11-29 14:00:52 -08001139 glVertexAttribPointer(Program::position, mesh.getVertexSize(), GL_FLOAT, GL_FALSE,
1140 mesh.getByteStride(), mesh.getPositions());
Mathias Agopian3f844832013-08-07 21:24:32 -07001141
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001142 if (mState.cornerRadius > 0.0f) {
1143 glEnableVertexAttribArray(Program::cropCoords);
1144 glVertexAttribPointer(Program::cropCoords, mesh.getVertexSize(), GL_FLOAT, GL_FALSE,
1145 mesh.getByteStride(), mesh.getCropCoords());
1146 }
1147
Peiyong Lina296b0c2018-04-30 16:55:29 -07001148 // By default, DISPLAY_P3 is the only supported wide color output. However,
1149 // when HDR content is present, hardware composer may be able to handle
1150 // BT2020 data space, in that case, the output data space is set to be
1151 // BT2020_HLG or BT2020_PQ respectively. In GPU fall back we need
1152 // to respect this and convert non-HDR content to HDR format.
Peiyong Lin13effd12018-07-24 17:01:47 -07001153 if (mUseColorManagement) {
1154 Description managedState = mState;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001155 Dataspace inputStandard = static_cast<Dataspace>(mDataSpace & Dataspace::STANDARD_MASK);
1156 Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK);
Peiyong Lin46080ef2018-10-26 18:43:14 -07001157 Dataspace outputStandard =
1158 static_cast<Dataspace>(mOutputDataSpace & Dataspace::STANDARD_MASK);
1159 Dataspace outputTransfer =
1160 static_cast<Dataspace>(mOutputDataSpace & Dataspace::TRANSFER_MASK);
Peiyong Lina296b0c2018-04-30 16:55:29 -07001161 bool needsXYZConversion = needsXYZTransformMatrix();
1162
Valerie Haueb8e0762018-11-06 10:10:42 -08001163 // NOTE: if the input standard of the input dataspace is not STANDARD_DCI_P3 or
1164 // STANDARD_BT2020, it will be treated as STANDARD_BT709
1165 if (inputStandard != Dataspace::STANDARD_DCI_P3 &&
1166 inputStandard != Dataspace::STANDARD_BT2020) {
1167 inputStandard = Dataspace::STANDARD_BT709;
1168 }
1169
Peiyong Lina296b0c2018-04-30 16:55:29 -07001170 if (needsXYZConversion) {
1171 // The supported input color spaces are standard RGB, Display P3 and BT2020.
1172 switch (inputStandard) {
1173 case Dataspace::STANDARD_DCI_P3:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001174 managedState.inputTransformMatrix = mDisplayP3ToXyz;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001175 break;
1176 case Dataspace::STANDARD_BT2020:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001177 managedState.inputTransformMatrix = mBt2020ToXyz;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001178 break;
1179 default:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001180 managedState.inputTransformMatrix = mSrgbToXyz;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001181 break;
1182 }
1183
Peiyong Lin9b03c732018-05-17 10:14:02 -07001184 // The supported output color spaces are BT2020, Display P3 and standard RGB.
Peiyong Lina296b0c2018-04-30 16:55:29 -07001185 switch (outputStandard) {
1186 case Dataspace::STANDARD_BT2020:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001187 managedState.outputTransformMatrix = mXyzToBt2020;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001188 break;
Peiyong Lin9b03c732018-05-17 10:14:02 -07001189 case Dataspace::STANDARD_DCI_P3:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001190 managedState.outputTransformMatrix = mXyzToDisplayP3;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001191 break;
Peiyong Lin9b03c732018-05-17 10:14:02 -07001192 default:
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001193 managedState.outputTransformMatrix = mXyzToSrgb;
Peiyong Lin9b03c732018-05-17 10:14:02 -07001194 break;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001195 }
1196 } else if (inputStandard != outputStandard) {
1197 // At this point, the input data space and output data space could be both
1198 // HDR data spaces, but they match each other, we do nothing in this case.
1199 // In addition to the case above, the input data space could be
1200 // - scRGB linear
1201 // - scRGB non-linear
1202 // - sRGB
1203 // - Display P3
Valerie Haueb8e0762018-11-06 10:10:42 -08001204 // - BT2020
Peiyong Lina296b0c2018-04-30 16:55:29 -07001205 // The output data spaces could be
1206 // - sRGB
1207 // - Display P3
Valerie Haueb8e0762018-11-06 10:10:42 -08001208 // - BT2020
1209 switch (outputStandard) {
1210 case Dataspace::STANDARD_BT2020:
1211 if (inputStandard == Dataspace::STANDARD_BT709) {
1212 managedState.outputTransformMatrix = mSrgbToBt2020;
1213 } else if (inputStandard == Dataspace::STANDARD_DCI_P3) {
1214 managedState.outputTransformMatrix = mDisplayP3ToBt2020;
1215 }
1216 break;
1217 case Dataspace::STANDARD_DCI_P3:
1218 if (inputStandard == Dataspace::STANDARD_BT709) {
1219 managedState.outputTransformMatrix = mSrgbToDisplayP3;
1220 } else if (inputStandard == Dataspace::STANDARD_BT2020) {
1221 managedState.outputTransformMatrix = mBt2020ToDisplayP3;
1222 }
1223 break;
1224 default:
1225 if (inputStandard == Dataspace::STANDARD_DCI_P3) {
1226 managedState.outputTransformMatrix = mDisplayP3ToSrgb;
1227 } else if (inputStandard == Dataspace::STANDARD_BT2020) {
1228 managedState.outputTransformMatrix = mBt2020ToSrgb;
1229 }
1230 break;
Peiyong Lina296b0c2018-04-30 16:55:29 -07001231 }
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001232 }
Peiyong Lina296b0c2018-04-30 16:55:29 -07001233
1234 // we need to convert the RGB value to linear space and convert it back when:
1235 // - there is a color matrix that is not an identity matrix, or
1236 // - there is an output transform matrix that is not an identity matrix, or
1237 // - the input transfer function doesn't match the output transfer function.
Peiyong Lin13effd12018-07-24 17:01:47 -07001238 if (managedState.hasColorMatrix() || managedState.hasOutputTransformMatrix() ||
Chia-I Wud49d6692018-06-27 07:17:41 +08001239 inputTransfer != outputTransfer) {
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001240 managedState.inputTransferFunction =
Peiyong Lin46080ef2018-10-26 18:43:14 -07001241 Description::dataSpaceToTransferFunction(inputTransfer);
Peiyong Lin70b26ce2018-09-18 19:02:39 -07001242 managedState.outputTransferFunction =
Peiyong Lin46080ef2018-10-26 18:43:14 -07001243 Description::dataSpaceToTransferFunction(outputTransfer);
Peiyong Lina296b0c2018-04-30 16:55:29 -07001244 }
1245
Peiyong Linfb530cf2018-12-15 05:07:38 +00001246 ProgramCache::getInstance().useProgram(mInProtectedContext ? mProtectedEGLContext
1247 : mEGLContext,
1248 managedState);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001249
1250 glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());
1251
1252 if (outputDebugPPMs) {
Peiyong Lin13effd12018-07-24 17:01:47 -07001253 static uint64_t managedColorFrameCount = 0;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001254 std::ostringstream out;
Peiyong Lin13effd12018-07-24 17:01:47 -07001255 out << "/data/texture_out" << managedColorFrameCount++;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001256 writePPM(out.str().c_str(), mVpWidth, mVpHeight);
1257 }
1258 } else {
Peiyong Linfb530cf2018-12-15 05:07:38 +00001259 ProgramCache::getInstance().useProgram(mInProtectedContext ? mProtectedEGLContext
1260 : mEGLContext,
1261 mState);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06001262
1263 glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());
1264 }
Mathias Agopian3f844832013-08-07 21:24:32 -07001265
1266 if (mesh.getTexCoordsSize()) {
1267 glDisableVertexAttribArray(Program::texCoords);
1268 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001269
1270 if (mState.cornerRadius > 0.0f) {
1271 glDisableVertexAttribArray(Program::cropCoords);
1272 }
Mathias Agopian3f844832013-08-07 21:24:32 -07001273}
1274
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001275size_t GLESRenderEngine::getMaxTextureSize() const {
Peiyong Linf1bada92018-08-29 09:39:31 -07001276 return mMaxTextureSize;
1277}
1278
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001279size_t GLESRenderEngine::getMaxViewportDims() const {
Peiyong Linf1bada92018-08-29 09:39:31 -07001280 return mMaxViewportDims[0] < mMaxViewportDims[1] ? mMaxViewportDims[0] : mMaxViewportDims[1];
1281}
1282
Yiwei Zhang5434a782018-12-05 18:06:32 -08001283void GLESRenderEngine::dump(std::string& result) {
Peiyong Linf11f39b2018-09-05 14:37:41 -07001284 const GLExtensions& extensions = GLExtensions::getInstance();
Peiyong Linfb530cf2018-12-15 05:07:38 +00001285 ProgramCache& cache = ProgramCache::getInstance();
Peiyong Linf11f39b2018-09-05 14:37:41 -07001286
Yiwei Zhang5434a782018-12-05 18:06:32 -08001287 StringAppendF(&result, "EGL implementation : %s\n", extensions.getEGLVersion());
1288 StringAppendF(&result, "%s\n", extensions.getEGLExtensions());
Yiwei Zhang5434a782018-12-05 18:06:32 -08001289 StringAppendF(&result, "GLES: %s, %s, %s\n", extensions.getVendor(), extensions.getRenderer(),
1290 extensions.getVersion());
1291 StringAppendF(&result, "%s\n", extensions.getExtensions());
Peiyong Linfb530cf2018-12-15 05:07:38 +00001292 StringAppendF(&result, "RenderEngine is in protected context : %d\n", mInProtectedContext);
1293 StringAppendF(&result, "RenderEngine program cache size for unprotected context: %zu\n",
1294 cache.getSize(mEGLContext));
1295 StringAppendF(&result, "RenderEngine program cache size for protected context: %zu\n",
1296 cache.getSize(mProtectedEGLContext));
Yiwei Zhang5434a782018-12-05 18:06:32 -08001297 StringAppendF(&result, "RenderEngine last dataspace conversion: (%s) to (%s)\n",
1298 dataspaceDetails(static_cast<android_dataspace>(mDataSpace)).c_str(),
1299 dataspaceDetails(static_cast<android_dataspace>(mOutputDataSpace)).c_str());
Mathias Agopian3f844832013-08-07 21:24:32 -07001300}
1301
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001302GLESRenderEngine::GlesVersion GLESRenderEngine::parseGlesVersion(const char* str) {
Peiyong Linf11f39b2018-09-05 14:37:41 -07001303 int major, minor;
1304 if (sscanf(str, "OpenGL ES-CM %d.%d", &major, &minor) != 2) {
1305 if (sscanf(str, "OpenGL ES %d.%d", &major, &minor) != 2) {
1306 ALOGW("Unable to parse GL_VERSION string: \"%s\"", str);
1307 return GLES_VERSION_1_0;
1308 }
1309 }
1310
1311 if (major == 1 && minor == 0) return GLES_VERSION_1_0;
1312 if (major == 1 && minor >= 1) return GLES_VERSION_1_1;
1313 if (major == 2 && minor >= 0) return GLES_VERSION_2_0;
1314 if (major == 3 && minor >= 0) return GLES_VERSION_3_0;
1315
1316 ALOGW("Unrecognized OpenGL ES version: %d.%d", major, minor);
1317 return GLES_VERSION_1_0;
1318}
1319
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001320EGLContext GLESRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,
Peiyong Linfb530cf2018-12-15 05:07:38 +00001321 EGLContext shareContext, bool useContextPriority,
1322 Protection protection) {
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001323 EGLint renderableType = 0;
1324 if (config == EGL_NO_CONFIG) {
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001325 renderableType = EGL_OPENGL_ES3_BIT;
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001326 } else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) {
1327 LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");
1328 }
1329 EGLint contextClientVersion = 0;
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001330 if (renderableType & EGL_OPENGL_ES3_BIT) {
1331 contextClientVersion = 3;
1332 } else if (renderableType & EGL_OPENGL_ES2_BIT) {
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001333 contextClientVersion = 2;
1334 } else if (renderableType & EGL_OPENGL_ES_BIT) {
1335 contextClientVersion = 1;
1336 } else {
1337 LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs");
1338 }
1339
1340 std::vector<EGLint> contextAttributes;
Peiyong Linfb530cf2018-12-15 05:07:38 +00001341 contextAttributes.reserve(7);
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001342 contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
1343 contextAttributes.push_back(contextClientVersion);
1344 if (useContextPriority) {
1345 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG);
1346 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG);
1347 }
Peiyong Linfb530cf2018-12-15 05:07:38 +00001348 if (protection == Protection::PROTECTED) {
1349 contextAttributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1350 contextAttributes.push_back(EGL_TRUE);
1351 }
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001352 contextAttributes.push_back(EGL_NONE);
1353
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001354 EGLContext context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1355
1356 if (contextClientVersion == 3 && context == EGL_NO_CONTEXT) {
1357 // eglGetConfigAttrib indicated we can create GLES 3 context, but we failed, thus
1358 // EGL_NO_CONTEXT so that we can abort.
1359 if (config != EGL_NO_CONFIG) {
1360 return context;
1361 }
1362 // If |config| is EGL_NO_CONFIG, we speculatively try to create GLES 3 context, so we should
1363 // try to fall back to GLES 2.
1364 contextAttributes[1] = 2;
1365 context = eglCreateContext(display, config, shareContext, contextAttributes.data());
1366 }
1367
1368 return context;
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001369}
1370
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001371EGLSurface GLESRenderEngine::createDummyEglPbufferSurface(EGLDisplay display, EGLConfig config,
Peiyong Linfb530cf2018-12-15 05:07:38 +00001372 int hwcFormat, Protection protection) {
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001373 EGLConfig dummyConfig = config;
1374 if (dummyConfig == EGL_NO_CONFIG) {
1375 dummyConfig = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);
1376 }
1377 std::vector<EGLint> attributes;
Peiyong Linfb530cf2018-12-15 05:07:38 +00001378 attributes.reserve(7);
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001379 attributes.push_back(EGL_WIDTH);
1380 attributes.push_back(1);
1381 attributes.push_back(EGL_HEIGHT);
1382 attributes.push_back(1);
Peiyong Linfb530cf2018-12-15 05:07:38 +00001383 if (protection == Protection::PROTECTED) {
1384 attributes.push_back(EGL_PROTECTED_CONTENT_EXT);
1385 attributes.push_back(EGL_TRUE);
1386 }
Peiyong Lina5e9f1b2018-11-27 22:49:37 -08001387 attributes.push_back(EGL_NONE);
1388
1389 return eglCreatePbufferSurface(display, dummyConfig, attributes.data());
1390}
1391
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001392bool GLESRenderEngine::isHdrDataSpace(const Dataspace dataSpace) const {
Peiyong Lina296b0c2018-04-30 16:55:29 -07001393 const Dataspace standard = static_cast<Dataspace>(dataSpace & Dataspace::STANDARD_MASK);
1394 const Dataspace transfer = static_cast<Dataspace>(dataSpace & Dataspace::TRANSFER_MASK);
1395 return standard == Dataspace::STANDARD_BT2020 &&
Peiyong Lin46080ef2018-10-26 18:43:14 -07001396 (transfer == Dataspace::TRANSFER_ST2084 || transfer == Dataspace::TRANSFER_HLG);
Peiyong Lina296b0c2018-04-30 16:55:29 -07001397}
1398
1399// For convenience, we want to convert the input color space to XYZ color space first,
1400// and then convert from XYZ color space to output color space when
1401// - SDR and HDR contents are mixed, either SDR content will be converted to HDR or
1402// HDR content will be tone-mapped to SDR; Or,
1403// - there are HDR PQ and HLG contents presented at the same time, where we want to convert
1404// HLG content to PQ content.
1405// In either case above, we need to operate the Y value in XYZ color space. Thus, when either
1406// input data space or output data space is HDR data space, and the input transfer function
1407// doesn't match the output transfer function, we would enable an intermediate transfrom to
1408// XYZ color space.
Peiyong Lin7e219eb2018-12-03 05:40:42 -08001409bool GLESRenderEngine::needsXYZTransformMatrix() const {
Peiyong Lina296b0c2018-04-30 16:55:29 -07001410 const bool isInputHdrDataSpace = isHdrDataSpace(mDataSpace);
1411 const bool isOutputHdrDataSpace = isHdrDataSpace(mOutputDataSpace);
1412 const Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK);
Peiyong Lin46080ef2018-10-26 18:43:14 -07001413 const Dataspace outputTransfer =
1414 static_cast<Dataspace>(mOutputDataSpace & Dataspace::TRANSFER_MASK);
Peiyong Lina296b0c2018-04-30 16:55:29 -07001415
1416 return (isInputHdrDataSpace || isOutputHdrDataSpace) && inputTransfer != outputTransfer;
1417}
1418
Alec Mourid43ccab2019-03-13 12:23:45 -07001419bool GLESRenderEngine::isImageCachedForTesting(uint64_t bufferId) {
1420 std::lock_guard<std::mutex> lock(mRenderingMutex);
1421 const auto& cachedImage = mImageCache.find(bufferId);
1422 return cachedImage != mImageCache.end();
1423}
1424
1425bool GLESRenderEngine::isFramebufferImageCachedForTesting(uint64_t bufferId) {
1426 std::lock_guard<std::mutex> lock(mRenderingMutex);
1427 return std::any_of(mFramebufferImageCache.cbegin(), mFramebufferImageCache.cend(),
1428 [=](std::pair<uint64_t, EGLImageKHR> image) {
1429 return image.first == bufferId;
1430 });
1431}
1432
Alec Mouri554d06e2018-12-20 00:15:33 -08001433// FlushTracer implementation
1434GLESRenderEngine::FlushTracer::FlushTracer(GLESRenderEngine* engine) : mEngine(engine) {
1435 mThread = std::thread(&GLESRenderEngine::FlushTracer::loop, this);
1436}
1437
1438GLESRenderEngine::FlushTracer::~FlushTracer() {
1439 {
1440 std::lock_guard<std::mutex> lock(mMutex);
1441 mRunning = false;
1442 }
1443 mCondition.notify_all();
1444 if (mThread.joinable()) {
1445 mThread.join();
1446 }
1447}
1448
1449void GLESRenderEngine::FlushTracer::queueSync(EGLSyncKHR sync) {
1450 std::lock_guard<std::mutex> lock(mMutex);
1451 char name[64];
1452 const uint64_t frameNum = mFramesQueued++;
1453 snprintf(name, sizeof(name), "Queueing sync for frame: %lu",
1454 static_cast<unsigned long>(frameNum));
1455 ATRACE_NAME(name);
1456 mQueue.push({sync, frameNum});
1457 ATRACE_INT("GPU Frames Outstanding", mQueue.size());
1458 mCondition.notify_one();
1459}
1460
1461void GLESRenderEngine::FlushTracer::loop() {
1462 while (mRunning) {
1463 QueueEntry entry;
1464 {
1465 std::lock_guard<std::mutex> lock(mMutex);
1466
1467 mCondition.wait(mMutex,
Alec Mouric15dd012019-01-15 15:30:38 -08001468 [&]() REQUIRES(mMutex) { return !mQueue.empty() || !mRunning; });
Alec Mouri554d06e2018-12-20 00:15:33 -08001469
1470 if (!mRunning) {
1471 // if mRunning is false, then FlushTracer is being destroyed, so
1472 // bail out now.
1473 break;
1474 }
1475 entry = mQueue.front();
1476 mQueue.pop();
1477 }
1478 {
1479 char name[64];
1480 snprintf(name, sizeof(name), "waiting for frame %lu",
1481 static_cast<unsigned long>(entry.mFrameNum));
1482 ATRACE_NAME(name);
1483 mEngine->waitSync(entry.mSync, 0);
1484 }
1485 }
1486}
1487
Peiyong Lin46080ef2018-10-26 18:43:14 -07001488} // namespace gl
1489} // namespace renderengine
1490} // namespace android