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