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