2 * Copyright 2013 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <ui/Region.h>
21 #include "RenderEngine.h"
22 #include "GLES20RenderEngine.h"
23 #include "GLExtensions.h"
27 #include <SurfaceFlinger.h>
29 EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
31 // ---------------------------------------------------------------------------
33 // ---------------------------------------------------------------------------
35 static bool findExtension(const char* exts, const char* name) {
38 size_t len = strlen(name);
40 const char* pos = exts;
41 while ((pos = strstr(pos, name)) != NULL) {
42 if (pos[len] == '\0' || pos[len] == ' ')
50 RenderEngine* RenderEngine::create(EGLDisplay display, int hwcFormat) {
51 // EGL_ANDROIDX_no_config_context is an experimental extension with no
52 // written specification. It will be replaced by something more formal.
53 // SurfaceFlinger is using it to allow a single EGLContext to render to
54 // both a 16-bit primary display framebuffer and a 32-bit virtual display
57 // EGL_KHR_no_config_context is official extension to allow creating a
58 // context that works with any surface of a display.
60 // The code assumes that ES2 or later is available if this extension is
62 EGLConfig config = EGL_NO_CONFIG;
63 if (!findExtension(eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS),
64 "EGL_ANDROIDX_no_config_context") &&
65 !findExtension(eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS),
66 "EGL_KHR_no_config_context")) {
67 config = chooseEglConfig(display, hwcFormat);
70 EGLint renderableType = 0;
71 if (config == EGL_NO_CONFIG) {
72 renderableType = EGL_OPENGL_ES2_BIT;
73 } else if (!eglGetConfigAttrib(display, config,
74 EGL_RENDERABLE_TYPE, &renderableType)) {
75 LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");
77 EGLint contextClientVersion = 0;
78 if (renderableType & EGL_OPENGL_ES2_BIT) {
79 contextClientVersion = 2;
80 } else if (renderableType & EGL_OPENGL_ES_BIT) {
81 contextClientVersion = 1;
83 LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs");
86 std::vector<EGLint> contextAttributes;
87 contextAttributes.reserve(6);
88 contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION);
89 contextAttributes.push_back(contextClientVersion);
90 #ifdef EGL_IMG_context_priority
91 if (SurfaceFlinger::useContextPriority) {
92 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG);
93 contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG);
96 contextAttributes.push_back(EGL_NONE);
97 contextAttributes.push_back(EGL_NONE);
99 EGLContext ctxt = eglCreateContext(display, config, NULL,
100 contextAttributes.data());
102 // if can't create a GL context, we can only abort.
103 LOG_ALWAYS_FATAL_IF(ctxt==EGL_NO_CONTEXT, "EGLContext creation failed");
106 // now figure out what version of GL did we actually get
107 // NOTE: a dummy surface is not needed if KHR_create_context is supported
109 EGLConfig dummyConfig = config;
110 if (dummyConfig == EGL_NO_CONFIG) {
111 dummyConfig = chooseEglConfig(display, hwcFormat);
113 EGLint attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE, EGL_NONE };
114 EGLSurface dummy = eglCreatePbufferSurface(display, dummyConfig, attribs);
115 LOG_ALWAYS_FATAL_IF(dummy==EGL_NO_SURFACE, "can't create dummy pbuffer");
116 EGLBoolean success = eglMakeCurrent(display, dummy, dummy, ctxt);
117 LOG_ALWAYS_FATAL_IF(!success, "can't make dummy pbuffer current");
119 GLExtensions& extensions(GLExtensions::getInstance());
120 extensions.initWithGLStrings(
121 glGetString(GL_VENDOR),
122 glGetString(GL_RENDERER),
123 glGetString(GL_VERSION),
124 glGetString(GL_EXTENSIONS));
126 GlesVersion version = parseGlesVersion( extensions.getVersion() );
128 // initialize the renderer while GL is current
130 RenderEngine* engine = NULL;
132 case GLES_VERSION_1_0:
133 case GLES_VERSION_1_1:
134 LOG_ALWAYS_FATAL("SurfaceFlinger requires OpenGL ES 2.0 minimum to run.");
136 case GLES_VERSION_2_0:
137 case GLES_VERSION_3_0:
138 engine = new GLES20RenderEngine();
141 engine->setEGLHandles(config, ctxt);
143 ALOGI("OpenGL ES informations:");
144 ALOGI("vendor : %s", extensions.getVendor());
145 ALOGI("renderer : %s", extensions.getRenderer());
146 ALOGI("version : %s", extensions.getVersion());
147 ALOGI("extensions: %s", extensions.getExtension());
148 ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize());
149 ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims());
151 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
152 eglDestroySurface(display, dummy);
157 RenderEngine::RenderEngine() : mEGLConfig(NULL), mEGLContext(EGL_NO_CONTEXT) {
160 RenderEngine::~RenderEngine() {
163 void RenderEngine::setEGLHandles(EGLConfig config, EGLContext ctxt) {
168 EGLContext RenderEngine::getEGLConfig() const {
172 EGLContext RenderEngine::getEGLContext() const {
176 void RenderEngine::checkErrors() const {
178 // there could be more than one error flag
179 GLenum error = glGetError();
180 if (error == GL_NO_ERROR)
182 ALOGE("GL error 0x%04x", int(error));
186 RenderEngine::GlesVersion RenderEngine::parseGlesVersion(const char* str) {
188 if (sscanf(str, "OpenGL ES-CM %d.%d", &major, &minor) != 2) {
189 if (sscanf(str, "OpenGL ES %d.%d", &major, &minor) != 2) {
190 ALOGW("Unable to parse GL_VERSION string: \"%s\"", str);
191 return GLES_VERSION_1_0;
195 if (major == 1 && minor == 0) return GLES_VERSION_1_0;
196 if (major == 1 && minor >= 1) return GLES_VERSION_1_1;
197 if (major == 2 && minor >= 0) return GLES_VERSION_2_0;
198 if (major == 3 && minor >= 0) return GLES_VERSION_3_0;
200 ALOGW("Unrecognized OpenGL ES version: %d.%d", major, minor);
201 return GLES_VERSION_1_0;
204 void RenderEngine::fillRegionWithColor(const Region& region, uint32_t height,
205 float red, float green, float blue, float alpha) {
207 Rect const* r = region.getArray(&c);
208 Mesh mesh(Mesh::TRIANGLES, c*6, 2);
209 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
210 for (size_t i=0 ; i<c ; i++, r++) {
211 position[i*6 + 0].x = r->left;
212 position[i*6 + 0].y = height - r->top;
213 position[i*6 + 1].x = r->left;
214 position[i*6 + 1].y = height - r->bottom;
215 position[i*6 + 2].x = r->right;
216 position[i*6 + 2].y = height - r->bottom;
217 position[i*6 + 3].x = r->left;
218 position[i*6 + 3].y = height - r->top;
219 position[i*6 + 4].x = r->right;
220 position[i*6 + 4].y = height - r->bottom;
221 position[i*6 + 5].x = r->right;
222 position[i*6 + 5].y = height - r->top;
224 setupFillWithColor(red, green, blue, alpha);
228 void RenderEngine::flush() {
232 void RenderEngine::clearWithColor(float red, float green, float blue, float alpha) {
233 glClearColor(red, green, blue, alpha);
234 glClear(GL_COLOR_BUFFER_BIT);
237 void RenderEngine::setScissor(
238 uint32_t left, uint32_t bottom, uint32_t right, uint32_t top) {
239 glScissor(left, bottom, right, top);
240 glEnable(GL_SCISSOR_TEST);
243 void RenderEngine::disableScissor() {
244 glDisable(GL_SCISSOR_TEST);
247 void RenderEngine::genTextures(size_t count, uint32_t* names) {
248 glGenTextures(count, names);
251 void RenderEngine::deleteTextures(size_t count, uint32_t const* names) {
252 glDeleteTextures(count, names);
255 void RenderEngine::readPixels(size_t l, size_t b, size_t w, size_t h, uint32_t* pixels) {
256 glReadPixels(l, b, w, h, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
259 void RenderEngine::dump(String8& result) {
260 const GLExtensions& extensions(GLExtensions::getInstance());
261 result.appendFormat("GLES: %s, %s, %s\n",
262 extensions.getVendor(),
263 extensions.getRenderer(),
264 extensions.getVersion());
265 result.appendFormat("%s\n", extensions.getExtension());
268 // ---------------------------------------------------------------------------
270 RenderEngine::BindImageAsFramebuffer::BindImageAsFramebuffer(
271 RenderEngine& engine, EGLImageKHR image) : mEngine(engine)
273 mEngine.bindImageAsFramebuffer(image, &mTexName, &mFbName, &mStatus);
275 ALOGE_IF(mStatus != GL_FRAMEBUFFER_COMPLETE_OES,
276 "glCheckFramebufferStatusOES error %d", mStatus);
279 RenderEngine::BindImageAsFramebuffer::~BindImageAsFramebuffer() {
280 // back to main framebuffer
281 mEngine.unbindFramebuffer(mTexName, mFbName);
284 status_t RenderEngine::BindImageAsFramebuffer::getStatus() const {
285 return mStatus == GL_FRAMEBUFFER_COMPLETE_OES ? NO_ERROR : BAD_VALUE;
288 // ---------------------------------------------------------------------------
290 static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs,
291 EGLint attribute, EGLint wanted, EGLConfig* outConfig) {
292 EGLint numConfigs = -1, n = 0;
293 eglGetConfigs(dpy, NULL, 0, &numConfigs);
294 EGLConfig* const configs = new EGLConfig[numConfigs];
295 eglChooseConfig(dpy, attrs, configs, numConfigs, &n);
298 if (attribute != EGL_NONE) {
299 for (int i=0 ; i<n ; i++) {
301 eglGetConfigAttrib(dpy, configs[i], attribute, &value);
302 if (wanted == value) {
303 *outConfig = configs[i];
309 // just pick the first one
310 *outConfig = configs[0];
316 return NAME_NOT_FOUND;
319 class EGLAttributeVector {
323 KeyedVector<Attribute, EGLint> mList;
325 Attribute() : v(0) {};
326 explicit Attribute(EGLint v) : v(v) { }
328 bool operator < (const Attribute& other) const {
329 // this places EGL_NONE at the end
332 if (lhs == EGL_NONE) lhs = 0x7FFFFFFF;
333 if (rhs == EGL_NONE) rhs = 0x7FFFFFFF;
338 friend class EGLAttributeVector;
339 EGLAttributeVector& v;
341 Adder(EGLAttributeVector& v, EGLint attribute)
342 : v(v), attribute(attribute) {
345 void operator = (EGLint value) {
346 if (attribute != EGL_NONE) {
347 v.mList.add(Attribute(attribute), value);
350 operator EGLint () const { return v.mList[attribute]; }
353 EGLAttributeVector() {
354 mList.add(Attribute(EGL_NONE), EGL_NONE);
356 void remove(EGLint attribute) {
357 if (attribute != EGL_NONE) {
358 mList.removeItem(Attribute(attribute));
361 Adder operator [] (EGLint attribute) {
362 return Adder(*this, attribute);
364 EGLint operator [] (EGLint attribute) const {
365 return mList[attribute];
367 // cast-operator to (EGLint const*)
368 operator EGLint const* () const { return &mList.keyAt(0).v; }
372 static status_t selectEGLConfig(EGLDisplay display, EGLint format,
373 EGLint renderableType, EGLConfig* config) {
374 // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if
375 // it is to be used with WIFI displays
377 EGLint wantedAttribute;
378 EGLint wantedAttributeValue;
380 EGLAttributeVector attribs;
381 if (renderableType) {
382 attribs[EGL_RENDERABLE_TYPE] = renderableType;
383 attribs[EGL_RECORDABLE_ANDROID] = EGL_TRUE;
384 attribs[EGL_SURFACE_TYPE] = EGL_WINDOW_BIT|EGL_PBUFFER_BIT;
385 attribs[EGL_FRAMEBUFFER_TARGET_ANDROID] = EGL_TRUE;
386 attribs[EGL_RED_SIZE] = 8;
387 attribs[EGL_GREEN_SIZE] = 8;
388 attribs[EGL_BLUE_SIZE] = 8;
389 attribs[EGL_ALPHA_SIZE] = 8;
390 wantedAttribute = EGL_NONE;
391 wantedAttributeValue = EGL_NONE;
393 // if no renderable type specified, fallback to a simplified query
394 wantedAttribute = EGL_NATIVE_VISUAL_ID;
395 wantedAttributeValue = format;
398 err = selectConfigForAttribute(display, attribs,
399 wantedAttribute, wantedAttributeValue, config);
400 if (err == NO_ERROR) {
402 if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat))
403 ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!");
409 EGLConfig RenderEngine::chooseEglConfig(EGLDisplay display, int format) {
413 // First try to get an ES2 config
414 err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);
415 if (err != NO_ERROR) {
416 // If ES2 fails, try ES1
417 err = selectEGLConfig(display, format, EGL_OPENGL_ES_BIT, &config);
418 if (err != NO_ERROR) {
419 // still didn't work, probably because we're on the emulator...
420 // try a simplified query
421 ALOGW("no suitable EGLConfig found, trying a simpler query");
422 err = selectEGLConfig(display, format, 0, &config);
423 if (err != NO_ERROR) {
424 // this EGL is too lame for android
425 LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up");
430 // print some debugging info
432 eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r);
433 eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
434 eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);
435 eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);
436 ALOGI("EGL information:");
437 ALOGI("vendor : %s", eglQueryString(display, EGL_VENDOR));
438 ALOGI("version : %s", eglQueryString(display, EGL_VERSION));
439 ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS));
440 ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS)?:"Not Supported");
441 ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);
447 void RenderEngine::primeCache() const {
448 // Getting the ProgramCache instance causes it to prime its shader cache,
449 // which is performed in its constructor
450 ProgramCache::getInstance();
453 // ---------------------------------------------------------------------------
454 }; // namespace android
455 // ---------------------------------------------------------------------------