opengl/libs/EGL/eglApi.cpp

   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 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
  18
  19 #include <dlfcn.h>
  20 #include <ctype.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24 #include <hardware/gralloc.h>
  25 #include <system/window.h>
  26
  27 #include <EGL/egl.h>
  28 #include <EGL/eglext.h>
  29
  30 #include <cutils/log.h>
  31 #include <cutils/atomic.h>
  32 #include <cutils/compiler.h>
  33 #include <cutils/properties.h>
  34 #include <cutils/memory.h>
  35
  36 #include <utils/KeyedVector.h>
  37 #include <utils/SortedVector.h>
  38 #include <utils/String8.h>
  39 #include <utils/Trace.h>
  40
  41 #include "../egl_impl.h"
  42 #include "../glestrace.h"
  43 #include "../hooks.h"
  44
  45 #include "egl_display.h"
  46 #include "egl_object.h"
  47 #include "egl_tls.h"
  48 #include "egldefs.h"
  49
  50 using namespace android;
  51
  52 // ----------------------------------------------------------------------------
  53
  54 namespace android {
  55
  56 struct extention_map_t {
  57     const char* name;
  58     __eglMustCastToProperFunctionPointerType address;
  59 };
  60
  61 /*
  62  * This is the list of EGL extensions exposed to applications.
  63  *
  64  * Some of them (gBuiltinExtensionString) are implemented entirely in this EGL
  65  * wrapper and are always available.
  66  *
  67  * The rest (gExtensionString) depend on support in the EGL driver, and are
  68  * only available if the driver supports them. However, some of these must be
  69  * supported because they are used by the Android system itself; these are
  70  * listd as mandatory below and are required by the CDD. The system *assumes*
  71  * the mandatory extensions are present and may not function properly if some
  72  * are missing.
  73  *
  74  * NOTE: Both strings MUST have a single space as the last character.
  75  */
  76 extern char const * const gBuiltinExtensionString =
  77         "EGL_KHR_get_all_proc_addresses "
  78         "EGL_ANDROID_presentation_time "
  79         ;
  80 extern char const * const gExtensionString  =
  81         "EGL_KHR_image "                        // mandatory
  82         "EGL_KHR_image_base "                   // mandatory
  83         "EGL_KHR_image_pixmap "
  84         "EGL_KHR_lock_surface "
  85         "EGL_KHR_gl_colorspace "
  86         "EGL_KHR_gl_texture_2D_image "
  87         "EGL_KHR_gl_texture_cubemap_image "
  88         "EGL_KHR_gl_renderbuffer_image "
  89         "EGL_KHR_reusable_sync "
  90         "EGL_KHR_fence_sync "
  91         "EGL_KHR_create_context "
  92         "EGL_EXT_create_context_robustness "
  93         "EGL_NV_system_time "
  94         "EGL_ANDROID_image_native_buffer "      // mandatory
  95         "EGL_KHR_wait_sync "                    // strongly recommended
  96         ;
  97
  98 // extensions not exposed to applications but used by the ANDROID system
  99 //      "EGL_ANDROID_blob_cache "               // strongly recommended
 100 //      "EGL_IMG_hibernate_process "            // optional
 101 //      "EGL_ANDROID_native_fence_sync "        // strongly recommended
 102 //      "EGL_ANDROID_framebuffer_target "       // mandatory for HWC 1.1
 103 //      "EGL_ANDROID_recordable "               // mandatory
 104
 105
 106 /*
 107  * EGL Extensions entry-points exposed to 3rd party applications
 108  * (keep in sync with gExtensionString above)
 109  *
 110  */
 111 static const extention_map_t sExtensionMap[] = {
 112     // EGL_KHR_lock_surface
 113     { "eglLockSurfaceKHR",
 114             (__eglMustCastToProperFunctionPointerType)&eglLockSurfaceKHR },
 115     { "eglUnlockSurfaceKHR",
 116             (__eglMustCastToProperFunctionPointerType)&eglUnlockSurfaceKHR },
 117
 118     // EGL_KHR_image, EGL_KHR_image_base
 119     { "eglCreateImageKHR",
 120             (__eglMustCastToProperFunctionPointerType)&eglCreateImageKHR },
 121     { "eglDestroyImageKHR",
 122             (__eglMustCastToProperFunctionPointerType)&eglDestroyImageKHR },
 123
 124     // EGL_KHR_reusable_sync, EGL_KHR_fence_sync
 125     { "eglCreateSyncKHR",
 126             (__eglMustCastToProperFunctionPointerType)&eglCreateSyncKHR },
 127     { "eglDestroySyncKHR",
 128             (__eglMustCastToProperFunctionPointerType)&eglDestroySyncKHR },
 129     { "eglClientWaitSyncKHR",
 130             (__eglMustCastToProperFunctionPointerType)&eglClientWaitSyncKHR },
 131     { "eglSignalSyncKHR",
 132             (__eglMustCastToProperFunctionPointerType)&eglSignalSyncKHR },
 133     { "eglGetSyncAttribKHR",
 134             (__eglMustCastToProperFunctionPointerType)&eglGetSyncAttribKHR },
 135
 136     // EGL_NV_system_time
 137     { "eglGetSystemTimeFrequencyNV",
 138             (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeFrequencyNV },
 139     { "eglGetSystemTimeNV",
 140             (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeNV },
 141
 142     // EGL_KHR_wait_sync
 143     { "eglWaitSyncKHR",
 144             (__eglMustCastToProperFunctionPointerType)&eglWaitSyncKHR },
 145
 146     // EGL_ANDROID_presentation_time
 147     { "eglPresentationTimeANDROID",
 148             (__eglMustCastToProperFunctionPointerType)&eglPresentationTimeANDROID },
 149 };
 150
 151 /*
 152  * These extensions entry-points should not be exposed to applications.
 153  * They're used internally by the Android EGL layer.
 154  */
 155 #define FILTER_EXTENSIONS(procname) \
 156         (!strcmp((procname), "eglSetBlobCacheFuncsANDROID") ||    \
 157          !strcmp((procname), "eglHibernateProcessIMG")      ||    \
 158          !strcmp((procname), "eglAwakenProcessIMG")         ||    \
 159          !strcmp((procname), "eglDupNativeFenceFDANDROID"))
 160
 161
 162
 163 // accesses protected by sExtensionMapMutex
 164 static DefaultKeyedVector<String8, __eglMustCastToProperFunctionPointerType> sGLExtentionMap;
 165 static int sGLExtentionSlot = 0;
 166 static pthread_mutex_t sExtensionMapMutex = PTHREAD_MUTEX_INITIALIZER;
 167
 168 static void(*findProcAddress(const char* name,
 169         const extention_map_t* map, size_t n))() {
 170     for (uint32_t i=0 ; i<n ; i++) {
 171         if (!strcmp(name, map[i].name)) {
 172             return map[i].address;
 173         }
 174     }
 175     return NULL;
 176 }
 177
 178 // ----------------------------------------------------------------------------
 179
 180 extern void setGLHooksThreadSpecific(gl_hooks_t const *value);
 181 extern EGLBoolean egl_init_drivers();
 182 extern const __eglMustCastToProperFunctionPointerType gExtensionForwarders[MAX_NUMBER_OF_GL_EXTENSIONS];
 183 extern int getEGLDebugLevel();
 184 extern void setEGLDebugLevel(int level);
 185 extern gl_hooks_t gHooksTrace;
 186
 187 } // namespace android;
 188
 189
 190 // ----------------------------------------------------------------------------
 191
 192 static inline void clearError() { egl_tls_t::clearError(); }
 193 static inline EGLContext getContext() { return egl_tls_t::getContext(); }
 194
 195 // ----------------------------------------------------------------------------
 196
 197 EGLDisplay eglGetDisplay(EGLNativeDisplayType display)
 198 {
 199     clearError();
 200
 201     uint32_t index = uint32_t(display);
 202     if (index >= NUM_DISPLAYS) {
 203         return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);
 204     }
 205
 206     if (egl_init_drivers() == EGL_FALSE) {
 207         return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);
 208     }
 209
 210     EGLDisplay dpy = egl_display_t::getFromNativeDisplay(display);
 211     return dpy;
 212 }
 213
 214 // ----------------------------------------------------------------------------
 215 // Initialization
 216 // ----------------------------------------------------------------------------
 217
 218 EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
 219 {
 220     clearError();
 221
 222     egl_display_ptr dp = get_display(dpy);
 223     if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
 224
 225     EGLBoolean res = dp->initialize(major, minor);
 226
 227     return res;
 228 }
 229
 230 EGLBoolean eglTerminate(EGLDisplay dpy)
 231 {
 232     // NOTE: don't unload the drivers b/c some APIs can be called
 233     // after eglTerminate() has been called. eglTerminate() only
 234     // terminates an EGLDisplay, not a EGL itself.
 235
 236     clearError();
 237
 238     egl_display_ptr dp = get_display(dpy);
 239     if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
 240
 241     EGLBoolean res = dp->terminate();
 242
 243     return res;
 244 }
 245
 246 // ----------------------------------------------------------------------------
 247 // configuration
 248 // ----------------------------------------------------------------------------
 249
 250 EGLBoolean eglGetConfigs(   EGLDisplay dpy,
 251                             EGLConfig *configs,
 252                             EGLint config_size, EGLint *num_config)
 253 {
 254     clearError();
 255
 256     const egl_display_ptr dp = validate_display(dpy);
 257     if (!dp) return EGL_FALSE;
 258
 259     if (num_config==0) {
 260         return setError(EGL_BAD_PARAMETER, EGL_FALSE);
 261     }
 262
 263     EGLBoolean res = EGL_FALSE;
 264     *num_config = 0;
 265
 266     egl_connection_t* const cnx = &gEGLImpl;
 267     if (cnx->dso) {
 268         res = cnx->egl.eglGetConfigs(
 269                 dp->disp.dpy, configs, config_size, num_config);
 270     }
 271
 272     return res;
 273 }
 274
 275 EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list,
 276                             EGLConfig *configs, EGLint config_size,
 277                             EGLint *num_config)
 278 {
 279     clearError();
 280
 281     const egl_display_ptr dp = validate_display(dpy);
 282     if (!dp) return EGL_FALSE;
 283
 284     if (num_config==0) {
 285         return setError(EGL_BAD_PARAMETER, EGL_FALSE);
 286     }
 287
 288     EGLBoolean res = EGL_FALSE;
 289     *num_config = 0;
 290
 291     egl_connection_t* const cnx = &gEGLImpl;
 292     if (cnx->dso) {
 293         if (attrib_list) {
 294             char value[PROPERTY_VALUE_MAX];
 295             property_get("debug.egl.force_msaa", value, "false");
 296
 297             if (!strcmp(value, "true")) {
 298                 size_t attribCount = 0;
 299                 EGLint attrib = attrib_list[0];
 300
 301                 // Only enable MSAA if the context is OpenGL ES 2.0 and
 302                 // if no caveat is requested
 303                 const EGLint *attribRendererable = NULL;
 304                 const EGLint *attribCaveat = NULL;
 305
 306                 // Count the number of attributes and look for
 307                 // EGL_RENDERABLE_TYPE and EGL_CONFIG_CAVEAT
 308                 while (attrib != EGL_NONE) {
 309                     attrib = attrib_list[attribCount];
 310                     switch (attrib) {
 311                         case EGL_RENDERABLE_TYPE:
 312                             attribRendererable = &attrib_list[attribCount];
 313                             break;
 314                         case EGL_CONFIG_CAVEAT:
 315                             attribCaveat = &attrib_list[attribCount];
 316                             break;
 317                     }
 318                     attribCount++;
 319                 }
 320
 321                 if (attribRendererable && attribRendererable[1] == EGL_OPENGL_ES2_BIT &&
 322                         (!attribCaveat || attribCaveat[1] != EGL_NONE)) {
 323
 324                     // Insert 2 extra attributes to force-enable MSAA 4x
 325                     EGLint aaAttribs[attribCount + 4];
 326                     aaAttribs[0] = EGL_SAMPLE_BUFFERS;
 327                     aaAttribs[1] = 1;
 328                     aaAttribs[2] = EGL_SAMPLES;
 329                     aaAttribs[3] = 4;
 330
 331                     memcpy(&aaAttribs[4], attrib_list, attribCount * sizeof(EGLint));
 332
 333                     EGLint numConfigAA;
 334                     EGLBoolean resAA = cnx->egl.eglChooseConfig(
 335                             dp->disp.dpy, aaAttribs, configs, config_size, &numConfigAA);
 336
 337                     if (resAA == EGL_TRUE && numConfigAA > 0) {
 338                         ALOGD("Enabling MSAA 4x");
 339                         *num_config = numConfigAA;
 340                         return resAA;
 341                     }
 342                 }
 343             }
 344         }
 345
 346         res = cnx->egl.eglChooseConfig(
 347                 dp->disp.dpy, attrib_list, configs, config_size, num_config);
 348     }
 349     return res;
 350 }
 351
 352 EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
 353         EGLint attribute, EGLint *value)
 354 {
 355     clearError();
 356
 357     egl_connection_t* cnx = NULL;
 358     const egl_display_ptr dp = validate_display_connection(dpy, cnx);
 359     if (!dp) return EGL_FALSE;
 360
 361     return cnx->egl.eglGetConfigAttrib(
 362             dp->disp.dpy, config, attribute, value);
 363 }
 364
 365 // ----------------------------------------------------------------------------
 366 // surfaces
 367 // ----------------------------------------------------------------------------
 368
 369 // The EGL_KHR_gl_colorspace spec hasn't been published yet, so these haven't
 370 // been added to the Khronos egl.h.
 371 #define EGL_GL_COLORSPACE_KHR           EGL_VG_COLORSPACE
 372 #define EGL_GL_COLORSPACE_SRGB_KHR      EGL_VG_COLORSPACE_sRGB
 373 #define EGL_GL_COLORSPACE_LINEAR_KHR    EGL_VG_COLORSPACE_LINEAR
 374
 375 // Turn linear formats into corresponding sRGB formats when colorspace is
 376 // EGL_GL_COLORSPACE_SRGB_KHR, or turn sRGB formats into corresponding linear
 377 // formats when colorspace is EGL_GL_COLORSPACE_LINEAR_KHR. In any cases where
 378 // the modification isn't possible, the original format is returned.
 379 static int modifyFormatColorspace(int fmt, EGLint colorspace) {
 380     if (colorspace == EGL_GL_COLORSPACE_LINEAR_KHR) {
 381         switch (fmt) {
 382             case HAL_PIXEL_FORMAT_sRGB_A_8888: return HAL_PIXEL_FORMAT_RGBA_8888;
 383             case HAL_PIXEL_FORMAT_sRGB_X_8888: return HAL_PIXEL_FORMAT_RGBX_8888;
 384         }
 385     } else if (colorspace == EGL_GL_COLORSPACE_SRGB_KHR) {
 386         switch (fmt) {
 387             case HAL_PIXEL_FORMAT_RGBA_8888: return HAL_PIXEL_FORMAT_sRGB_A_8888;
 388             case HAL_PIXEL_FORMAT_RGBX_8888: return HAL_PIXEL_FORMAT_sRGB_X_8888;
 389             // TODO: this should go away once drivers stop using BGRA EGLConfigs
 390             case HAL_PIXEL_FORMAT_BGRA_8888: return HAL_PIXEL_FORMAT_sRGB_A_8888;
 391         }
 392     }
 393     return fmt;
 394 }
 395
 396 EGLSurface eglCreateWindowSurface(  EGLDisplay dpy, EGLConfig config,
 397                                     NativeWindowType window,
 398                                     const EGLint *attrib_list)
 399 {
 400     clearError();
 401
 402     egl_connection_t* cnx = NULL;
 403     egl_display_ptr dp = validate_display_connection(dpy, cnx);
 404     if (dp) {
 405         EGLDisplay iDpy = dp->disp.dpy;
 406
 407         if (native_window_api_connect(window, NATIVE_WINDOW_API_EGL) != OK) {
 408             ALOGE("EGLNativeWindowType %p already connected to another API",
 409                     window);
 410             return setError(EGL_BAD_ALLOC, EGL_NO_SURFACE);
 411         }
 412
 413         // Set the native window's buffers format to match this config.
 414         // Whether to use sRGB gamma is not part of the EGLconfig, but is part
 415         // of our native format. So if sRGB gamma is requested, we have to
 416         // modify the EGLconfig's format before setting the native window's
 417         // format.
 418         EGLint format;
 419         if (!cnx->egl.eglGetConfigAttrib(iDpy, config, EGL_NATIVE_VISUAL_ID,
 420                 &format)) {
 421             ALOGE("eglGetConfigAttrib(EGL_NATIVE_VISUAL_ID) failed: %#x",
 422                     eglGetError());
 423             format = 0;
 424         }
 425         if (attrib_list) {
 426             for (const EGLint* attr = attrib_list; *attr != EGL_NONE;
 427                     attr += 2) {
 428                 if (*attr == EGL_GL_COLORSPACE_KHR &&
 429                         dp->haveExtension("EGL_KHR_gl_colorspace")) {
 430                     format = modifyFormatColorspace(format, *(attr+1));
 431                 }
 432             }
 433         }
 434         if (format != 0) {
 435             int err = native_window_set_buffers_format(window, format);
 436             if (err != 0) {
 437                 ALOGE("error setting native window pixel format: %s (%d)",
 438                         strerror(-err), err);
 439                 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
 440                 return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
 441             }
 442         }
 443
 444         // the EGL spec requires that a new EGLSurface default to swap interval
 445         // 1, so explicitly set that on the window here.
 446         ANativeWindow* anw = reinterpret_cast<ANativeWindow*>(window);
 447         anw->setSwapInterval(anw, 1);
 448
 449         EGLSurface surface = cnx->egl.eglCreateWindowSurface(
 450                 iDpy, config, window, attrib_list);
 451         if (surface != EGL_NO_SURFACE) {
 452             egl_surface_t* s = new egl_surface_t(dp.get(), config, window,
 453                     surface, cnx);
 454             return s;
 455         }
 456
 457         // EGLSurface creation failed
 458         native_window_set_buffers_format(window, 0);
 459         native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
 460     }
 461     return EGL_NO_SURFACE;
 462 }
 463
 464 EGLSurface eglCreatePixmapSurface(  EGLDisplay dpy, EGLConfig config,
 465                                     NativePixmapType pixmap,
 466                                     const EGLint *attrib_list)
 467 {
 468     clearError();
 469
 470     egl_connection_t* cnx = NULL;
 471     egl_display_ptr dp = validate_display_connection(dpy, cnx);
 472     if (dp) {
 473         EGLSurface surface = cnx->egl.eglCreatePixmapSurface(
 474                 dp->disp.dpy, config, pixmap, attrib_list);
 475         if (surface != EGL_NO_SURFACE) {
 476             egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL,
 477                     surface, cnx);
 478             return s;
 479         }
 480     }
 481     return EGL_NO_SURFACE;
 482 }
 483
 484 EGLSurface eglCreatePbufferSurface( EGLDisplay dpy, EGLConfig config,
 485                                     const EGLint *attrib_list)
 486 {
 487     clearError();
 488
 489     egl_connection_t* cnx = NULL;
 490     egl_display_ptr dp = validate_display_connection(dpy, cnx);
 491     if (dp) {
 492         EGLSurface surface = cnx->egl.eglCreatePbufferSurface(
 493                 dp->disp.dpy, config, attrib_list);
 494         if (surface != EGL_NO_SURFACE) {
 495             egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL,
 496                     surface, cnx);
 497             return s;
 498         }
 499     }
 500     return EGL_NO_SURFACE;
 501 }
 502
 503 EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
 504 {
 505     clearError();
 506
 507     const egl_display_ptr dp = validate_display(dpy);
 508     if (!dp) return EGL_FALSE;
 509
 510     SurfaceRef _s(dp.get(), surface);
 511     if (!_s.get())
 512         return setError(EGL_BAD_SURFACE, EGL_FALSE);
 513
 514     egl_surface_t * const s = get_surface(surface);
 515     EGLBoolean result = s->cnx->egl.eglDestroySurface(dp->disp.dpy, s->surface);
 516     if (result == EGL_TRUE) {
 517         _s.terminate();
 518     }
 519     return result;
 520 }
 521
 522 EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface surface,
 523                             EGLint attribute, EGLint *value)
 524 {
 525     clearError();
 526
 527     const egl_display_ptr dp = validate_display(dpy);
 528     if (!dp) return EGL_FALSE;
 529
 530     SurfaceRef _s(dp.get(), surface);
 531     if (!_s.get())
 532         return setError(EGL_BAD_SURFACE, EGL_FALSE);
 533
 534     egl_surface_t const * const s = get_surface(surface);
 535     return s->cnx->egl.eglQuerySurface(
 536             dp->disp.dpy, s->surface, attribute, value);
 537 }
 538
 539 void EGLAPI eglBeginFrame(EGLDisplay dpy, EGLSurface surface) {
 540     ATRACE_CALL();
 541     clearError();
 542
 543     const egl_display_ptr dp = validate_display(dpy);
 544     if (!dp) {
 545         return;
 546     }
 547
 548     SurfaceRef _s(dp.get(), surface);
 549     if (!_s.get()) {
 550         setError(EGL_BAD_SURFACE, EGL_FALSE);
 551         return;
 552     }
 553 }
 554
 555 // ----------------------------------------------------------------------------
 556 // Contexts
 557 // ----------------------------------------------------------------------------
 558
 559 EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,
 560                             EGLContext share_list, const EGLint *attrib_list)
 561 {
 562     clearError();
 563
 564     egl_connection_t* cnx = NULL;
 565     const egl_display_ptr dp = validate_display_connection(dpy, cnx);
 566     if (dp) {
 567         if (share_list != EGL_NO_CONTEXT) {
 568             if (!ContextRef(dp.get(), share_list).get()) {
 569                 return setError(EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
 570             }
 571             egl_context_t* const c = get_context(share_list);
 572             share_list = c->context;
 573         }
 574         EGLContext context = cnx->egl.eglCreateContext(
 575                 dp->disp.dpy, config, share_list, attrib_list);
 576         if (context != EGL_NO_CONTEXT) {
 577             // figure out if it's a GLESv1 or GLESv2
 578             int version = 0;
 579             if (attrib_list) {
 580                 while (*attrib_list != EGL_NONE) {
 581                     GLint attr = *attrib_list++;
 582                     GLint value = *attrib_list++;
 583                     if (attr == EGL_CONTEXT_CLIENT_VERSION) {
 584                         if (value == 1) {
 585                             version = egl_connection_t::GLESv1_INDEX;
 586                         } else if (value == 2 || value == 3) {
 587                             version = egl_connection_t::GLESv2_INDEX;
 588                         }
 589                     }
 590                 };
 591             }
 592             egl_context_t* c = new egl_context_t(dpy, context, config, cnx,
 593                     version);
 594 #if EGL_TRACE
 595             if (getEGLDebugLevel() > 0)
 596                 GLTrace_eglCreateContext(version, c);
 597 #endif
 598             return c;
 599         }
 600     }
 601     return EGL_NO_CONTEXT;
 602 }
 603
 604 EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 605 {
 606     clearError();
 607
 608     const egl_display_ptr dp = validate_display(dpy);
 609     if (!dp)
 610         return EGL_FALSE;
 611
 612     ContextRef _c(dp.get(), ctx);
 613     if (!_c.get())
 614         return setError(EGL_BAD_CONTEXT, EGL_FALSE);
 615
 616     egl_context_t * const c = get_context(ctx);
 617     EGLBoolean result = c->cnx->egl.eglDestroyContext(dp->disp.dpy, c->context);
 618     if (result == EGL_TRUE) {
 619         _c.terminate();
 620     }
 621     return result;
 622 }
 623
 624 EGLBoolean eglMakeCurrent(  EGLDisplay dpy, EGLSurface draw,
 625                             EGLSurface read, EGLContext ctx)
 626 {
 627     clearError();
 628
 629     egl_display_ptr dp = validate_display(dpy);
 630     if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
 631
 632     // If ctx is not EGL_NO_CONTEXT, read is not EGL_NO_SURFACE, or draw is not
 633     // EGL_NO_SURFACE, then an EGL_NOT_INITIALIZED error is generated if dpy is
 634     // a valid but uninitialized display.
 635     if ( (ctx != EGL_NO_CONTEXT) || (read != EGL_NO_SURFACE) ||
 636          (draw != EGL_NO_SURFACE) ) {
 637         if (!dp->isReady()) return setError(EGL_NOT_INITIALIZED, EGL_FALSE);
 638     }
 639
 640     // get a reference to the object passed in
 641     ContextRef _c(dp.get(), ctx);
 642     SurfaceRef _d(dp.get(), draw);
 643     SurfaceRef _r(dp.get(), read);
 644
 645     // validate the context (if not EGL_NO_CONTEXT)
 646     if ((ctx != EGL_NO_CONTEXT) && !_c.get()) {
 647         // EGL_NO_CONTEXT is valid
 648         return setError(EGL_BAD_CONTEXT, EGL_FALSE);
 649     }
 650
 651     // these are the underlying implementation's object
 652     EGLContext impl_ctx  = EGL_NO_CONTEXT;
 653     EGLSurface impl_draw = EGL_NO_SURFACE;
 654     EGLSurface impl_read = EGL_NO_SURFACE;
 655
 656     // these are our objects structs passed in
 657     egl_context_t       * c = NULL;
 658     egl_surface_t const * d = NULL;
 659     egl_surface_t const * r = NULL;
 660
 661     // these are the current objects structs
 662     egl_context_t * cur_c = get_context(getContext());
 663
 664     if (ctx != EGL_NO_CONTEXT) {
 665         c = get_context(ctx);
 666         impl_ctx = c->context;
 667     } else {
 668         // no context given, use the implementation of the current context
 669         if (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE) {
 670             // calling eglMakeCurrent( ..., !=0, !=0, EGL_NO_CONTEXT);
 671             return setError(EGL_BAD_MATCH, EGL_FALSE);
 672         }
 673         if (cur_c == NULL) {
 674             // no current context
 675             // not an error, there is just no current context.
 676             return EGL_TRUE;
 677         }
 678     }
 679
 680     // retrieve the underlying implementation's draw EGLSurface
 681     if (draw != EGL_NO_SURFACE) {
 682         if (!_d.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
 683         d = get_surface(draw);
 684         impl_draw = d->surface;
 685     }
 686
 687     // retrieve the underlying implementation's read EGLSurface
 688     if (read != EGL_NO_SURFACE) {
 689         if (!_r.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
 690         r = get_surface(read);
 691         impl_read = r->surface;
 692     }
 693
 694
 695     EGLBoolean result = dp->makeCurrent(c, cur_c,
 696             draw, read, ctx,
 697             impl_draw, impl_read, impl_ctx);
 698
 699     if (result == EGL_TRUE) {
 700         if (c) {
 701             setGLHooksThreadSpecific(c->cnx->hooks[c->version]);
 702             egl_tls_t::setContext(ctx);
 703 #if EGL_TRACE
 704             if (getEGLDebugLevel() > 0)
 705                 GLTrace_eglMakeCurrent(c->version, c->cnx->hooks[c->version], ctx);
 706 #endif
 707             _c.acquire();
 708             _r.acquire();
 709             _d.acquire();
 710         } else {
 711             setGLHooksThreadSpecific(&gHooksNoContext);
 712             egl_tls_t::setContext(EGL_NO_CONTEXT);
 713         }
 714     } else {
 715         // this will ALOGE the error
 716         result = setError(c->cnx->egl.eglGetError(), EGL_FALSE);
 717     }
 718     return result;
 719 }
 720
 721
 722 EGLBoolean eglQueryContext( EGLDisplay dpy, EGLContext ctx,
 723                             EGLint attribute, EGLint *value)
 724 {
 725     clearError();
 726
 727     const egl_display_ptr dp = validate_display(dpy);
 728     if (!dp) return EGL_FALSE;
 729
 730     ContextRef _c(dp.get(), ctx);
 731     if (!_c.get()) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
 732
 733     egl_context_t * const c = get_context(ctx);
 734     return c->cnx->egl.eglQueryContext(
 735             dp->disp.dpy, c->context, attribute, value);
 736
 737 }
 738
 739 EGLContext eglGetCurrentContext(void)
 740 {
 741     // could be called before eglInitialize(), but we wouldn't have a context
 742     // then, and this function would correctly return EGL_NO_CONTEXT.
 743
 744     clearError();
 745
 746     EGLContext ctx = getContext();
 747     return ctx;
 748 }
 749
 750 EGLSurface eglGetCurrentSurface(EGLint readdraw)
 751 {
 752     // could be called before eglInitialize(), but we wouldn't have a context
 753     // then, and this function would correctly return EGL_NO_SURFACE.
 754
 755     clearError();
 756
 757     EGLContext ctx = getContext();
 758     if (ctx) {
 759         egl_context_t const * const c = get_context(ctx);
 760         if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
 761         switch (readdraw) {
 762             case EGL_READ: return c->read;
 763             case EGL_DRAW: return c->draw;
 764             default: return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
 765         }
 766     }
 767     return EGL_NO_SURFACE;
 768 }
 769
 770 EGLDisplay eglGetCurrentDisplay(void)
 771 {
 772     // could be called before eglInitialize(), but we wouldn't have a context
 773     // then, and this function would correctly return EGL_NO_DISPLAY.
 774
 775     clearError();
 776
 777     EGLContext ctx = getContext();
 778     if (ctx) {
 779         egl_context_t const * const c = get_context(ctx);
 780         if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
 781         return c->dpy;
 782     }
 783     return EGL_NO_DISPLAY;
 784 }
 785
 786 EGLBoolean eglWaitGL(void)
 787 {
 788     clearError();
 789
 790     egl_connection_t* const cnx = &gEGLImpl;
 791     if (!cnx->dso)
 792         return setError(EGL_BAD_CONTEXT, EGL_FALSE);
 793
 794     return cnx->egl.eglWaitGL();
 795 }
 796
 797 EGLBoolean eglWaitNative(EGLint engine)
 798 {
 799     clearError();
 800
 801     egl_connection_t* const cnx = &gEGLImpl;
 802     if (!cnx->dso)
 803         return setError(EGL_BAD_CONTEXT, EGL_FALSE);
 804
 805     return cnx->egl.eglWaitNative(engine);
 806 }
 807
 808 EGLint eglGetError(void)
 809 {
 810     EGLint err = EGL_SUCCESS;
 811     egl_connection_t* const cnx = &gEGLImpl;
 812     if (cnx->dso) {
 813         err = cnx->egl.eglGetError();
 814     }
 815     if (err == EGL_SUCCESS) {
 816         err = egl_tls_t::getError();
 817     }
 818     return err;
 819 }
 820
 821 static __eglMustCastToProperFunctionPointerType findBuiltinGLWrapper(
 822         const char* procname) {
 823     const egl_connection_t* cnx = &gEGLImpl;
 824     void* proc = NULL;
 825
 826     proc = dlsym(cnx->libGles2, procname);
 827     if (proc) return (__eglMustCastToProperFunctionPointerType)proc;
 828
 829     proc = dlsym(cnx->libGles1, procname);
 830     if (proc) return (__eglMustCastToProperFunctionPointerType)proc;
 831
 832     return NULL;
 833 }
 834
 835 __eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname)
 836 {
 837     // eglGetProcAddress() could be the very first function called
 838     // in which case we must make sure we've initialized ourselves, this
 839     // happens the first time egl_get_display() is called.
 840
 841     clearError();
 842
 843     if (egl_init_drivers() == EGL_FALSE) {
 844         setError(EGL_BAD_PARAMETER, NULL);
 845         return  NULL;
 846     }
 847
 848     if (FILTER_EXTENSIONS(procname)) {
 849         return NULL;
 850     }
 851
 852     __eglMustCastToProperFunctionPointerType addr;
 853     addr = findProcAddress(procname, sExtensionMap, NELEM(sExtensionMap));
 854     if (addr) return addr;
 855
 856     addr = findBuiltinGLWrapper(procname);
 857     if (addr) return addr;
 858
 859     // this protects accesses to sGLExtentionMap and sGLExtentionSlot
 860     pthread_mutex_lock(&sExtensionMapMutex);
 861
 862         /*
 863          * Since eglGetProcAddress() is not associated to anything, it needs
 864          * to return a function pointer that "works" regardless of what
 865          * the current context is.
 866          *
 867          * For this reason, we return a "forwarder", a small stub that takes
 868          * care of calling the function associated with the context
 869          * currently bound.
 870          *
 871          * We first look for extensions we've already resolved, if we're seeing
 872          * this extension for the first time, we go through all our
 873          * implementations and call eglGetProcAddress() and record the
 874          * result in the appropriate implementation hooks and return the
 875          * address of the forwarder corresponding to that hook set.
 876          *
 877          */
 878
 879         const String8 name(procname);
 880         addr = sGLExtentionMap.valueFor(name);
 881         const int slot = sGLExtentionSlot;
 882
 883         ALOGE_IF(slot >= MAX_NUMBER_OF_GL_EXTENSIONS,
 884                 "no more slots for eglGetProcAddress(\"%s\")",
 885                 procname);
 886
 887 #if EGL_TRACE
 888         gl_hooks_t *debugHooks = GLTrace_getGLHooks();
 889 #endif
 890
 891         if (!addr && (slot < MAX_NUMBER_OF_GL_EXTENSIONS)) {
 892             bool found = false;
 893
 894             egl_connection_t* const cnx = &gEGLImpl;
 895             if (cnx->dso && cnx->egl.eglGetProcAddress) {
 896                 // Extensions are independent of the bound context
 897                 addr =
 898                 cnx->hooks[egl_connection_t::GLESv1_INDEX]->ext.extensions[slot] =
 899                 cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[slot] =
 900 #if EGL_TRACE
 901                 debugHooks->ext.extensions[slot] =
 902                 gHooksTrace.ext.extensions[slot] =
 903 #endif
 904                         cnx->egl.eglGetProcAddress(procname);
 905                 if (addr) found = true;
 906             }
 907
 908             if (found) {
 909                 addr = gExtensionForwarders[slot];
 910                 sGLExtentionMap.add(name, addr);
 911                 sGLExtentionSlot++;
 912             }
 913         }
 914
 915     pthread_mutex_unlock(&sExtensionMapMutex);
 916     return addr;
 917 }
 918
 919 class FrameCompletionThread : public Thread {
 920 public:
 921
 922     static void queueSync(EGLSyncKHR sync) {
 923         static sp<FrameCompletionThread> thread(new FrameCompletionThread);
 924         static bool running = false;
 925         if (!running) {
 926             thread->run("GPUFrameCompletion");
 927             running = true;
 928         }
 929         {
 930             Mutex::Autolock lock(thread->mMutex);
 931             ScopedTrace st(ATRACE_TAG, String8::format("kicked off frame %d",
 932                     thread->mFramesQueued).string());
 933             thread->mQueue.push_back(sync);
 934             thread->mCondition.signal();
 935             thread->mFramesQueued++;
 936             ATRACE_INT("GPU Frames Outstanding", thread->mQueue.size());
 937         }
 938     }
 939
 940 private:
 941     FrameCompletionThread() : mFramesQueued(0), mFramesCompleted(0) {}
 942
 943     virtual bool threadLoop() {
 944         EGLSyncKHR sync;
 945         uint32_t frameNum;
 946         {
 947             Mutex::Autolock lock(mMutex);
 948             while (mQueue.isEmpty()) {
 949                 mCondition.wait(mMutex);
 950             }
 951             sync = mQueue[0];
 952             frameNum = mFramesCompleted;
 953         }
 954         EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 955         {
 956             ScopedTrace st(ATRACE_TAG, String8::format("waiting for frame %d",
 957                     frameNum).string());
 958             EGLint result = eglClientWaitSyncKHR(dpy, sync, 0, EGL_FOREVER_KHR);
 959             if (result == EGL_FALSE) {
 960                 ALOGE("FrameCompletion: error waiting for fence: %#x", eglGetError());
 961             } else if (result == EGL_TIMEOUT_EXPIRED_KHR) {
 962                 ALOGE("FrameCompletion: timeout waiting for fence");
 963             }
 964             eglDestroySyncKHR(dpy, sync);
 965         }
 966         {
 967             Mutex::Autolock lock(mMutex);
 968             mQueue.removeAt(0);
 969             mFramesCompleted++;
 970             ATRACE_INT("GPU Frames Outstanding", mQueue.size());
 971         }
 972         return true;
 973     }
 974
 975     uint32_t mFramesQueued;
 976     uint32_t mFramesCompleted;
 977     Vector<EGLSyncKHR> mQueue;
 978     Condition mCondition;
 979     Mutex mMutex;
 980 };
 981
 982 EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw)
 983 {
 984     ATRACE_CALL();
 985     clearError();
 986
 987     const egl_display_ptr dp = validate_display(dpy);
 988     if (!dp) return EGL_FALSE;
 989
 990     SurfaceRef _s(dp.get(), draw);
 991     if (!_s.get())
 992         return setError(EGL_BAD_SURFACE, EGL_FALSE);
 993
 994 #if EGL_TRACE
 995     gl_hooks_t const *trace_hooks = getGLTraceThreadSpecific();
 996     if (getEGLDebugLevel() > 0) {
 997         if (trace_hooks == NULL) {
 998             if (GLTrace_start() < 0) {
 999                 ALOGE("Disabling Tracer for OpenGL ES");
1000                 setEGLDebugLevel(0);
1001             } else {
1002                 // switch over to the trace version of hooks
1003                 EGLContext ctx = egl_tls_t::getContext();
1004                 egl_context_t * const c = get_context(ctx);
1005                 if (c) {
1006                     setGLHooksThreadSpecific(c->cnx->hooks[c->version]);
1007                     GLTrace_eglMakeCurrent(c->version, c->cnx->hooks[c->version], ctx);
1008                 }
1009             }
1010         }
1011
1012         GLTrace_eglSwapBuffers(dpy, draw);
1013     } else if (trace_hooks != NULL) {
1014         // tracing is now disabled, so switch back to the non trace version
1015         EGLContext ctx = egl_tls_t::getContext();
1016         egl_context_t * const c = get_context(ctx);
1017         if (c) setGLHooksThreadSpecific(c->cnx->hooks[c->version]);
1018         GLTrace_stop();
1019     }
1020 #endif
1021
1022     egl_surface_t const * const s = get_surface(draw);
1023
1024     if (CC_UNLIKELY(dp->traceGpuCompletion)) {
1025         EGLSyncKHR sync = eglCreateSyncKHR(dpy, EGL_SYNC_FENCE_KHR, NULL);
1026         if (sync != EGL_NO_SYNC_KHR) {
1027             FrameCompletionThread::queueSync(sync);
1028         }
1029     }
1030
1031     if (CC_UNLIKELY(dp->finishOnSwap)) {
1032         uint32_t pixel;
1033         egl_context_t * const c = get_context( egl_tls_t::getContext() );
1034         if (c) {
1035             // glReadPixels() ensures that the frame is complete
1036             s->cnx->hooks[c->version]->gl.glReadPixels(0,0,1,1,
1037                     GL_RGBA,GL_UNSIGNED_BYTE,&pixel);
1038         }
1039     }
1040
1041     return s->cnx->egl.eglSwapBuffers(dp->disp.dpy, s->surface);
1042 }
1043
1044 EGLBoolean eglCopyBuffers(  EGLDisplay dpy, EGLSurface surface,
1045                             NativePixmapType target)
1046 {
1047     clearError();
1048
1049     const egl_display_ptr dp = validate_display(dpy);
1050     if (!dp) return EGL_FALSE;
1051
1052     SurfaceRef _s(dp.get(), surface);
1053     if (!_s.get())
1054         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1055
1056     egl_surface_t const * const s = get_surface(surface);
1057     return s->cnx->egl.eglCopyBuffers(dp->disp.dpy, s->surface, target);
1058 }
1059
1060 const char* eglQueryString(EGLDisplay dpy, EGLint name)
1061 {
1062     clearError();
1063
1064     const egl_display_ptr dp = validate_display(dpy);
1065     if (!dp) return (const char *) NULL;
1066
1067     switch (name) {
1068         case EGL_VENDOR:
1069             return dp->getVendorString();
1070         case EGL_VERSION:
1071             return dp->getVersionString();
1072         case EGL_EXTENSIONS:
1073             return dp->getExtensionString();
1074         case EGL_CLIENT_APIS:
1075             return dp->getClientApiString();
1076     }
1077     return setError(EGL_BAD_PARAMETER, (const char *)0);
1078 }
1079
1080 EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name)
1081 {
1082     clearError();
1083
1084     const egl_display_ptr dp = validate_display(dpy);
1085     if (!dp) return (const char *) NULL;
1086
1087     switch (name) {
1088         case EGL_VENDOR:
1089             return dp->disp.queryString.vendor;
1090         case EGL_VERSION:
1091             return dp->disp.queryString.version;
1092         case EGL_EXTENSIONS:
1093             return dp->disp.queryString.extensions;
1094         case EGL_CLIENT_APIS:
1095             return dp->disp.queryString.clientApi;
1096     }
1097     return setError(EGL_BAD_PARAMETER, (const char *)0);
1098 }
1099
1100 // ----------------------------------------------------------------------------
1101 // EGL 1.1
1102 // ----------------------------------------------------------------------------
1103
1104 EGLBoolean eglSurfaceAttrib(
1105         EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
1106 {
1107     clearError();
1108
1109     const egl_display_ptr dp = validate_display(dpy);
1110     if (!dp) return EGL_FALSE;
1111
1112     SurfaceRef _s(dp.get(), surface);
1113     if (!_s.get())
1114         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1115
1116     egl_surface_t const * const s = get_surface(surface);
1117     if (s->cnx->egl.eglSurfaceAttrib) {
1118         return s->cnx->egl.eglSurfaceAttrib(
1119                 dp->disp.dpy, s->surface, attribute, value);
1120     }
1121     return setError(EGL_BAD_SURFACE, EGL_FALSE);
1122 }
1123
1124 EGLBoolean eglBindTexImage(
1125         EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1126 {
1127     clearError();
1128
1129     const egl_display_ptr dp = validate_display(dpy);
1130     if (!dp) return EGL_FALSE;
1131
1132     SurfaceRef _s(dp.get(), surface);
1133     if (!_s.get())
1134         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1135
1136     egl_surface_t const * const s = get_surface(surface);
1137     if (s->cnx->egl.eglBindTexImage) {
1138         return s->cnx->egl.eglBindTexImage(
1139                 dp->disp.dpy, s->surface, buffer);
1140     }
1141     return setError(EGL_BAD_SURFACE, EGL_FALSE);
1142 }
1143
1144 EGLBoolean eglReleaseTexImage(
1145         EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1146 {
1147     clearError();
1148
1149     const egl_display_ptr dp = validate_display(dpy);
1150     if (!dp) return EGL_FALSE;
1151
1152     SurfaceRef _s(dp.get(), surface);
1153     if (!_s.get())
1154         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1155
1156     egl_surface_t const * const s = get_surface(surface);
1157     if (s->cnx->egl.eglReleaseTexImage) {
1158         return s->cnx->egl.eglReleaseTexImage(
1159                 dp->disp.dpy, s->surface, buffer);
1160     }
1161     return setError(EGL_BAD_SURFACE, EGL_FALSE);
1162 }
1163
1164 EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)
1165 {
1166     clearError();
1167
1168     const egl_display_ptr dp = validate_display(dpy);
1169     if (!dp) return EGL_FALSE;
1170
1171     EGLBoolean res = EGL_TRUE;
1172     egl_connection_t* const cnx = &gEGLImpl;
1173     if (cnx->dso && cnx->egl.eglSwapInterval) {
1174         res = cnx->egl.eglSwapInterval(dp->disp.dpy, interval);
1175     }
1176
1177     return res;
1178 }
1179
1180
1181 // ----------------------------------------------------------------------------
1182 // EGL 1.2
1183 // ----------------------------------------------------------------------------
1184
1185 EGLBoolean eglWaitClient(void)
1186 {
1187     clearError();
1188
1189     egl_connection_t* const cnx = &gEGLImpl;
1190     if (!cnx->dso)
1191         return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1192
1193     EGLBoolean res;
1194     if (cnx->egl.eglWaitClient) {
1195         res = cnx->egl.eglWaitClient();
1196     } else {
1197         res = cnx->egl.eglWaitGL();
1198     }
1199     return res;
1200 }
1201
1202 EGLBoolean eglBindAPI(EGLenum api)
1203 {
1204     clearError();
1205
1206     if (egl_init_drivers() == EGL_FALSE) {
1207         return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1208     }
1209
1210     // bind this API on all EGLs
1211     EGLBoolean res = EGL_TRUE;
1212     egl_connection_t* const cnx = &gEGLImpl;
1213     if (cnx->dso && cnx->egl.eglBindAPI) {
1214         res = cnx->egl.eglBindAPI(api);
1215     }
1216     return res;
1217 }
1218
1219 EGLenum eglQueryAPI(void)
1220 {
1221     clearError();
1222
1223     if (egl_init_drivers() == EGL_FALSE) {
1224         return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1225     }
1226
1227     egl_connection_t* const cnx = &gEGLImpl;
1228     if (cnx->dso && cnx->egl.eglQueryAPI) {
1229         return cnx->egl.eglQueryAPI();
1230     }
1231
1232     // or, it can only be OpenGL ES
1233     return EGL_OPENGL_ES_API;
1234 }
1235
1236 EGLBoolean eglReleaseThread(void)
1237 {
1238     clearError();
1239
1240 #if EGL_TRACE
1241     if (getEGLDebugLevel() > 0)
1242         GLTrace_eglReleaseThread();
1243 #endif
1244
1245     // If there is context bound to the thread, release it
1246     egl_display_t::loseCurrent(get_context(getContext()));
1247
1248     egl_connection_t* const cnx = &gEGLImpl;
1249     if (cnx->dso && cnx->egl.eglReleaseThread) {
1250         cnx->egl.eglReleaseThread();
1251     }
1252     egl_tls_t::clearTLS();
1253     return EGL_TRUE;
1254 }
1255
1256 EGLSurface eglCreatePbufferFromClientBuffer(
1257           EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
1258           EGLConfig config, const EGLint *attrib_list)
1259 {
1260     clearError();
1261
1262     egl_connection_t* cnx = NULL;
1263     const egl_display_ptr dp = validate_display_connection(dpy, cnx);
1264     if (!dp) return EGL_FALSE;
1265     if (cnx->egl.eglCreatePbufferFromClientBuffer) {
1266         return cnx->egl.eglCreatePbufferFromClientBuffer(
1267                 dp->disp.dpy, buftype, buffer, config, attrib_list);
1268     }
1269     return setError(EGL_BAD_CONFIG, EGL_NO_SURFACE);
1270 }
1271
1272 // ----------------------------------------------------------------------------
1273 // EGL_EGLEXT_VERSION 3
1274 // ----------------------------------------------------------------------------
1275
1276 EGLBoolean eglLockSurfaceKHR(EGLDisplay dpy, EGLSurface surface,
1277         const EGLint *attrib_list)
1278 {
1279     clearError();
1280
1281     const egl_display_ptr dp = validate_display(dpy);
1282     if (!dp) return EGL_FALSE;
1283
1284     SurfaceRef _s(dp.get(), surface);
1285     if (!_s.get())
1286         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1287
1288     egl_surface_t const * const s = get_surface(surface);
1289     if (s->cnx->egl.eglLockSurfaceKHR) {
1290         return s->cnx->egl.eglLockSurfaceKHR(
1291                 dp->disp.dpy, s->surface, attrib_list);
1292     }
1293     return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1294 }
1295
1296 EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface)
1297 {
1298     clearError();
1299
1300     const egl_display_ptr dp = validate_display(dpy);
1301     if (!dp) return EGL_FALSE;
1302
1303     SurfaceRef _s(dp.get(), surface);
1304     if (!_s.get())
1305         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1306
1307     egl_surface_t const * const s = get_surface(surface);
1308     if (s->cnx->egl.eglUnlockSurfaceKHR) {
1309         return s->cnx->egl.eglUnlockSurfaceKHR(dp->disp.dpy, s->surface);
1310     }
1311     return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1312 }
1313
1314 EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
1315         EGLClientBuffer buffer, const EGLint *attrib_list)
1316 {
1317     clearError();
1318
1319     const egl_display_ptr dp = validate_display(dpy);
1320     if (!dp) return EGL_NO_IMAGE_KHR;
1321
1322     ContextRef _c(dp.get(), ctx);
1323     egl_context_t * const c = _c.get();
1324
1325     EGLImageKHR result = EGL_NO_IMAGE_KHR;
1326     egl_connection_t* const cnx = &gEGLImpl;
1327     if (cnx->dso && cnx->egl.eglCreateImageKHR) {
1328         result = cnx->egl.eglCreateImageKHR(
1329                 dp->disp.dpy,
1330                 c ? c->context : EGL_NO_CONTEXT,
1331                 target, buffer, attrib_list);
1332     }
1333     return result;
1334 }
1335
1336 EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img)
1337 {
1338     clearError();
1339
1340     const egl_display_ptr dp = validate_display(dpy);
1341     if (!dp) return EGL_FALSE;
1342
1343     EGLBoolean result = EGL_FALSE;
1344     egl_connection_t* const cnx = &gEGLImpl;
1345     if (cnx->dso && cnx->egl.eglDestroyImageKHR) {
1346         result = cnx->egl.eglDestroyImageKHR(dp->disp.dpy, img);
1347     }
1348     return result;
1349 }
1350
1351 // ----------------------------------------------------------------------------
1352 // EGL_EGLEXT_VERSION 5
1353 // ----------------------------------------------------------------------------
1354
1355
1356 EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
1357 {
1358     clearError();
1359
1360     const egl_display_ptr dp = validate_display(dpy);
1361     if (!dp) return EGL_NO_SYNC_KHR;
1362
1363     EGLSyncKHR result = EGL_NO_SYNC_KHR;
1364     egl_connection_t* const cnx = &gEGLImpl;
1365     if (cnx->dso && cnx->egl.eglCreateSyncKHR) {
1366         result = cnx->egl.eglCreateSyncKHR(dp->disp.dpy, type, attrib_list);
1367     }
1368     return result;
1369 }
1370
1371 EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
1372 {
1373     clearError();
1374
1375     const egl_display_ptr dp = validate_display(dpy);
1376     if (!dp) return EGL_FALSE;
1377
1378     EGLBoolean result = EGL_FALSE;
1379     egl_connection_t* const cnx = &gEGLImpl;
1380     if (cnx->dso && cnx->egl.eglDestroySyncKHR) {
1381         result = cnx->egl.eglDestroySyncKHR(dp->disp.dpy, sync);
1382     }
1383     return result;
1384 }
1385
1386 EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) {
1387     clearError();
1388
1389     const egl_display_ptr dp = validate_display(dpy);
1390     if (!dp) return EGL_FALSE;
1391
1392     EGLBoolean result = EGL_FALSE;
1393     egl_connection_t* const cnx = &gEGLImpl;
1394     if (cnx->dso && cnx->egl.eglSignalSyncKHR) {
1395         result = cnx->egl.eglSignalSyncKHR(
1396                 dp->disp.dpy, sync, mode);
1397     }
1398     return result;
1399 }
1400
1401 EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync,
1402         EGLint flags, EGLTimeKHR timeout)
1403 {
1404     clearError();
1405
1406     const egl_display_ptr dp = validate_display(dpy);
1407     if (!dp) return EGL_FALSE;
1408
1409     EGLBoolean result = EGL_FALSE;
1410     egl_connection_t* const cnx = &gEGLImpl;
1411     if (cnx->dso && cnx->egl.eglClientWaitSyncKHR) {
1412         result = cnx->egl.eglClientWaitSyncKHR(
1413                 dp->disp.dpy, sync, flags, timeout);
1414     }
1415     return result;
1416 }
1417
1418 EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync,
1419         EGLint attribute, EGLint *value)
1420 {
1421     clearError();
1422
1423     const egl_display_ptr dp = validate_display(dpy);
1424     if (!dp) return EGL_FALSE;
1425
1426     EGLBoolean result = EGL_FALSE;
1427     egl_connection_t* const cnx = &gEGLImpl;
1428     if (cnx->dso && cnx->egl.eglGetSyncAttribKHR) {
1429         result = cnx->egl.eglGetSyncAttribKHR(
1430                 dp->disp.dpy, sync, attribute, value);
1431     }
1432     return result;
1433 }
1434
1435 // ----------------------------------------------------------------------------
1436 // EGL_EGLEXT_VERSION 15
1437 // ----------------------------------------------------------------------------
1438
1439 EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) {
1440     clearError();
1441     const egl_display_ptr dp = validate_display(dpy);
1442     if (!dp) return EGL_FALSE;
1443     EGLint result = EGL_FALSE;
1444     egl_connection_t* const cnx = &gEGLImpl;
1445     if (cnx->dso && cnx->egl.eglWaitSyncKHR) {
1446         result = cnx->egl.eglWaitSyncKHR(dp->disp.dpy, sync, flags);
1447     }
1448     return result;
1449 }
1450
1451 // ----------------------------------------------------------------------------
1452 // ANDROID extensions
1453 // ----------------------------------------------------------------------------
1454
1455 EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync)
1456 {
1457     clearError();
1458
1459     const egl_display_ptr dp = validate_display(dpy);
1460     if (!dp) return EGL_NO_NATIVE_FENCE_FD_ANDROID;
1461
1462     EGLint result = EGL_NO_NATIVE_FENCE_FD_ANDROID;
1463     egl_connection_t* const cnx = &gEGLImpl;
1464     if (cnx->dso && cnx->egl.eglDupNativeFenceFDANDROID) {
1465         result = cnx->egl.eglDupNativeFenceFDANDROID(dp->disp.dpy, sync);
1466     }
1467     return result;
1468 }
1469
1470 EGLBoolean eglPresentationTimeANDROID(EGLDisplay dpy, EGLSurface surface,
1471         EGLnsecsANDROID time)
1472 {
1473     clearError();
1474
1475     const egl_display_ptr dp = validate_display(dpy);
1476     if (!dp) {
1477         return EGL_FALSE;
1478     }
1479
1480     SurfaceRef _s(dp.get(), surface);
1481     if (!_s.get()) {
1482         setError(EGL_BAD_SURFACE, EGL_FALSE);
1483         return EGL_FALSE;
1484     }
1485
1486     egl_surface_t const * const s = get_surface(surface);
1487     native_window_set_buffers_timestamp(s->win.get(), time);
1488
1489     return EGL_TRUE;
1490 }
1491
1492 // ----------------------------------------------------------------------------
1493 // NVIDIA extensions
1494 // ----------------------------------------------------------------------------
1495 EGLuint64NV eglGetSystemTimeFrequencyNV()
1496 {
1497     clearError();
1498
1499     if (egl_init_drivers() == EGL_FALSE) {
1500         return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1501     }
1502
1503     EGLuint64NV ret = 0;
1504     egl_connection_t* const cnx = &gEGLImpl;
1505
1506     if (cnx->dso && cnx->egl.eglGetSystemTimeFrequencyNV) {
1507         return cnx->egl.eglGetSystemTimeFrequencyNV();
1508     }
1509
1510     return setErrorQuiet(EGL_BAD_DISPLAY, 0);
1511 }
1512
1513 EGLuint64NV eglGetSystemTimeNV()
1514 {
1515     clearError();
1516
1517     if (egl_init_drivers() == EGL_FALSE) {
1518         return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1519     }
1520
1521     EGLuint64NV ret = 0;
1522     egl_connection_t* const cnx = &gEGLImpl;
1523
1524     if (cnx->dso && cnx->egl.eglGetSystemTimeNV) {
1525         return cnx->egl.eglGetSystemTimeNV();
1526     }
1527
1528     return setErrorQuiet(EGL_BAD_DISPLAY, 0);
1529 }