Home | History | Annotate | Download | only in EGL 
      1 /*
      2  ** Copyright 2007, 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 <ctype.h>
     18 #include <stdlib.h>
     19 #include <string.h>
     20 
     21 #include <hardware/gralloc.h>
     22 #include <system/window.h>
     23 
     24 #include <EGL/egl.h>
     25 #include <EGL/eglext.h>
     26 #include <GLES/gl.h>
     27 #include <GLES/glext.h>
     28 
     29 #include <cutils/log.h>
     30 #include <cutils/atomic.h>
     31 #include <cutils/properties.h>
     32 #include <cutils/memory.h>
     33 
     34 #include <utils/CallStack.h>
     35 #include <utils/String8.h>
     36 
     37 #include "egldefs.h"
     38 #include "egl_impl.h"
     39 #include "egl_tls.h"
     40 #include "glesv2dbg.h"
     41 #include "hooks.h"
     42 #include "Loader.h"
     43 
     44 #include "egl_display.h"
     45 #include "egl_object.h"
     46 
     47 // ----------------------------------------------------------------------------
     48 namespace android {
     49 // ----------------------------------------------------------------------------
     50 
     51 egl_connection_t gEGLImpl[IMPL_NUM_IMPLEMENTATIONS];
     52 gl_hooks_t gHooks[2][IMPL_NUM_IMPLEMENTATIONS];
     53 gl_hooks_t gHooksNoContext;
     54 pthread_key_t gGLWrapperKey = -1;
     55 
     56 // ----------------------------------------------------------------------------
     57 
     58 #if EGL_TRACE
     59 
     60 EGLAPI pthread_key_t gGLTraceKey = -1;
     61 
     62 // ----------------------------------------------------------------------------
     63 
     64 int gEGLDebugLevel;
     65 
     66 static int sEGLTraceLevel;
     67 static int sEGLApplicationTraceLevel;
     68 
     69 extern gl_hooks_t gHooksTrace;
     70 extern gl_hooks_t gHooksDebug;
     71 
     72 static inline void setGlTraceThreadSpecific(gl_hooks_t const *value) {
     73     pthread_setspecific(gGLTraceKey, value);
     74 }
     75 
     76 gl_hooks_t const* getGLTraceThreadSpecific() {
     77     return static_cast<gl_hooks_t*>(pthread_getspecific(gGLTraceKey));
     78 }
     79 
     80 void initEglTraceLevel() {
     81     char value[PROPERTY_VALUE_MAX];
     82     property_get("debug.egl.trace", value, "0");
     83     int propertyLevel = atoi(value);
     84     int applicationLevel = sEGLApplicationTraceLevel;
     85     sEGLTraceLevel = propertyLevel > applicationLevel ? propertyLevel : applicationLevel;
     86 
     87     property_get("debug.egl.debug_proc", value, "");
     88     long pid = getpid();
     89     char procPath[128] = {};
     90     sprintf(procPath, "/proc/%ld/cmdline", pid);
     91     FILE * file = fopen(procPath, "r");
     92     if (file)
     93     {
     94         char cmdline[256] = {};
     95         if (fgets(cmdline, sizeof(cmdline) - 1, file))
     96         {
     97             if (!strcmp(value, cmdline))
     98                 gEGLDebugLevel = 1;
     99         }
    100         fclose(file);
    101     }
    102 
    103     if (gEGLDebugLevel > 0)
    104     {
    105         property_get("debug.egl.debug_port", value, "5039");
    106         const unsigned short port = (unsigned short)atoi(value);
    107         property_get("debug.egl.debug_forceUseFile", value, "0");
    108         const bool forceUseFile = (bool)atoi(value);
    109         property_get("debug.egl.debug_maxFileSize", value, "8");
    110         const unsigned int maxFileSize = atoi(value) << 20;
    111         property_get("debug.egl.debug_filePath", value, "/data/local/tmp/dump.gles2dbg");
    112         StartDebugServer(port, forceUseFile, maxFileSize, value);
    113     }
    114 }
    115 
    116 void setGLHooksThreadSpecific(gl_hooks_t const *value) {
    117     if (sEGLTraceLevel > 0) {
    118         setGlTraceThreadSpecific(value);
    119         setGlThreadSpecific(&gHooksTrace);
    120     } else if (gEGLDebugLevel > 0 && value != &gHooksNoContext) {
    121         setGlTraceThreadSpecific(value);
    122         setGlThreadSpecific(&gHooksDebug);
    123     } else {
    124         setGlThreadSpecific(value);
    125     }
    126 }
    127 
    128 /*
    129  * Global entry point to allow applications to modify their own trace level.
    130  * The effective trace level is the max of this level and the value of debug.egl.trace.
    131  */
    132 extern "C"
    133 void setGLTraceLevel(int level) {
    134     sEGLApplicationTraceLevel = level;
    135 }
    136 
    137 #else
    138 
    139 void setGLHooksThreadSpecific(gl_hooks_t const *value) {
    140     setGlThreadSpecific(value);
    141 }
    142 
    143 #endif
    144 
    145 /*****************************************************************************/
    146 
    147 static int gl_no_context() {
    148     if (egl_tls_t::logNoContextCall()) {
    149         LOGE("call to OpenGL ES API with no current context "
    150              "(logged once per thread)");
    151         char value[PROPERTY_VALUE_MAX];
    152         property_get("debug.egl.callstack", value, "0");
    153         if (atoi(value)) {
    154             CallStack stack;
    155             stack.update();
    156             stack.dump();
    157         }
    158     }
    159     return 0;
    160 }
    161 
    162 static void early_egl_init(void)
    163 {
    164 #if !USE_FAST_TLS_KEY
    165     pthread_key_create(&gGLWrapperKey, NULL);
    166 #endif
    167 #if EGL_TRACE
    168     pthread_key_create(&gGLTraceKey, NULL);
    169     initEglTraceLevel();
    170 #endif
    171     uint32_t addr = (uint32_t)((void*)gl_no_context);
    172     android_memset32(
    173             (uint32_t*)(void*)&gHooksNoContext,
    174             addr,
    175             sizeof(gHooksNoContext));
    176 
    177     setGLHooksThreadSpecific(&gHooksNoContext);
    178 }
    179 
    180 static pthread_once_t once_control = PTHREAD_ONCE_INIT;
    181 static int sEarlyInitState = pthread_once(&once_control, &early_egl_init);
    182 
    183 // ----------------------------------------------------------------------------
    184 
    185 egl_display_t* validate_display(EGLDisplay dpy) {
    186     egl_display_t * const dp = get_display(dpy);
    187     if (!dp)
    188         return setError(EGL_BAD_DISPLAY, (egl_display_t*)NULL);
    189     if (!dp->isReady())
    190         return setError(EGL_NOT_INITIALIZED, (egl_display_t*)NULL);
    191 
    192     return dp;
    193 }
    194 
    195 egl_connection_t* validate_display_config(EGLDisplay dpy, EGLConfig config,
    196         egl_display_t const*& dp) {
    197     dp = validate_display(dpy);
    198     if (!dp)
    199         return (egl_connection_t*) NULL;
    200 
    201     if (intptr_t(config) >= dp->numTotalConfigs) {
    202         return setError(EGL_BAD_CONFIG, (egl_connection_t*)NULL);
    203     }
    204     egl_connection_t* const cnx = &gEGLImpl[dp->configs[intptr_t(config)].impl];
    205     if (cnx->dso == 0) {
    206         return setError(EGL_BAD_CONFIG, (egl_connection_t*)NULL);
    207     }
    208     return cnx;
    209 }
    210 
    211 // ----------------------------------------------------------------------------
    212 
    213 EGLImageKHR egl_get_image_for_current_context(EGLImageKHR image)
    214 {
    215     EGLContext context = egl_tls_t::getContext();
    216     if (context == EGL_NO_CONTEXT || image == EGL_NO_IMAGE_KHR)
    217         return EGL_NO_IMAGE_KHR;
    218 
    219     egl_context_t const * const c = get_context(context);
    220     if (c == NULL) // this should never happen, by construction
    221         return EGL_NO_IMAGE_KHR;
    222 
    223     egl_display_t* display = egl_display_t::get(c->dpy);
    224     if (display == NULL) // this should never happen, by construction
    225         return EGL_NO_IMAGE_KHR;
    226 
    227     ImageRef _i(display, image);
    228     if (!_i.get())
    229         return EGL_NO_IMAGE_KHR;
    230 
    231     // here we don't validate the context because if it's been marked for
    232     // termination, this call should still succeed since it's internal to
    233     // EGL.
    234 
    235     egl_image_t const * const i = get_image(image);
    236     return i->images[c->impl];
    237 }
    238 
    239 // ----------------------------------------------------------------------------
    240 
    241 // this mutex protects:
    242 //    d->disp[]
    243 //    egl_init_drivers_locked()
    244 //
    245 static EGLBoolean egl_init_drivers_locked() {
    246     if (sEarlyInitState) {
    247         // initialized by static ctor. should be set here.
    248         return EGL_FALSE;
    249     }
    250 
    251     // get our driver loader
    252     Loader& loader(Loader::getInstance());
    253 
    254     // dynamically load all our EGL implementations
    255     egl_connection_t* cnx;
    256 
    257     cnx = &gEGLImpl[IMPL_SOFTWARE];
    258     if (cnx->dso == 0) {
    259         cnx->hooks[GLESv1_INDEX] = &gHooks[GLESv1_INDEX][IMPL_SOFTWARE];
    260         cnx->hooks[GLESv2_INDEX] = &gHooks[GLESv2_INDEX][IMPL_SOFTWARE];
    261         cnx->dso = loader.open(EGL_DEFAULT_DISPLAY, 0, cnx);
    262     }
    263 
    264     cnx = &gEGLImpl[IMPL_HARDWARE];
    265     if (cnx->dso == 0) {
    266         char value[PROPERTY_VALUE_MAX];
    267         property_get("debug.egl.hw", value, "1");
    268         if (atoi(value) != 0) {
    269             cnx->hooks[GLESv1_INDEX] = &gHooks[GLESv1_INDEX][IMPL_HARDWARE];
    270             cnx->hooks[GLESv2_INDEX] = &gHooks[GLESv2_INDEX][IMPL_HARDWARE];
    271             cnx->dso = loader.open(EGL_DEFAULT_DISPLAY, 1, cnx);
    272         } else {
    273             LOGD("3D hardware acceleration is disabled");
    274         }
    275     }
    276 
    277     if (!gEGLImpl[IMPL_SOFTWARE].dso && !gEGLImpl[IMPL_HARDWARE].dso) {
    278         return EGL_FALSE;
    279     }
    280 
    281     return EGL_TRUE;
    282 }
    283 
    284 static pthread_mutex_t sInitDriverMutex = PTHREAD_MUTEX_INITIALIZER;
    285 
    286 EGLBoolean egl_init_drivers() {
    287     EGLBoolean res;
    288     pthread_mutex_lock(&sInitDriverMutex);
    289     res = egl_init_drivers_locked();
    290     pthread_mutex_unlock(&sInitDriverMutex);
    291     return res;
    292 }
    293 
    294 void gl_unimplemented() {
    295     LOGE("called unimplemented OpenGL ES API");
    296 }
    297 
    298 // ----------------------------------------------------------------------------
    299 
    300 #if USE_FAST_TLS_KEY
    301 
    302 // We have a dedicated TLS slot in bionic
    303 static inline gl_hooks_t const * volatile * get_tls_hooks() {
    304     volatile void *tls_base = __get_tls();
    305     gl_hooks_t const * volatile * tls_hooks =
    306             reinterpret_cast<gl_hooks_t const * volatile *>(tls_base);
    307     return tls_hooks;
    308 }
    309 
    310 void setGlThreadSpecific(gl_hooks_t const *value) {
    311     gl_hooks_t const * volatile * tls_hooks = get_tls_hooks();
    312     tls_hooks[TLS_SLOT_OPENGL_API] = value;
    313 }
    314 
    315 gl_hooks_t const* getGlThreadSpecific() {
    316     gl_hooks_t const * volatile * tls_hooks = get_tls_hooks();
    317     gl_hooks_t const* hooks = tls_hooks[TLS_SLOT_OPENGL_API];
    318     if (hooks) return hooks;
    319     return &gHooksNoContext;
    320 }
    321 
    322 #else
    323 
    324 void setGlThreadSpecific(gl_hooks_t const *value) {
    325     pthread_setspecific(gGLWrapperKey, value);
    326 }
    327 
    328 gl_hooks_t const* getGlThreadSpecific() {
    329     gl_hooks_t const* hooks =  static_cast<gl_hooks_t*>(pthread_getspecific(gGLWrapperKey));
    330     if (hooks) return hooks;
    331     return &gHooksNoContext;
    332 }
    333 
    334 #endif
    335 
    336 // ----------------------------------------------------------------------------
    337 // GL / EGL hooks
    338 // ----------------------------------------------------------------------------
    339 
    340 #undef GL_ENTRY
    341 #undef EGL_ENTRY
    342 #define GL_ENTRY(_r, _api, ...) #_api,
    343 #define EGL_ENTRY(_r, _api, ...) #_api,
    344 
    345 char const * const gl_names[] = {
    346     #include "entries.in"
    347     NULL
    348 };
    349 
    350 char const * const egl_names[] = {
    351     #include "egl_entries.in"
    352     NULL
    353 };
    354 
    355 #undef GL_ENTRY
    356 #undef EGL_ENTRY
    357 
    358 
    359 // ----------------------------------------------------------------------------
    360 }; // namespace android
    361 // ----------------------------------------------------------------------------
    362 
    363