RenderEngine.cpp revision c03d283e8b3f830d76dd94822b2a13872c05c730
1/* 2 * Copyright 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include <android/log.h> 18#include <ui/Rect.h> 19#include <ui/Region.h> 20 21#include "RenderEngine.h" 22#include "GLES20RenderEngine.h" 23#include "GLExtensions.h" 24#include "Mesh.h" 25 26EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name); 27 28// --------------------------------------------------------------------------- 29namespace android { 30// --------------------------------------------------------------------------- 31 32static bool findExtension(const char* exts, const char* name) { 33 if (!exts) 34 return false; 35 size_t len = strlen(name); 36 37 const char* pos = exts; 38 while ((pos = strstr(pos, name)) != NULL) { 39 if (pos[len] == '\0' || pos[len] == ' ') 40 return true; 41 pos += len; 42 } 43 44 return false; 45} 46 47RenderEngine* RenderEngine::create(EGLDisplay display, int hwcFormat) { 48 // EGL_ANDROIDX_no_config_context is an experimental extension with no 49 // written specification. It will be replaced by something more formal. 50 // SurfaceFlinger is using it to allow a single EGLContext to render to 51 // both a 16-bit primary display framebuffer and a 32-bit virtual display 52 // framebuffer. 53 // 54 // The code assumes that ES2 or later is available if this extension is 55 // supported. 56 EGLConfig config = EGL_NO_CONFIG; 57 if (!findExtension( 58 eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS), 59 "EGL_ANDROIDX_no_config_context")) { 60 config = chooseEglConfig(display, hwcFormat); 61 } 62 63 EGLint renderableType = 0; 64 if (config == EGL_NO_CONFIG) { 65 renderableType = EGL_OPENGL_ES2_BIT; 66 } else if (!eglGetConfigAttrib(display, config, 67 EGL_RENDERABLE_TYPE, &renderableType)) { 68 LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE"); 69 } 70 EGLint contextClientVersion = 0; 71 if (renderableType & EGL_OPENGL_ES2_BIT) { 72 contextClientVersion = 2; 73 } else if (renderableType & EGL_OPENGL_ES_BIT) { 74 contextClientVersion = 1; 75 } else { 76 LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs"); 77 } 78 79 // Also create our EGLContext 80 EGLint contextAttributes[] = { 81 EGL_CONTEXT_CLIENT_VERSION, contextClientVersion, // MUST be first 82#ifdef EGL_IMG_context_priority 83#ifdef HAS_CONTEXT_PRIORITY 84#warning "using EGL_IMG_context_priority" 85 EGL_CONTEXT_PRIORITY_LEVEL_IMG, EGL_CONTEXT_PRIORITY_HIGH_IMG, 86#endif 87#endif 88 EGL_NONE, EGL_NONE 89 }; 90 EGLContext ctxt = eglCreateContext(display, config, NULL, contextAttributes); 91 92 // if can't create a GL context, we can only abort. 93 LOG_ALWAYS_FATAL_IF(ctxt==EGL_NO_CONTEXT, "EGLContext creation failed"); 94 95 96 // now figure out what version of GL did we actually get 97 // NOTE: a dummy surface is not needed if KHR_create_context is supported 98 99 EGLConfig dummyConfig = config; 100 if (dummyConfig == EGL_NO_CONFIG) { 101 dummyConfig = chooseEglConfig(display, hwcFormat); 102 } 103 EGLint attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE, EGL_NONE }; 104 EGLSurface dummy = eglCreatePbufferSurface(display, dummyConfig, attribs); 105 LOG_ALWAYS_FATAL_IF(dummy==EGL_NO_SURFACE, "can't create dummy pbuffer"); 106 EGLBoolean success = eglMakeCurrent(display, dummy, dummy, ctxt); 107 LOG_ALWAYS_FATAL_IF(!success, "can't make dummy pbuffer current"); 108 109 GLExtensions& extensions(GLExtensions::getInstance()); 110 extensions.initWithGLStrings( 111 glGetString(GL_VENDOR), 112 glGetString(GL_RENDERER), 113 glGetString(GL_VERSION), 114 glGetString(GL_EXTENSIONS)); 115 116 GlesVersion version = parseGlesVersion( extensions.getVersion() ); 117 118 // initialize the renderer while GL is current 119 120 RenderEngine* engine = NULL; 121 switch (version) { 122 case GLES_VERSION_1_0: 123 case GLES_VERSION_1_1: 124 LOG_ALWAYS_FATAL("SurfaceFlinger requires OpenGL ES 2.0 minimum to run."); 125 break; 126 case GLES_VERSION_2_0: 127 case GLES_VERSION_3_0: 128 engine = new GLES20RenderEngine(); 129 break; 130 } 131 engine->setEGLHandles(config, ctxt); 132 133 ALOGI("OpenGL ES informations:"); 134 ALOGI("vendor : %s", extensions.getVendor()); 135 ALOGI("renderer : %s", extensions.getRenderer()); 136 ALOGI("version : %s", extensions.getVersion()); 137 ALOGI("extensions: %s", extensions.getExtension()); 138 ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize()); 139 ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims()); 140 141 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); 142 eglDestroySurface(display, dummy); 143 144 return engine; 145} 146 147RenderEngine::RenderEngine() : mEGLConfig(NULL), mEGLContext(EGL_NO_CONTEXT) { 148} 149 150RenderEngine::~RenderEngine() { 151} 152 153void RenderEngine::setEGLHandles(EGLConfig config, EGLContext ctxt) { 154 mEGLConfig = config; 155 mEGLContext = ctxt; 156} 157 158EGLContext RenderEngine::getEGLConfig() const { 159 return mEGLConfig; 160} 161 162EGLContext RenderEngine::getEGLContext() const { 163 return mEGLContext; 164} 165 166void RenderEngine::checkErrors() const { 167 do { 168 // there could be more than one error flag 169 GLenum error = glGetError(); 170 if (error == GL_NO_ERROR) 171 break; 172 ALOGE("GL error 0x%04x", int(error)); 173 } while (true); 174} 175 176RenderEngine::GlesVersion RenderEngine::parseGlesVersion(const char* str) { 177 int major, minor; 178 if (sscanf(str, "OpenGL ES-CM %d.%d", &major, &minor) != 2) { 179 if (sscanf(str, "OpenGL ES %d.%d", &major, &minor) != 2) { 180 ALOGW("Unable to parse GL_VERSION string: \"%s\"", str); 181 return GLES_VERSION_1_0; 182 } 183 } 184 185 if (major == 1 && minor == 0) return GLES_VERSION_1_0; 186 if (major == 1 && minor >= 1) return GLES_VERSION_1_1; 187 if (major == 2 && minor >= 0) return GLES_VERSION_2_0; 188 if (major == 3 && minor >= 0) return GLES_VERSION_3_0; 189 190 ALOGW("Unrecognized OpenGL ES version: %d.%d", major, minor); 191 return GLES_VERSION_1_0; 192} 193 194void RenderEngine::fillRegionWithColor(const Region& region, uint32_t height, 195 float red, float green, float blue, float alpha) { 196 size_t c; 197 Rect const* r = region.getArray(&c); 198 Mesh mesh(Mesh::TRIANGLES, c*6, 2); 199 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>()); 200 for (size_t i=0 ; i<c ; i++, r++) { 201 position[i*6 + 0].x = r->left; 202 position[i*6 + 0].y = height - r->top; 203 position[i*6 + 1].x = r->left; 204 position[i*6 + 1].y = height - r->bottom; 205 position[i*6 + 2].x = r->right; 206 position[i*6 + 2].y = height - r->bottom; 207 position[i*6 + 3].x = r->left; 208 position[i*6 + 3].y = height - r->top; 209 position[i*6 + 4].x = r->right; 210 position[i*6 + 4].y = height - r->bottom; 211 position[i*6 + 5].x = r->right; 212 position[i*6 + 5].y = height - r->top; 213 } 214 setupFillWithColor(red, green, blue, alpha); 215 drawMesh(mesh); 216} 217 218void RenderEngine::flush() { 219 glFlush(); 220} 221 222void RenderEngine::clearWithColor(float red, float green, float blue, float alpha) { 223 glClearColor(red, green, blue, alpha); 224 glClear(GL_COLOR_BUFFER_BIT); 225} 226 227void RenderEngine::setScissor( 228 uint32_t left, uint32_t bottom, uint32_t right, uint32_t top) { 229 glScissor(left, bottom, right, top); 230 glEnable(GL_SCISSOR_TEST); 231} 232 233void RenderEngine::disableScissor() { 234 glDisable(GL_SCISSOR_TEST); 235} 236 237void RenderEngine::genTextures(size_t count, uint32_t* names) { 238 glGenTextures(count, names); 239} 240 241void RenderEngine::deleteTextures(size_t count, uint32_t const* names) { 242 glDeleteTextures(count, names); 243} 244 245void RenderEngine::readPixels(size_t l, size_t b, size_t w, size_t h, uint32_t* pixels) { 246 glReadPixels(l, b, w, h, GL_RGBA, GL_UNSIGNED_BYTE, pixels); 247} 248 249void RenderEngine::dump(String8& result) { 250 const GLExtensions& extensions(GLExtensions::getInstance()); 251 result.appendFormat("GLES: %s, %s, %s\n", 252 extensions.getVendor(), 253 extensions.getRenderer(), 254 extensions.getVersion()); 255 result.appendFormat("%s\n", extensions.getExtension()); 256} 257 258// --------------------------------------------------------------------------- 259 260RenderEngine::BindImageAsFramebuffer::BindImageAsFramebuffer( 261 RenderEngine& engine, EGLImageKHR image) : mEngine(engine) 262{ 263 mEngine.bindImageAsFramebuffer(image, &mTexName, &mFbName, &mStatus); 264 265 ALOGE_IF(mStatus != GL_FRAMEBUFFER_COMPLETE_OES, 266 "glCheckFramebufferStatusOES error %d", mStatus); 267} 268 269RenderEngine::BindImageAsFramebuffer::~BindImageAsFramebuffer() { 270 // back to main framebuffer 271 mEngine.unbindFramebuffer(mTexName, mFbName); 272} 273 274status_t RenderEngine::BindImageAsFramebuffer::getStatus() const { 275 return mStatus == GL_FRAMEBUFFER_COMPLETE_OES ? NO_ERROR : BAD_VALUE; 276} 277 278// --------------------------------------------------------------------------- 279 280static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs, 281 EGLint attribute, EGLint wanted, EGLConfig* outConfig) { 282 EGLint numConfigs = -1, n = 0; 283 eglGetConfigs(dpy, NULL, 0, &numConfigs); 284 EGLConfig* const configs = new EGLConfig[numConfigs]; 285 eglChooseConfig(dpy, attrs, configs, numConfigs, &n); 286 287 if (n) { 288 if (attribute != EGL_NONE) { 289 for (int i=0 ; i<n ; i++) { 290 EGLint value = 0; 291 eglGetConfigAttrib(dpy, configs[i], attribute, &value); 292 if (wanted == value) { 293 *outConfig = configs[i]; 294 delete [] configs; 295 return NO_ERROR; 296 } 297 } 298 } else { 299 // just pick the first one 300 *outConfig = configs[0]; 301 delete [] configs; 302 return NO_ERROR; 303 } 304 } 305 delete [] configs; 306 return NAME_NOT_FOUND; 307} 308 309class EGLAttributeVector { 310 struct Attribute; 311 class Adder; 312 friend class Adder; 313 KeyedVector<Attribute, EGLint> mList; 314 struct Attribute { 315 Attribute() : v(0) {}; 316 explicit Attribute(EGLint v) : v(v) { } 317 EGLint v; 318 bool operator < (const Attribute& other) const { 319 // this places EGL_NONE at the end 320 EGLint lhs(v); 321 EGLint rhs(other.v); 322 if (lhs == EGL_NONE) lhs = 0x7FFFFFFF; 323 if (rhs == EGL_NONE) rhs = 0x7FFFFFFF; 324 return lhs < rhs; 325 } 326 }; 327 class Adder { 328 friend class EGLAttributeVector; 329 EGLAttributeVector& v; 330 EGLint attribute; 331 Adder(EGLAttributeVector& v, EGLint attribute) 332 : v(v), attribute(attribute) { 333 } 334 public: 335 void operator = (EGLint value) { 336 if (attribute != EGL_NONE) { 337 v.mList.add(Attribute(attribute), value); 338 } 339 } 340 operator EGLint () const { return v.mList[attribute]; } 341 }; 342public: 343 EGLAttributeVector() { 344 mList.add(Attribute(EGL_NONE), EGL_NONE); 345 } 346 void remove(EGLint attribute) { 347 if (attribute != EGL_NONE) { 348 mList.removeItem(Attribute(attribute)); 349 } 350 } 351 Adder operator [] (EGLint attribute) { 352 return Adder(*this, attribute); 353 } 354 EGLint operator [] (EGLint attribute) const { 355 return mList[attribute]; 356 } 357 // cast-operator to (EGLint const*) 358 operator EGLint const* () const { return &mList.keyAt(0).v; } 359}; 360 361 362static status_t selectEGLConfig(EGLDisplay display, EGLint format, 363 EGLint renderableType, EGLConfig* config) { 364 // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if 365 // it is to be used with WIFI displays 366 status_t err; 367 EGLint wantedAttribute; 368 EGLint wantedAttributeValue; 369 370 EGLAttributeVector attribs; 371 if (renderableType) { 372 attribs[EGL_RENDERABLE_TYPE] = renderableType; 373 attribs[EGL_RECORDABLE_ANDROID] = EGL_TRUE; 374 attribs[EGL_SURFACE_TYPE] = EGL_WINDOW_BIT|EGL_PBUFFER_BIT; 375 attribs[EGL_FRAMEBUFFER_TARGET_ANDROID] = EGL_TRUE; 376 attribs[EGL_RED_SIZE] = 8; 377 attribs[EGL_GREEN_SIZE] = 8; 378 attribs[EGL_BLUE_SIZE] = 8; 379 wantedAttribute = EGL_NONE; 380 wantedAttributeValue = EGL_NONE; 381 } else { 382 // if no renderable type specified, fallback to a simplified query 383 wantedAttribute = EGL_NATIVE_VISUAL_ID; 384 wantedAttributeValue = format; 385 } 386 387 err = selectConfigForAttribute(display, attribs, 388 wantedAttribute, wantedAttributeValue, config); 389 if (err == NO_ERROR) { 390 EGLint caveat; 391 if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat)) 392 ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!"); 393 } 394 395 return err; 396} 397 398EGLConfig RenderEngine::chooseEglConfig(EGLDisplay display, int format) { 399 status_t err; 400 EGLConfig config; 401 402 // First try to get an ES2 config 403 err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config); 404 if (err != NO_ERROR) { 405 // If ES2 fails, try ES1 406 err = selectEGLConfig(display, format, EGL_OPENGL_ES_BIT, &config); 407 if (err != NO_ERROR) { 408 // still didn't work, probably because we're on the emulator... 409 // try a simplified query 410 ALOGW("no suitable EGLConfig found, trying a simpler query"); 411 err = selectEGLConfig(display, format, 0, &config); 412 if (err != NO_ERROR) { 413 // this EGL is too lame for android 414 LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up"); 415 } 416 } 417 } 418 419 // print some debugging info 420 EGLint r,g,b,a; 421 eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r); 422 eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g); 423 eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b); 424 eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a); 425 ALOGI("EGL information:"); 426 ALOGI("vendor : %s", eglQueryString(display, EGL_VENDOR)); 427 ALOGI("version : %s", eglQueryString(display, EGL_VERSION)); 428 ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS)); 429 ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS)?:"Not Supported"); 430 ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config); 431 432 return config; 433} 434 435 436void RenderEngine::primeCache() const { 437 // Getting the ProgramCache instance causes it to prime its shader cache, 438 // which is performed in its constructor 439 ProgramCache::getInstance(); 440} 441 442// --------------------------------------------------------------------------- 443}; // namespace android 444// --------------------------------------------------------------------------- 445