services/surfaceflinger/RenderEngine/RenderEngine.cpp

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