Home | History | Annotate | Download | only in renderthread 
      1 /*
      2  * Copyright (C) 2014 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 "EglManager.h"
     18 
     19 #include <cutils/log.h>
     20 #include <cutils/properties.h>
     21 
     22 #include "../RenderState.h"
     23 #include "RenderThread.h"
     24 
     25 #define PROPERTY_RENDER_DIRTY_REGIONS "debug.hwui.render_dirty_regions"
     26 #define GLES_VERSION 2
     27 
     28 // Android-specific addition that is used to show when frames began in systrace
     29 EGLAPI void EGLAPIENTRY eglBeginFrame(EGLDisplay dpy, EGLSurface surface);
     30 
     31 namespace android {
     32 namespace uirenderer {
     33 namespace renderthread {
     34 
     35 #define ERROR_CASE(x) case x: return #x;
     36 static const char* egl_error_str(EGLint error) {
     37     switch (error) {
     38         ERROR_CASE(EGL_SUCCESS)
     39         ERROR_CASE(EGL_NOT_INITIALIZED)
     40         ERROR_CASE(EGL_BAD_ACCESS)
     41         ERROR_CASE(EGL_BAD_ALLOC)
     42         ERROR_CASE(EGL_BAD_ATTRIBUTE)
     43         ERROR_CASE(EGL_BAD_CONFIG)
     44         ERROR_CASE(EGL_BAD_CONTEXT)
     45         ERROR_CASE(EGL_BAD_CURRENT_SURFACE)
     46         ERROR_CASE(EGL_BAD_DISPLAY)
     47         ERROR_CASE(EGL_BAD_MATCH)
     48         ERROR_CASE(EGL_BAD_NATIVE_PIXMAP)
     49         ERROR_CASE(EGL_BAD_NATIVE_WINDOW)
     50         ERROR_CASE(EGL_BAD_PARAMETER)
     51         ERROR_CASE(EGL_BAD_SURFACE)
     52         ERROR_CASE(EGL_CONTEXT_LOST)
     53     default:
     54         return "Unknown error";
     55     }
     56 }
     57 static const char* egl_error_str() {
     58     return egl_error_str(eglGetError());
     59 }
     60 
     61 static bool load_dirty_regions_property() {
     62     char buf[PROPERTY_VALUE_MAX];
     63     int len = property_get(PROPERTY_RENDER_DIRTY_REGIONS, buf, "true");
     64     return !strncasecmp("true", buf, len);
     65 }
     66 
     67 EglManager::EglManager(RenderThread& thread)
     68         : mRenderThread(thread)
     69         , mEglDisplay(EGL_NO_DISPLAY)
     70         , mEglConfig(0)
     71         , mEglContext(EGL_NO_CONTEXT)
     72         , mPBufferSurface(EGL_NO_SURFACE)
     73         , mAllowPreserveBuffer(load_dirty_regions_property())
     74         , mCurrentSurface(EGL_NO_SURFACE)
     75         , mAtlasMap(NULL)
     76         , mAtlasMapSize(0)
     77         , mInFrame(false) {
     78     mCanSetPreserveBuffer = mAllowPreserveBuffer;
     79     ALOGD("Use EGL_SWAP_BEHAVIOR_PRESERVED: %s", mAllowPreserveBuffer ? "true" : "false");
     80 }
     81 
     82 void EglManager::initialize() {
     83     if (hasEglContext()) return;
     84 
     85     ATRACE_NAME("Creating EGLContext");
     86 
     87     mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
     88     LOG_ALWAYS_FATAL_IF(mEglDisplay == EGL_NO_DISPLAY,
     89             "Failed to get EGL_DEFAULT_DISPLAY! err=%s", egl_error_str());
     90 
     91     EGLint major, minor;
     92     LOG_ALWAYS_FATAL_IF(eglInitialize(mEglDisplay, &major, &minor) == EGL_FALSE,
     93             "Failed to initialize display %p! err=%s", mEglDisplay, egl_error_str());
     94 
     95     ALOGI("Initialized EGL, version %d.%d", (int)major, (int)minor);
     96 
     97     loadConfig();
     98     createContext();
     99     usePBufferSurface();
    100     mRenderThread.renderState().onGLContextCreated();
    101     initAtlas();
    102 }
    103 
    104 bool EglManager::hasEglContext() {
    105     return mEglDisplay != EGL_NO_DISPLAY;
    106 }
    107 
    108 void EglManager::requireGlContext() {
    109     LOG_ALWAYS_FATAL_IF(mEglDisplay == EGL_NO_DISPLAY, "No EGL context");
    110 
    111     if (!mInFrame) {
    112         // We can't be certain about the state of the current surface (whether
    113         // or not it is destroyed, for example), so err on the side of using
    114         // the pbuffer surface which we fully control
    115         usePBufferSurface();
    116     }
    117 }
    118 
    119 void EglManager::loadConfig() {
    120     EGLint swapBehavior = mCanSetPreserveBuffer ? EGL_SWAP_BEHAVIOR_PRESERVED_BIT : 0;
    121     EGLint attribs[] = {
    122             EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
    123             EGL_RED_SIZE, 8,
    124             EGL_GREEN_SIZE, 8,
    125             EGL_BLUE_SIZE, 8,
    126             EGL_ALPHA_SIZE, 8,
    127             EGL_DEPTH_SIZE, 0,
    128             EGL_CONFIG_CAVEAT, EGL_NONE,
    129             EGL_STENCIL_SIZE, Stencil::getStencilSize(),
    130             EGL_SURFACE_TYPE, EGL_WINDOW_BIT | swapBehavior,
    131             EGL_NONE
    132     };
    133 
    134     EGLint num_configs = 1;
    135     if (!eglChooseConfig(mEglDisplay, attribs, &mEglConfig, num_configs, &num_configs)
    136             || num_configs != 1) {
    137         // Failed to get a valid config
    138         if (mCanSetPreserveBuffer) {
    139             ALOGW("Failed to choose config with EGL_SWAP_BEHAVIOR_PRESERVED, retrying without...");
    140             // Try again without dirty regions enabled
    141             mCanSetPreserveBuffer = false;
    142             loadConfig();
    143         } else {
    144             LOG_ALWAYS_FATAL("Failed to choose config, error = %s", egl_error_str());
    145         }
    146     }
    147 }
    148 
    149 void EglManager::createContext() {
    150     EGLint attribs[] = { EGL_CONTEXT_CLIENT_VERSION, GLES_VERSION, EGL_NONE };
    151     mEglContext = eglCreateContext(mEglDisplay, mEglConfig, EGL_NO_CONTEXT, attribs);
    152     LOG_ALWAYS_FATAL_IF(mEglContext == EGL_NO_CONTEXT,
    153         "Failed to create context, error = %s", egl_error_str());
    154 }
    155 
    156 void EglManager::setTextureAtlas(const sp<GraphicBuffer>& buffer,
    157         int64_t* map, size_t mapSize) {
    158 
    159     // Already initialized
    160     if (mAtlasBuffer.get()) {
    161         ALOGW("Multiple calls to setTextureAtlas!");
    162         delete map;
    163         return;
    164     }
    165 
    166     mAtlasBuffer = buffer;
    167     mAtlasMap = map;
    168     mAtlasMapSize = mapSize;
    169 
    170     if (hasEglContext()) {
    171         usePBufferSurface();
    172         initAtlas();
    173     }
    174 }
    175 
    176 void EglManager::initAtlas() {
    177     if (mAtlasBuffer.get()) {
    178         mRenderThread.renderState().assetAtlas().init(mAtlasBuffer,
    179                 mAtlasMap, mAtlasMapSize);
    180     }
    181 }
    182 
    183 void EglManager::usePBufferSurface() {
    184     LOG_ALWAYS_FATAL_IF(mEglDisplay == EGL_NO_DISPLAY,
    185             "usePBufferSurface() called on uninitialized GlobalContext!");
    186 
    187     if (mPBufferSurface == EGL_NO_SURFACE) {
    188         EGLint attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE };
    189         mPBufferSurface = eglCreatePbufferSurface(mEglDisplay, mEglConfig, attribs);
    190     }
    191     makeCurrent(mPBufferSurface);
    192 }
    193 
    194 EGLSurface EglManager::createSurface(EGLNativeWindowType window) {
    195     initialize();
    196     EGLSurface surface = eglCreateWindowSurface(mEglDisplay, mEglConfig, window, NULL);
    197     LOG_ALWAYS_FATAL_IF(surface == EGL_NO_SURFACE,
    198             "Failed to create EGLSurface for window %p, eglErr = %s",
    199             (void*) window, egl_error_str());
    200     return surface;
    201 }
    202 
    203 void EglManager::destroySurface(EGLSurface surface) {
    204     if (isCurrent(surface)) {
    205         makeCurrent(EGL_NO_SURFACE);
    206     }
    207     if (!eglDestroySurface(mEglDisplay, surface)) {
    208         ALOGW("Failed to destroy surface %p, error=%s", (void*)surface, egl_error_str());
    209     }
    210 }
    211 
    212 void EglManager::destroy() {
    213     if (mEglDisplay == EGL_NO_DISPLAY) return;
    214 
    215     usePBufferSurface();
    216     if (Caches::hasInstance()) {
    217         Caches::getInstance().terminate();
    218     }
    219 
    220     mRenderThread.renderState().onGLContextDestroyed();
    221     eglDestroyContext(mEglDisplay, mEglContext);
    222     eglDestroySurface(mEglDisplay, mPBufferSurface);
    223     eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    224     eglTerminate(mEglDisplay);
    225     eglReleaseThread();
    226 
    227     mEglDisplay = EGL_NO_DISPLAY;
    228     mEglContext = EGL_NO_CONTEXT;
    229     mPBufferSurface = EGL_NO_SURFACE;
    230     mCurrentSurface = EGL_NO_SURFACE;
    231 }
    232 
    233 bool EglManager::makeCurrent(EGLSurface surface) {
    234     if (isCurrent(surface)) return false;
    235 
    236     if (surface == EGL_NO_SURFACE) {
    237         // If we are setting EGL_NO_SURFACE we don't care about any of the potential
    238         // return errors, which would only happen if mEglDisplay had already been
    239         // destroyed in which case the current context is already NO_CONTEXT
    240         eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    241     } else if (!eglMakeCurrent(mEglDisplay, surface, surface, mEglContext)) {
    242         LOG_ALWAYS_FATAL("Failed to make current on surface %p, error=%s",
    243                 (void*)surface, egl_error_str());
    244     }
    245     mCurrentSurface = surface;
    246     return true;
    247 }
    248 
    249 void EglManager::beginFrame(EGLSurface surface, EGLint* width, EGLint* height) {
    250     LOG_ALWAYS_FATAL_IF(surface == EGL_NO_SURFACE,
    251             "Tried to beginFrame on EGL_NO_SURFACE!");
    252     makeCurrent(surface);
    253     if (width) {
    254         eglQuerySurface(mEglDisplay, surface, EGL_WIDTH, width);
    255     }
    256     if (height) {
    257         eglQuerySurface(mEglDisplay, surface, EGL_HEIGHT, height);
    258     }
    259     eglBeginFrame(mEglDisplay, surface);
    260     mInFrame = true;
    261 }
    262 
    263 bool EglManager::swapBuffers(EGLSurface surface) {
    264     mInFrame = false;
    265     eglSwapBuffers(mEglDisplay, surface);
    266     EGLint err = eglGetError();
    267     if (CC_LIKELY(err == EGL_SUCCESS)) {
    268         return true;
    269     }
    270     if (err == EGL_BAD_SURFACE) {
    271         // For some reason our surface was destroyed out from under us
    272         // This really shouldn't happen, but if it does we can recover easily
    273         // by just not trying to use the surface anymore
    274         ALOGW("swapBuffers encountered EGL_BAD_SURFACE on %p, halting rendering...", surface);
    275         return false;
    276     }
    277     LOG_ALWAYS_FATAL("Encountered EGL error %d %s during rendering",
    278             err, egl_error_str(err));
    279     // Impossible to hit this, but the compiler doesn't know that
    280     return false;
    281 }
    282 
    283 void EglManager::cancelFrame() {
    284     mInFrame = false;
    285 }
    286 
    287 bool EglManager::setPreserveBuffer(EGLSurface surface, bool preserve) {
    288     if (CC_UNLIKELY(!mAllowPreserveBuffer)) return false;
    289 
    290     bool preserved = false;
    291     if (mCanSetPreserveBuffer) {
    292         preserved = eglSurfaceAttrib(mEglDisplay, surface, EGL_SWAP_BEHAVIOR,
    293                 preserve ? EGL_BUFFER_PRESERVED : EGL_BUFFER_DESTROYED);
    294         if (CC_UNLIKELY(!preserved)) {
    295             ALOGW("Failed to set EGL_SWAP_BEHAVIOR on surface %p, error=%s",
    296                     (void*) surface, egl_error_str());
    297         }
    298     }
    299     if (CC_UNLIKELY(!preserved)) {
    300         // Maybe it's already set?
    301         EGLint swapBehavior;
    302         if (eglQuerySurface(mEglDisplay, surface, EGL_SWAP_BEHAVIOR, &swapBehavior)) {
    303             preserved = (swapBehavior == EGL_BUFFER_PRESERVED);
    304         } else {
    305             ALOGW("Failed to query EGL_SWAP_BEHAVIOR on surface %p, error=%p",
    306                                 (void*) surface, egl_error_str());
    307         }
    308     }
    309 
    310     return preserved;
    311 }
    312 
    313 } /* namespace renderthread */
    314 } /* namespace uirenderer */
    315 } /* namespace android */
    316