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