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 <ui/GraphicBuffer.h>
  37
  38 #include <utils/KeyedVector.h>
  39 #include <utils/SortedVector.h>
  40 #include <utils/String8.h>
  41 #include <utils/Trace.h>
  42
  43 #include "../egl_impl.h"
  44 #include "../hooks.h"
  45
  46 #include "egl_display.h"
  47 #include "egl_object.h"
  48 #include "egl_tls.h"
  49 #include "egldefs.h"
  50
  51 using namespace android;
  52
  53 // This extension has not been ratified yet, so can't be shipped.
  54 // Implementation is incomplete and untested.
  55 #define ENABLE_EGL_KHR_GL_COLORSPACE 0
  56
  57 #define ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS 0
  58
  59 // ----------------------------------------------------------------------------
  60
  61 namespace android {
  62
  63 struct extention_map_t {
  64     const char* name;
  65     __eglMustCastToProperFunctionPointerType address;
  66 };
  67
  68 /*
  69  * This is the list of EGL extensions exposed to applications.
  70  *
  71  * Some of them (gBuiltinExtensionString) are implemented entirely in this EGL
  72  * wrapper and are always available.
  73  *
  74  * The rest (gExtensionString) depend on support in the EGL driver, and are
  75  * only available if the driver supports them. However, some of these must be
  76  * supported because they are used by the Android system itself; these are
  77  * listed as mandatory below and are required by the CDD. The system *assumes*
  78  * the mandatory extensions are present and may not function properly if some
  79  * are missing.
  80  *
  81  * NOTE: Both strings MUST have a single space as the last character.
  82  */
  83 extern char const * const gBuiltinExtensionString =
  84         "EGL_KHR_get_all_proc_addresses "
  85         "EGL_ANDROID_presentation_time "
  86         "EGL_KHR_swap_buffers_with_damage "
  87         "EGL_ANDROID_create_native_client_buffer "
  88         "EGL_ANDROID_front_buffer_auto_refresh "
  89 #if ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS
  90         "EGL_ANDROID_get_frame_timestamps "
  91 #endif
  92         ;
  93 extern char const * const gExtensionString  =
  94         "EGL_KHR_image "                        // mandatory
  95         "EGL_KHR_image_base "                   // mandatory
  96         "EGL_KHR_image_pixmap "
  97         "EGL_KHR_lock_surface "
  98 #if (ENABLE_EGL_KHR_GL_COLORSPACE != 0)
  99         "EGL_KHR_gl_colorspace "
 100 #endif
 101         "EGL_KHR_gl_texture_2D_image "
 102         "EGL_KHR_gl_texture_3D_image "
 103         "EGL_KHR_gl_texture_cubemap_image "
 104         "EGL_KHR_gl_renderbuffer_image "
 105         "EGL_KHR_reusable_sync "
 106         "EGL_KHR_fence_sync "
 107         "EGL_KHR_create_context "
 108         "EGL_KHR_config_attribs "
 109         "EGL_KHR_surfaceless_context "
 110         "EGL_KHR_stream "
 111         "EGL_KHR_stream_fifo "
 112         "EGL_KHR_stream_producer_eglsurface "
 113         "EGL_KHR_stream_consumer_gltexture "
 114         "EGL_KHR_stream_cross_process_fd "
 115         "EGL_EXT_create_context_robustness "
 116         "EGL_NV_system_time "
 117         "EGL_ANDROID_image_native_buffer "      // mandatory
 118         "EGL_KHR_wait_sync "                    // strongly recommended
 119         "EGL_ANDROID_recordable "               // mandatory
 120         "EGL_KHR_partial_update "               // strongly recommended
 121         "EGL_EXT_buffer_age "                   // strongly recommended with partial_update
 122         "EGL_KHR_create_context_no_error "
 123         "EGL_KHR_mutable_render_buffer "
 124         "EGL_EXT_yuv_surface "
 125         "EGL_EXT_protected_content "
 126         ;
 127
 128 // extensions not exposed to applications but used by the ANDROID system
 129 //      "EGL_ANDROID_blob_cache "               // strongly recommended
 130 //      "EGL_IMG_hibernate_process "            // optional
 131 //      "EGL_ANDROID_native_fence_sync "        // strongly recommended
 132 //      "EGL_ANDROID_framebuffer_target "       // mandatory for HWC 1.1
 133 //      "EGL_ANDROID_image_crop "               // optional
 134
 135 /*
 136  * EGL Extensions entry-points exposed to 3rd party applications
 137  * (keep in sync with gExtensionString above)
 138  *
 139  */
 140 static const extention_map_t sExtensionMap[] = {
 141     // EGL_KHR_lock_surface
 142     { "eglLockSurfaceKHR",
 143             (__eglMustCastToProperFunctionPointerType)&eglLockSurfaceKHR },
 144     { "eglUnlockSurfaceKHR",
 145             (__eglMustCastToProperFunctionPointerType)&eglUnlockSurfaceKHR },
 146
 147     // EGL_KHR_image, EGL_KHR_image_base
 148     { "eglCreateImageKHR",
 149             (__eglMustCastToProperFunctionPointerType)&eglCreateImageKHR },
 150     { "eglDestroyImageKHR",
 151             (__eglMustCastToProperFunctionPointerType)&eglDestroyImageKHR },
 152
 153     // EGL_KHR_reusable_sync, EGL_KHR_fence_sync
 154     { "eglCreateSyncKHR",
 155             (__eglMustCastToProperFunctionPointerType)&eglCreateSyncKHR },
 156     { "eglDestroySyncKHR",
 157             (__eglMustCastToProperFunctionPointerType)&eglDestroySyncKHR },
 158     { "eglClientWaitSyncKHR",
 159             (__eglMustCastToProperFunctionPointerType)&eglClientWaitSyncKHR },
 160     { "eglSignalSyncKHR",
 161             (__eglMustCastToProperFunctionPointerType)&eglSignalSyncKHR },
 162     { "eglGetSyncAttribKHR",
 163             (__eglMustCastToProperFunctionPointerType)&eglGetSyncAttribKHR },
 164
 165     // EGL_NV_system_time
 166     { "eglGetSystemTimeFrequencyNV",
 167             (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeFrequencyNV },
 168     { "eglGetSystemTimeNV",
 169             (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeNV },
 170
 171     // EGL_KHR_wait_sync
 172     { "eglWaitSyncKHR",
 173             (__eglMustCastToProperFunctionPointerType)&eglWaitSyncKHR },
 174
 175     // EGL_ANDROID_presentation_time
 176     { "eglPresentationTimeANDROID",
 177             (__eglMustCastToProperFunctionPointerType)&eglPresentationTimeANDROID },
 178
 179     // EGL_KHR_swap_buffers_with_damage
 180     { "eglSwapBuffersWithDamageKHR",
 181             (__eglMustCastToProperFunctionPointerType)&eglSwapBuffersWithDamageKHR },
 182
 183     // EGL_ANDROID_native_client_buffer
 184     { "eglCreateNativeClientBufferANDROID",
 185             (__eglMustCastToProperFunctionPointerType)&eglCreateNativeClientBufferANDROID },
 186
 187     // EGL_KHR_partial_update
 188     { "eglSetDamageRegionKHR",
 189             (__eglMustCastToProperFunctionPointerType)&eglSetDamageRegionKHR },
 190
 191     { "eglCreateStreamKHR",
 192             (__eglMustCastToProperFunctionPointerType)&eglCreateStreamKHR },
 193     { "eglDestroyStreamKHR",
 194             (__eglMustCastToProperFunctionPointerType)&eglDestroyStreamKHR },
 195     { "eglStreamAttribKHR",
 196             (__eglMustCastToProperFunctionPointerType)&eglStreamAttribKHR },
 197     { "eglQueryStreamKHR",
 198             (__eglMustCastToProperFunctionPointerType)&eglQueryStreamKHR },
 199     { "eglQueryStreamu64KHR",
 200             (__eglMustCastToProperFunctionPointerType)&eglQueryStreamu64KHR },
 201     { "eglQueryStreamTimeKHR",
 202             (__eglMustCastToProperFunctionPointerType)&eglQueryStreamTimeKHR },
 203     { "eglCreateStreamProducerSurfaceKHR",
 204             (__eglMustCastToProperFunctionPointerType)&eglCreateStreamProducerSurfaceKHR },
 205     { "eglStreamConsumerGLTextureExternalKHR",
 206             (__eglMustCastToProperFunctionPointerType)&eglStreamConsumerGLTextureExternalKHR },
 207     { "eglStreamConsumerAcquireKHR",
 208             (__eglMustCastToProperFunctionPointerType)&eglStreamConsumerAcquireKHR },
 209     { "eglStreamConsumerReleaseKHR",
 210             (__eglMustCastToProperFunctionPointerType)&eglStreamConsumerReleaseKHR },
 211     { "eglGetStreamFileDescriptorKHR",
 212             (__eglMustCastToProperFunctionPointerType)&eglGetStreamFileDescriptorKHR },
 213     { "eglCreateStreamFromFileDescriptorKHR",
 214             (__eglMustCastToProperFunctionPointerType)&eglCreateStreamFromFileDescriptorKHR },
 215
 216     // EGL_ANDROID_get_frame_timestamps
 217     { "eglGetFrameTimestampsANDROID",
 218             (__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampsANDROID },
 219     { "eglQueryTimestampSupportedANDROID",
 220             (__eglMustCastToProperFunctionPointerType)&eglQueryTimestampSupportedANDROID },
 221 };
 222
 223 /*
 224  * These extensions entry-points should not be exposed to applications.
 225  * They're used internally by the Android EGL layer.
 226  */
 227 #define FILTER_EXTENSIONS(procname) \
 228         (!strcmp((procname), "eglSetBlobCacheFuncsANDROID") ||    \
 229          !strcmp((procname), "eglHibernateProcessIMG")      ||    \
 230          !strcmp((procname), "eglAwakenProcessIMG")         ||    \
 231          !strcmp((procname), "eglDupNativeFenceFDANDROID"))
 232
 233
 234
 235 // accesses protected by sExtensionMapMutex
 236 static DefaultKeyedVector<String8, __eglMustCastToProperFunctionPointerType> sGLExtentionMap;
 237 static int sGLExtentionSlot = 0;
 238 static pthread_mutex_t sExtensionMapMutex = PTHREAD_MUTEX_INITIALIZER;
 239
 240 static void(*findProcAddress(const char* name,
 241         const extention_map_t* map, size_t n))() {
 242     for (uint32_t i=0 ; i<n ; i++) {
 243         if (!strcmp(name, map[i].name)) {
 244             return map[i].address;
 245         }
 246     }
 247     return NULL;
 248 }
 249
 250 // ----------------------------------------------------------------------------
 251
 252 extern void setGLHooksThreadSpecific(gl_hooks_t const *value);
 253 extern EGLBoolean egl_init_drivers();
 254 extern const __eglMustCastToProperFunctionPointerType gExtensionForwarders[MAX_NUMBER_OF_GL_EXTENSIONS];
 255 extern gl_hooks_t gHooksTrace;
 256
 257 } // namespace android;
 258
 259
 260 // ----------------------------------------------------------------------------
 261
 262 static inline void clearError() { egl_tls_t::clearError(); }
 263 static inline EGLContext getContext() { return egl_tls_t::getContext(); }
 264
 265 // ----------------------------------------------------------------------------
 266
 267 EGLDisplay eglGetDisplay(EGLNativeDisplayType display)
 268 {
 269     clearError();
 270
 271     uintptr_t index = reinterpret_cast<uintptr_t>(display);
 272     if (index >= NUM_DISPLAYS) {
 273         return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);
 274     }
 275
 276     if (egl_init_drivers() == EGL_FALSE) {
 277         return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);
 278     }
 279
 280     EGLDisplay dpy = egl_display_t::getFromNativeDisplay(display);
 281     return dpy;
 282 }
 283
 284 // ----------------------------------------------------------------------------
 285 // Initialization
 286 // ----------------------------------------------------------------------------
 287
 288 EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
 289 {
 290     clearError();
 291
 292     egl_display_ptr dp = get_display(dpy);
 293     if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
 294
 295     EGLBoolean res = dp->initialize(major, minor);
 296
 297     return res;
 298 }
 299
 300 EGLBoolean eglTerminate(EGLDisplay dpy)
 301 {
 302     // NOTE: don't unload the drivers b/c some APIs can be called
 303     // after eglTerminate() has been called. eglTerminate() only
 304     // terminates an EGLDisplay, not a EGL itself.
 305
 306     clearError();
 307
 308     egl_display_ptr dp = get_display(dpy);
 309     if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
 310
 311     EGLBoolean res = dp->terminate();
 312
 313     return res;
 314 }
 315
 316 // ----------------------------------------------------------------------------
 317 // configuration
 318 // ----------------------------------------------------------------------------
 319
 320 EGLBoolean eglGetConfigs(   EGLDisplay dpy,
 321                             EGLConfig *configs,
 322                             EGLint config_size, EGLint *num_config)
 323 {
 324     clearError();
 325
 326     const egl_display_ptr dp = validate_display(dpy);
 327     if (!dp) return EGL_FALSE;
 328
 329     if (num_config==0) {
 330         return setError(EGL_BAD_PARAMETER, EGL_FALSE);
 331     }
 332
 333     EGLBoolean res = EGL_FALSE;
 334     *num_config = 0;
 335
 336     egl_connection_t* const cnx = &gEGLImpl;
 337     if (cnx->dso) {
 338         res = cnx->egl.eglGetConfigs(
 339                 dp->disp.dpy, configs, config_size, num_config);
 340     }
 341
 342     return res;
 343 }
 344
 345 EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list,
 346                             EGLConfig *configs, EGLint config_size,
 347                             EGLint *num_config)
 348 {
 349     clearError();
 350
 351     const egl_display_ptr dp = validate_display(dpy);
 352     if (!dp) return EGL_FALSE;
 353
 354     if (num_config==0) {
 355         return setError(EGL_BAD_PARAMETER, EGL_FALSE);
 356     }
 357
 358     EGLBoolean res = EGL_FALSE;
 359     *num_config = 0;
 360
 361     egl_connection_t* const cnx = &gEGLImpl;
 362     if (cnx->dso) {
 363         if (attrib_list) {
 364             char value[PROPERTY_VALUE_MAX];
 365             property_get("debug.egl.force_msaa", value, "false");
 366
 367             if (!strcmp(value, "true")) {
 368                 size_t attribCount = 0;
 369                 EGLint attrib = attrib_list[0];
 370
 371                 // Only enable MSAA if the context is OpenGL ES 2.0 and
 372                 // if no caveat is requested
 373                 const EGLint *attribRendererable = NULL;
 374                 const EGLint *attribCaveat = NULL;
 375
 376                 // Count the number of attributes and look for
 377                 // EGL_RENDERABLE_TYPE and EGL_CONFIG_CAVEAT
 378                 while (attrib != EGL_NONE) {
 379                     attrib = attrib_list[attribCount];
 380                     switch (attrib) {
 381                         case EGL_RENDERABLE_TYPE:
 382                             attribRendererable = &attrib_list[attribCount];
 383                             break;
 384                         case EGL_CONFIG_CAVEAT:
 385                             attribCaveat = &attrib_list[attribCount];
 386                             break;
 387                     }
 388                     attribCount++;
 389                 }
 390
 391                 if (attribRendererable && attribRendererable[1] == EGL_OPENGL_ES2_BIT &&
 392                         (!attribCaveat || attribCaveat[1] != EGL_NONE)) {
 393
 394                     // Insert 2 extra attributes to force-enable MSAA 4x
 395                     EGLint aaAttribs[attribCount + 4];
 396                     aaAttribs[0] = EGL_SAMPLE_BUFFERS;
 397                     aaAttribs[1] = 1;
 398                     aaAttribs[2] = EGL_SAMPLES;
 399                     aaAttribs[3] = 4;
 400
 401                     memcpy(&aaAttribs[4], attrib_list, attribCount * sizeof(EGLint));
 402
 403                     EGLint numConfigAA;
 404                     EGLBoolean resAA = cnx->egl.eglChooseConfig(
 405                             dp->disp.dpy, aaAttribs, configs, config_size, &numConfigAA);
 406
 407                     if (resAA == EGL_TRUE && numConfigAA > 0) {
 408                         ALOGD("Enabling MSAA 4x");
 409                         *num_config = numConfigAA;
 410                         return resAA;
 411                     }
 412                 }
 413             }
 414         }
 415
 416         res = cnx->egl.eglChooseConfig(
 417                 dp->disp.dpy, attrib_list, configs, config_size, num_config);
 418     }
 419     return res;
 420 }
 421
 422 EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
 423         EGLint attribute, EGLint *value)
 424 {
 425     clearError();
 426
 427     egl_connection_t* cnx = NULL;
 428     const egl_display_ptr dp = validate_display_connection(dpy, cnx);
 429     if (!dp) return EGL_FALSE;
 430
 431     return cnx->egl.eglGetConfigAttrib(
 432             dp->disp.dpy, config, attribute, value);
 433 }
 434
 435 // ----------------------------------------------------------------------------
 436 // surfaces
 437 // ----------------------------------------------------------------------------
 438
 439 // The EGL_KHR_gl_colorspace spec hasn't been ratified yet, so these haven't
 440 // been added to the Khronos egl.h.
 441 #define EGL_GL_COLORSPACE_KHR           EGL_VG_COLORSPACE
 442 #define EGL_GL_COLORSPACE_SRGB_KHR      EGL_VG_COLORSPACE_sRGB
 443 #define EGL_GL_COLORSPACE_LINEAR_KHR    EGL_VG_COLORSPACE_LINEAR
 444
 445 // Turn linear formats into corresponding sRGB formats when colorspace is
 446 // EGL_GL_COLORSPACE_SRGB_KHR, or turn sRGB formats into corresponding linear
 447 // formats when colorspace is EGL_GL_COLORSPACE_LINEAR_KHR. In any cases where
 448 // the modification isn't possible, the original dataSpace is returned.
 449 static android_dataspace modifyBufferDataspace( android_dataspace dataSpace,
 450                                                 EGLint colorspace) {
 451     if (colorspace == EGL_GL_COLORSPACE_LINEAR_KHR) {
 452         return HAL_DATASPACE_SRGB_LINEAR;
 453     } else if (colorspace == EGL_GL_COLORSPACE_SRGB_KHR) {
 454         return HAL_DATASPACE_SRGB;
 455     }
 456     return dataSpace;
 457 }
 458
 459 EGLSurface eglCreateWindowSurface(  EGLDisplay dpy, EGLConfig config,
 460                                     NativeWindowType window,
 461                                     const EGLint *attrib_list)
 462 {
 463     clearError();
 464
 465     egl_connection_t* cnx = NULL;
 466     egl_display_ptr dp = validate_display_connection(dpy, cnx);
 467     if (dp) {
 468         EGLDisplay iDpy = dp->disp.dpy;
 469
 470         int result = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
 471         if (result != OK) {
 472             ALOGE("eglCreateWindowSurface: native_window_api_connect (win=%p) "
 473                     "failed (%#x) (already connected to another API?)",
 474                     window, result);
 475             return setError(EGL_BAD_ALLOC, EGL_NO_SURFACE);
 476         }
 477
 478         // Set the native window's buffers format to match what this config requests.
 479         // Whether to use sRGB gamma is not part of the EGLconfig, but is part
 480         // of our native format. So if sRGB gamma is requested, we have to
 481         // modify the EGLconfig's format before setting the native window's
 482         // format.
 483
 484         // by default, just pick RGBA_8888
 485         EGLint format = HAL_PIXEL_FORMAT_RGBA_8888;
 486         android_dataspace dataSpace = HAL_DATASPACE_UNKNOWN;
 487
 488         EGLint a = 0;
 489         cnx->egl.eglGetConfigAttrib(iDpy, config, EGL_ALPHA_SIZE, &a);
 490         if (a > 0) {
 491             // alpha-channel requested, there's really only one suitable format
 492             format = HAL_PIXEL_FORMAT_RGBA_8888;
 493         } else {
 494             EGLint r, g, b;
 495             r = g = b = 0;
 496             cnx->egl.eglGetConfigAttrib(iDpy, config, EGL_RED_SIZE,   &r);
 497             cnx->egl.eglGetConfigAttrib(iDpy, config, EGL_GREEN_SIZE, &g);
 498             cnx->egl.eglGetConfigAttrib(iDpy, config, EGL_BLUE_SIZE,  &b);
 499             EGLint colorDepth = r + g + b;
 500             if (colorDepth <= 16) {
 501                 format = HAL_PIXEL_FORMAT_RGB_565;
 502             } else {
 503                 format = HAL_PIXEL_FORMAT_RGBX_8888;
 504             }
 505         }
 506
 507         // now select a corresponding sRGB format if needed
 508         if (attrib_list && dp->haveExtension("EGL_KHR_gl_colorspace")) {
 509             for (const EGLint* attr = attrib_list; *attr != EGL_NONE; attr += 2) {
 510                 if (*attr == EGL_GL_COLORSPACE_KHR) {
 511                     if (ENABLE_EGL_KHR_GL_COLORSPACE) {
 512                         dataSpace = modifyBufferDataspace(dataSpace, *(attr+1));
 513                     } else {
 514                         // Normally we'd pass through unhandled attributes to
 515                         // the driver. But in case the driver implements this
 516                         // extension but we're disabling it, we want to prevent
 517                         // it getting through -- support will be broken without
 518                         // our help.
 519                         ALOGE("sRGB window surfaces not supported");
 520                         return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
 521                     }
 522                 }
 523             }
 524         }
 525
 526         if (format != 0) {
 527             int err = native_window_set_buffers_format(window, format);
 528             if (err != 0) {
 529                 ALOGE("error setting native window pixel format: %s (%d)",
 530                         strerror(-err), err);
 531                 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
 532                 return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
 533             }
 534         }
 535
 536         if (dataSpace != 0) {
 537             int err = native_window_set_buffers_data_space(window, dataSpace);
 538             if (err != 0) {
 539                 ALOGE("error setting native window pixel dataSpace: %s (%d)",
 540                         strerror(-err), err);
 541                 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
 542                 return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
 543             }
 544         }
 545
 546         // the EGL spec requires that a new EGLSurface default to swap interval
 547         // 1, so explicitly set that on the window here.
 548         ANativeWindow* anw = reinterpret_cast<ANativeWindow*>(window);
 549         anw->setSwapInterval(anw, 1);
 550
 551         EGLSurface surface = cnx->egl.eglCreateWindowSurface(
 552                 iDpy, config, window, attrib_list);
 553         if (surface != EGL_NO_SURFACE) {
 554             egl_surface_t* s = new egl_surface_t(dp.get(), config, window,
 555                     surface, cnx);
 556             return s;
 557         }
 558
 559         // EGLSurface creation failed
 560         native_window_set_buffers_format(window, 0);
 561         native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
 562     }
 563     return EGL_NO_SURFACE;
 564 }
 565
 566 EGLSurface eglCreatePixmapSurface(  EGLDisplay dpy, EGLConfig config,
 567                                     NativePixmapType pixmap,
 568                                     const EGLint *attrib_list)
 569 {
 570     clearError();
 571
 572     egl_connection_t* cnx = NULL;
 573     egl_display_ptr dp = validate_display_connection(dpy, cnx);
 574     if (dp) {
 575         EGLSurface surface = cnx->egl.eglCreatePixmapSurface(
 576                 dp->disp.dpy, config, pixmap, attrib_list);
 577         if (surface != EGL_NO_SURFACE) {
 578             egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL,
 579                     surface, cnx);
 580             return s;
 581         }
 582     }
 583     return EGL_NO_SURFACE;
 584 }
 585
 586 EGLSurface eglCreatePbufferSurface( EGLDisplay dpy, EGLConfig config,
 587                                     const EGLint *attrib_list)
 588 {
 589     clearError();
 590
 591     egl_connection_t* cnx = NULL;
 592     egl_display_ptr dp = validate_display_connection(dpy, cnx);
 593     if (dp) {
 594         EGLSurface surface = cnx->egl.eglCreatePbufferSurface(
 595                 dp->disp.dpy, config, attrib_list);
 596         if (surface != EGL_NO_SURFACE) {
 597             egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL,
 598                     surface, cnx);
 599             return s;
 600         }
 601     }
 602     return EGL_NO_SURFACE;
 603 }
 604
 605 EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
 606 {
 607     clearError();
 608
 609     const egl_display_ptr dp = validate_display(dpy);
 610     if (!dp) return EGL_FALSE;
 611
 612     SurfaceRef _s(dp.get(), surface);
 613     if (!_s.get())
 614         return setError(EGL_BAD_SURFACE, EGL_FALSE);
 615
 616     egl_surface_t * const s = get_surface(surface);
 617     EGLBoolean result = s->cnx->egl.eglDestroySurface(dp->disp.dpy, s->surface);
 618     if (result == EGL_TRUE) {
 619         _s.terminate();
 620     }
 621     return result;
 622 }
 623
 624 EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface surface,
 625                             EGLint attribute, EGLint *value)
 626 {
 627     clearError();
 628
 629     const egl_display_ptr dp = validate_display(dpy);
 630     if (!dp) return EGL_FALSE;
 631
 632     SurfaceRef _s(dp.get(), surface);
 633     if (!_s.get())
 634         return setError(EGL_BAD_SURFACE, EGL_FALSE);
 635
 636     egl_surface_t const * const s = get_surface(surface);
 637     return s->cnx->egl.eglQuerySurface(
 638             dp->disp.dpy, s->surface, attribute, value);
 639 }
 640
 641 void EGLAPI eglBeginFrame(EGLDisplay dpy, EGLSurface surface) {
 642     ATRACE_CALL();
 643     clearError();
 644
 645     const egl_display_ptr dp = validate_display(dpy);
 646     if (!dp) {
 647         return;
 648     }
 649
 650     SurfaceRef _s(dp.get(), surface);
 651     if (!_s.get()) {
 652         setError(EGL_BAD_SURFACE, EGL_FALSE);
 653         return;
 654     }
 655 }
 656
 657 // ----------------------------------------------------------------------------
 658 // Contexts
 659 // ----------------------------------------------------------------------------
 660
 661 EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,
 662                             EGLContext share_list, const EGLint *attrib_list)
 663 {
 664     clearError();
 665
 666     egl_connection_t* cnx = NULL;
 667     const egl_display_ptr dp = validate_display_connection(dpy, cnx);
 668     if (dp) {
 669         if (share_list != EGL_NO_CONTEXT) {
 670             if (!ContextRef(dp.get(), share_list).get()) {
 671                 return setError(EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
 672             }
 673             egl_context_t* const c = get_context(share_list);
 674             share_list = c->context;
 675         }
 676         EGLContext context = cnx->egl.eglCreateContext(
 677                 dp->disp.dpy, config, share_list, attrib_list);
 678         if (context != EGL_NO_CONTEXT) {
 679             // figure out if it's a GLESv1 or GLESv2
 680             int version = 0;
 681             if (attrib_list) {
 682                 while (*attrib_list != EGL_NONE) {
 683                     GLint attr = *attrib_list++;
 684                     GLint value = *attrib_list++;
 685                     if (attr == EGL_CONTEXT_CLIENT_VERSION) {
 686                         if (value == 1) {
 687                             version = egl_connection_t::GLESv1_INDEX;
 688                         } else if (value == 2 || value == 3) {
 689                             version = egl_connection_t::GLESv2_INDEX;
 690                         }
 691                     }
 692                 };
 693             }
 694             egl_context_t* c = new egl_context_t(dpy, context, config, cnx,
 695                     version);
 696             return c;
 697         }
 698     }
 699     return EGL_NO_CONTEXT;
 700 }
 701
 702 EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 703 {
 704     clearError();
 705
 706     const egl_display_ptr dp = validate_display(dpy);
 707     if (!dp)
 708         return EGL_FALSE;
 709
 710     ContextRef _c(dp.get(), ctx);
 711     if (!_c.get())
 712         return setError(EGL_BAD_CONTEXT, EGL_FALSE);
 713
 714     egl_context_t * const c = get_context(ctx);
 715     EGLBoolean result = c->cnx->egl.eglDestroyContext(dp->disp.dpy, c->context);
 716     if (result == EGL_TRUE) {
 717         _c.terminate();
 718     }
 719     return result;
 720 }
 721
 722 EGLBoolean eglMakeCurrent(  EGLDisplay dpy, EGLSurface draw,
 723                             EGLSurface read, EGLContext ctx)
 724 {
 725     clearError();
 726
 727     egl_display_ptr dp = validate_display(dpy);
 728     if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
 729
 730     // If ctx is not EGL_NO_CONTEXT, read is not EGL_NO_SURFACE, or draw is not
 731     // EGL_NO_SURFACE, then an EGL_NOT_INITIALIZED error is generated if dpy is
 732     // a valid but uninitialized display.
 733     if ( (ctx != EGL_NO_CONTEXT) || (read != EGL_NO_SURFACE) ||
 734          (draw != EGL_NO_SURFACE) ) {
 735         if (!dp->isReady()) return setError(EGL_NOT_INITIALIZED, EGL_FALSE);
 736     }
 737
 738     // get a reference to the object passed in
 739     ContextRef _c(dp.get(), ctx);
 740     SurfaceRef _d(dp.get(), draw);
 741     SurfaceRef _r(dp.get(), read);
 742
 743     // validate the context (if not EGL_NO_CONTEXT)
 744     if ((ctx != EGL_NO_CONTEXT) && !_c.get()) {
 745         // EGL_NO_CONTEXT is valid
 746         return setError(EGL_BAD_CONTEXT, EGL_FALSE);
 747     }
 748
 749     // these are the underlying implementation's object
 750     EGLContext impl_ctx  = EGL_NO_CONTEXT;
 751     EGLSurface impl_draw = EGL_NO_SURFACE;
 752     EGLSurface impl_read = EGL_NO_SURFACE;
 753
 754     // these are our objects structs passed in
 755     egl_context_t       * c = NULL;
 756     egl_surface_t const * d = NULL;
 757     egl_surface_t const * r = NULL;
 758
 759     // these are the current objects structs
 760     egl_context_t * cur_c = get_context(getContext());
 761
 762     if (ctx != EGL_NO_CONTEXT) {
 763         c = get_context(ctx);
 764         impl_ctx = c->context;
 765     } else {
 766         // no context given, use the implementation of the current context
 767         if (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE) {
 768             // calling eglMakeCurrent( ..., !=0, !=0, EGL_NO_CONTEXT);
 769             return setError(EGL_BAD_MATCH, EGL_FALSE);
 770         }
 771         if (cur_c == NULL) {
 772             // no current context
 773             // not an error, there is just no current context.
 774             return EGL_TRUE;
 775         }
 776     }
 777
 778     // retrieve the underlying implementation's draw EGLSurface
 779     if (draw != EGL_NO_SURFACE) {
 780         if (!_d.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
 781         d = get_surface(draw);
 782         impl_draw = d->surface;
 783     }
 784
 785     // retrieve the underlying implementation's read EGLSurface
 786     if (read != EGL_NO_SURFACE) {
 787         if (!_r.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
 788         r = get_surface(read);
 789         impl_read = r->surface;
 790     }
 791
 792
 793     EGLBoolean result = dp->makeCurrent(c, cur_c,
 794             draw, read, ctx,
 795             impl_draw, impl_read, impl_ctx);
 796
 797     if (result == EGL_TRUE) {
 798         if (c) {
 799             setGLHooksThreadSpecific(c->cnx->hooks[c->version]);
 800             egl_tls_t::setContext(ctx);
 801             _c.acquire();
 802             _r.acquire();
 803             _d.acquire();
 804         } else {
 805             setGLHooksThreadSpecific(&gHooksNoContext);
 806             egl_tls_t::setContext(EGL_NO_CONTEXT);
 807         }
 808     } else {
 809         // this will ALOGE the error
 810         egl_connection_t* const cnx = &gEGLImpl;
 811         result = setError(cnx->egl.eglGetError(), EGL_FALSE);
 812     }
 813     return result;
 814 }
 815
 816
 817 EGLBoolean eglQueryContext( EGLDisplay dpy, EGLContext ctx,
 818                             EGLint attribute, EGLint *value)
 819 {
 820     clearError();
 821
 822     const egl_display_ptr dp = validate_display(dpy);
 823     if (!dp) return EGL_FALSE;
 824
 825     ContextRef _c(dp.get(), ctx);
 826     if (!_c.get()) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
 827
 828     egl_context_t * const c = get_context(ctx);
 829     return c->cnx->egl.eglQueryContext(
 830             dp->disp.dpy, c->context, attribute, value);
 831
 832 }
 833
 834 EGLContext eglGetCurrentContext(void)
 835 {
 836     // could be called before eglInitialize(), but we wouldn't have a context
 837     // then, and this function would correctly return EGL_NO_CONTEXT.
 838
 839     clearError();
 840
 841     EGLContext ctx = getContext();
 842     return ctx;
 843 }
 844
 845 EGLSurface eglGetCurrentSurface(EGLint readdraw)
 846 {
 847     // could be called before eglInitialize(), but we wouldn't have a context
 848     // then, and this function would correctly return EGL_NO_SURFACE.
 849
 850     clearError();
 851
 852     EGLContext ctx = getContext();
 853     if (ctx) {
 854         egl_context_t const * const c = get_context(ctx);
 855         if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
 856         switch (readdraw) {
 857             case EGL_READ: return c->read;
 858             case EGL_DRAW: return c->draw;
 859             default: return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
 860         }
 861     }
 862     return EGL_NO_SURFACE;
 863 }
 864
 865 EGLDisplay eglGetCurrentDisplay(void)
 866 {
 867     // could be called before eglInitialize(), but we wouldn't have a context
 868     // then, and this function would correctly return EGL_NO_DISPLAY.
 869
 870     clearError();
 871
 872     EGLContext ctx = getContext();
 873     if (ctx) {
 874         egl_context_t const * const c = get_context(ctx);
 875         if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
 876         return c->dpy;
 877     }
 878     return EGL_NO_DISPLAY;
 879 }
 880
 881 EGLBoolean eglWaitGL(void)
 882 {
 883     clearError();
 884
 885     egl_connection_t* const cnx = &gEGLImpl;
 886     if (!cnx->dso)
 887         return setError(EGL_BAD_CONTEXT, EGL_FALSE);
 888
 889     return cnx->egl.eglWaitGL();
 890 }
 891
 892 EGLBoolean eglWaitNative(EGLint engine)
 893 {
 894     clearError();
 895
 896     egl_connection_t* const cnx = &gEGLImpl;
 897     if (!cnx->dso)
 898         return setError(EGL_BAD_CONTEXT, EGL_FALSE);
 899
 900     return cnx->egl.eglWaitNative(engine);
 901 }
 902
 903 EGLint eglGetError(void)
 904 {
 905     EGLint err = EGL_SUCCESS;
 906     egl_connection_t* const cnx = &gEGLImpl;
 907     if (cnx->dso) {
 908         err = cnx->egl.eglGetError();
 909     }
 910     if (err == EGL_SUCCESS) {
 911         err = egl_tls_t::getError();
 912     }
 913     return err;
 914 }
 915
 916 static __eglMustCastToProperFunctionPointerType findBuiltinWrapper(
 917         const char* procname) {
 918     const egl_connection_t* cnx = &gEGLImpl;
 919     void* proc = NULL;
 920
 921     proc = dlsym(cnx->libEgl, procname);
 922     if (proc) return (__eglMustCastToProperFunctionPointerType)proc;
 923
 924     proc = dlsym(cnx->libGles2, procname);
 925     if (proc) return (__eglMustCastToProperFunctionPointerType)proc;
 926
 927     proc = dlsym(cnx->libGles1, procname);
 928     if (proc) return (__eglMustCastToProperFunctionPointerType)proc;
 929
 930     return NULL;
 931 }
 932
 933 __eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname)
 934 {
 935     // eglGetProcAddress() could be the very first function called
 936     // in which case we must make sure we've initialized ourselves, this
 937     // happens the first time egl_get_display() is called.
 938
 939     clearError();
 940
 941     if (egl_init_drivers() == EGL_FALSE) {
 942         setError(EGL_BAD_PARAMETER, NULL);
 943         return  NULL;
 944     }
 945
 946     if (FILTER_EXTENSIONS(procname)) {
 947         return NULL;
 948     }
 949
 950     __eglMustCastToProperFunctionPointerType addr;
 951     addr = findProcAddress(procname, sExtensionMap, NELEM(sExtensionMap));
 952     if (addr) return addr;
 953
 954     addr = findBuiltinWrapper(procname);
 955     if (addr) return addr;
 956
 957     // this protects accesses to sGLExtentionMap and sGLExtentionSlot
 958     pthread_mutex_lock(&sExtensionMapMutex);
 959
 960         /*
 961          * Since eglGetProcAddress() is not associated to anything, it needs
 962          * to return a function pointer that "works" regardless of what
 963          * the current context is.
 964          *
 965          * For this reason, we return a "forwarder", a small stub that takes
 966          * care of calling the function associated with the context
 967          * currently bound.
 968          *
 969          * We first look for extensions we've already resolved, if we're seeing
 970          * this extension for the first time, we go through all our
 971          * implementations and call eglGetProcAddress() and record the
 972          * result in the appropriate implementation hooks and return the
 973          * address of the forwarder corresponding to that hook set.
 974          *
 975          */
 976
 977         const String8 name(procname);
 978         addr = sGLExtentionMap.valueFor(name);
 979         const int slot = sGLExtentionSlot;
 980
 981         ALOGE_IF(slot >= MAX_NUMBER_OF_GL_EXTENSIONS,
 982                 "no more slots for eglGetProcAddress(\"%s\")",
 983                 procname);
 984
 985         if (!addr && (slot < MAX_NUMBER_OF_GL_EXTENSIONS)) {
 986             bool found = false;
 987
 988             egl_connection_t* const cnx = &gEGLImpl;
 989             if (cnx->dso && cnx->egl.eglGetProcAddress) {
 990                 // Extensions are independent of the bound context
 991                 addr =
 992                 cnx->hooks[egl_connection_t::GLESv1_INDEX]->ext.extensions[slot] =
 993                 cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[slot] =
 994                         cnx->egl.eglGetProcAddress(procname);
 995                 if (addr) found = true;
 996             }
 997
 998             if (found) {
 999                 addr = gExtensionForwarders[slot];
1000                 sGLExtentionMap.add(name, addr);
1001                 sGLExtentionSlot++;
1002             }
1003         }
1004
1005     pthread_mutex_unlock(&sExtensionMapMutex);
1006     return addr;
1007 }
1008
1009 class FrameCompletionThread : public Thread {
1010 public:
1011
1012     static void queueSync(EGLSyncKHR sync) {
1013         static sp<FrameCompletionThread> thread(new FrameCompletionThread);
1014         static bool running = false;
1015         if (!running) {
1016             thread->run("GPUFrameCompletion");
1017             running = true;
1018         }
1019         {
1020             Mutex::Autolock lock(thread->mMutex);
1021             ScopedTrace st(ATRACE_TAG, String8::format("kicked off frame %d",
1022                     thread->mFramesQueued).string());
1023             thread->mQueue.push_back(sync);
1024             thread->mCondition.signal();
1025             thread->mFramesQueued++;
1026             ATRACE_INT("GPU Frames Outstanding", thread->mQueue.size());
1027         }
1028     }
1029
1030 private:
1031     FrameCompletionThread() : mFramesQueued(0), mFramesCompleted(0) {}
1032
1033     virtual bool threadLoop() {
1034         EGLSyncKHR sync;
1035         uint32_t frameNum;
1036         {
1037             Mutex::Autolock lock(mMutex);
1038             while (mQueue.isEmpty()) {
1039                 mCondition.wait(mMutex);
1040             }
1041             sync = mQueue[0];
1042             frameNum = mFramesCompleted;
1043         }
1044         EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1045         {
1046             ScopedTrace st(ATRACE_TAG, String8::format("waiting for frame %d",
1047                     frameNum).string());
1048             EGLint result = eglClientWaitSyncKHR(dpy, sync, 0, EGL_FOREVER_KHR);
1049             if (result == EGL_FALSE) {
1050                 ALOGE("FrameCompletion: error waiting for fence: %#x", eglGetError());
1051             } else if (result == EGL_TIMEOUT_EXPIRED_KHR) {
1052                 ALOGE("FrameCompletion: timeout waiting for fence");
1053             }
1054             eglDestroySyncKHR(dpy, sync);
1055         }
1056         {
1057             Mutex::Autolock lock(mMutex);
1058             mQueue.removeAt(0);
1059             mFramesCompleted++;
1060             ATRACE_INT("GPU Frames Outstanding", mQueue.size());
1061         }
1062         return true;
1063     }
1064
1065     uint32_t mFramesQueued;
1066     uint32_t mFramesCompleted;
1067     Vector<EGLSyncKHR> mQueue;
1068     Condition mCondition;
1069     Mutex mMutex;
1070 };
1071
1072 EGLBoolean eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface draw,
1073         EGLint *rects, EGLint n_rects)
1074 {
1075     ATRACE_CALL();
1076     clearError();
1077
1078     const egl_display_ptr dp = validate_display(dpy);
1079     if (!dp) return EGL_FALSE;
1080
1081     SurfaceRef _s(dp.get(), draw);
1082     if (!_s.get())
1083         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1084
1085     egl_surface_t const * const s = get_surface(draw);
1086
1087     if (CC_UNLIKELY(dp->traceGpuCompletion)) {
1088         EGLSyncKHR sync = eglCreateSyncKHR(dpy, EGL_SYNC_FENCE_KHR, NULL);
1089         if (sync != EGL_NO_SYNC_KHR) {
1090             FrameCompletionThread::queueSync(sync);
1091         }
1092     }
1093
1094     if (CC_UNLIKELY(dp->finishOnSwap)) {
1095         uint32_t pixel;
1096         egl_context_t * const c = get_context( egl_tls_t::getContext() );
1097         if (c) {
1098             // glReadPixels() ensures that the frame is complete
1099             s->cnx->hooks[c->version]->gl.glReadPixels(0,0,1,1,
1100                     GL_RGBA,GL_UNSIGNED_BYTE,&pixel);
1101         }
1102     }
1103
1104     if (n_rects == 0) {
1105         return s->cnx->egl.eglSwapBuffers(dp->disp.dpy, s->surface);
1106     }
1107
1108     Vector<android_native_rect_t> androidRects;
1109     for (int r = 0; r < n_rects; ++r) {
1110         int offset = r * 4;
1111         int x = rects[offset];
1112         int y = rects[offset + 1];
1113         int width = rects[offset + 2];
1114         int height = rects[offset + 3];
1115         android_native_rect_t androidRect;
1116         androidRect.left = x;
1117         androidRect.top = y + height;
1118         androidRect.right = x + width;
1119         androidRect.bottom = y;
1120         androidRects.push_back(androidRect);
1121     }
1122     native_window_set_surface_damage(s->win.get(), androidRects.array(),
1123             androidRects.size());
1124
1125     if (s->cnx->egl.eglSwapBuffersWithDamageKHR) {
1126         return s->cnx->egl.eglSwapBuffersWithDamageKHR(dp->disp.dpy, s->surface,
1127                 rects, n_rects);
1128     } else {
1129         return s->cnx->egl.eglSwapBuffers(dp->disp.dpy, s->surface);
1130     }
1131 }
1132
1133 EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
1134 {
1135     return eglSwapBuffersWithDamageKHR(dpy, surface, NULL, 0);
1136 }
1137
1138 EGLBoolean eglCopyBuffers(  EGLDisplay dpy, EGLSurface surface,
1139                             NativePixmapType target)
1140 {
1141     clearError();
1142
1143     const egl_display_ptr dp = validate_display(dpy);
1144     if (!dp) return EGL_FALSE;
1145
1146     SurfaceRef _s(dp.get(), surface);
1147     if (!_s.get())
1148         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1149
1150     egl_surface_t const * const s = get_surface(surface);
1151     return s->cnx->egl.eglCopyBuffers(dp->disp.dpy, s->surface, target);
1152 }
1153
1154 const char* eglQueryString(EGLDisplay dpy, EGLint name)
1155 {
1156     clearError();
1157
1158     const egl_display_ptr dp = validate_display(dpy);
1159     if (!dp) return (const char *) NULL;
1160
1161     switch (name) {
1162         case EGL_VENDOR:
1163             return dp->getVendorString();
1164         case EGL_VERSION:
1165             return dp->getVersionString();
1166         case EGL_EXTENSIONS:
1167             return dp->getExtensionString();
1168         case EGL_CLIENT_APIS:
1169             return dp->getClientApiString();
1170     }
1171     return setError(EGL_BAD_PARAMETER, (const char *)0);
1172 }
1173
1174 EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name)
1175 {
1176     clearError();
1177
1178     const egl_display_ptr dp = validate_display(dpy);
1179     if (!dp) return (const char *) NULL;
1180
1181     switch (name) {
1182         case EGL_VENDOR:
1183             return dp->disp.queryString.vendor;
1184         case EGL_VERSION:
1185             return dp->disp.queryString.version;
1186         case EGL_EXTENSIONS:
1187             return dp->disp.queryString.extensions;
1188         case EGL_CLIENT_APIS:
1189             return dp->disp.queryString.clientApi;
1190     }
1191     return setError(EGL_BAD_PARAMETER, (const char *)0);
1192 }
1193
1194 // ----------------------------------------------------------------------------
1195 // EGL 1.1
1196 // ----------------------------------------------------------------------------
1197
1198 EGLBoolean eglSurfaceAttrib(
1199         EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
1200 {
1201     clearError();
1202
1203     const egl_display_ptr dp = validate_display(dpy);
1204     if (!dp) return EGL_FALSE;
1205
1206     SurfaceRef _s(dp.get(), surface);
1207     if (!_s.get())
1208         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1209
1210     egl_surface_t * const s = get_surface(surface);
1211
1212     if (attribute == EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID) {
1213         int err = native_window_set_auto_refresh(s->win.get(),
1214             value ? true : false);
1215         return (err == NO_ERROR) ? EGL_TRUE :
1216             setError(EGL_BAD_SURFACE, EGL_FALSE);
1217     }
1218
1219 #if ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS
1220     if (attribute == EGL_TIMESTAMPS_ANDROID) {
1221         s->enableTimestamps = value;
1222         return EGL_TRUE;
1223     }
1224 #endif
1225
1226     if (s->cnx->egl.eglSurfaceAttrib) {
1227         return s->cnx->egl.eglSurfaceAttrib(
1228                 dp->disp.dpy, s->surface, attribute, value);
1229     }
1230     return setError(EGL_BAD_SURFACE, EGL_FALSE);
1231 }
1232
1233 EGLBoolean eglBindTexImage(
1234         EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1235 {
1236     clearError();
1237
1238     const egl_display_ptr dp = validate_display(dpy);
1239     if (!dp) return EGL_FALSE;
1240
1241     SurfaceRef _s(dp.get(), surface);
1242     if (!_s.get())
1243         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1244
1245     egl_surface_t const * const s = get_surface(surface);
1246     if (s->cnx->egl.eglBindTexImage) {
1247         return s->cnx->egl.eglBindTexImage(
1248                 dp->disp.dpy, s->surface, buffer);
1249     }
1250     return setError(EGL_BAD_SURFACE, EGL_FALSE);
1251 }
1252
1253 EGLBoolean eglReleaseTexImage(
1254         EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1255 {
1256     clearError();
1257
1258     const egl_display_ptr dp = validate_display(dpy);
1259     if (!dp) return EGL_FALSE;
1260
1261     SurfaceRef _s(dp.get(), surface);
1262     if (!_s.get())
1263         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1264
1265     egl_surface_t const * const s = get_surface(surface);
1266     if (s->cnx->egl.eglReleaseTexImage) {
1267         return s->cnx->egl.eglReleaseTexImage(
1268                 dp->disp.dpy, s->surface, buffer);
1269     }
1270     return setError(EGL_BAD_SURFACE, EGL_FALSE);
1271 }
1272
1273 EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)
1274 {
1275     clearError();
1276
1277     const egl_display_ptr dp = validate_display(dpy);
1278     if (!dp) return EGL_FALSE;
1279
1280     EGLBoolean res = EGL_TRUE;
1281     egl_connection_t* const cnx = &gEGLImpl;
1282     if (cnx->dso && cnx->egl.eglSwapInterval) {
1283         res = cnx->egl.eglSwapInterval(dp->disp.dpy, interval);
1284     }
1285
1286     return res;
1287 }
1288
1289
1290 // ----------------------------------------------------------------------------
1291 // EGL 1.2
1292 // ----------------------------------------------------------------------------
1293
1294 EGLBoolean eglWaitClient(void)
1295 {
1296     clearError();
1297
1298     egl_connection_t* const cnx = &gEGLImpl;
1299     if (!cnx->dso)
1300         return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1301
1302     EGLBoolean res;
1303     if (cnx->egl.eglWaitClient) {
1304         res = cnx->egl.eglWaitClient();
1305     } else {
1306         res = cnx->egl.eglWaitGL();
1307     }
1308     return res;
1309 }
1310
1311 EGLBoolean eglBindAPI(EGLenum api)
1312 {
1313     clearError();
1314
1315     if (egl_init_drivers() == EGL_FALSE) {
1316         return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1317     }
1318
1319     // bind this API on all EGLs
1320     EGLBoolean res = EGL_TRUE;
1321     egl_connection_t* const cnx = &gEGLImpl;
1322     if (cnx->dso && cnx->egl.eglBindAPI) {
1323         res = cnx->egl.eglBindAPI(api);
1324     }
1325     return res;
1326 }
1327
1328 EGLenum eglQueryAPI(void)
1329 {
1330     clearError();
1331
1332     if (egl_init_drivers() == EGL_FALSE) {
1333         return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1334     }
1335
1336     egl_connection_t* const cnx = &gEGLImpl;
1337     if (cnx->dso && cnx->egl.eglQueryAPI) {
1338         return cnx->egl.eglQueryAPI();
1339     }
1340
1341     // or, it can only be OpenGL ES
1342     return EGL_OPENGL_ES_API;
1343 }
1344
1345 EGLBoolean eglReleaseThread(void)
1346 {
1347     clearError();
1348
1349     // If there is context bound to the thread, release it
1350     egl_display_t::loseCurrent(get_context(getContext()));
1351
1352     egl_connection_t* const cnx = &gEGLImpl;
1353     if (cnx->dso && cnx->egl.eglReleaseThread) {
1354         cnx->egl.eglReleaseThread();
1355     }
1356     egl_tls_t::clearTLS();
1357     return EGL_TRUE;
1358 }
1359
1360 EGLSurface eglCreatePbufferFromClientBuffer(
1361           EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
1362           EGLConfig config, const EGLint *attrib_list)
1363 {
1364     clearError();
1365
1366     egl_connection_t* cnx = NULL;
1367     const egl_display_ptr dp = validate_display_connection(dpy, cnx);
1368     if (!dp) return EGL_FALSE;
1369     if (cnx->egl.eglCreatePbufferFromClientBuffer) {
1370         return cnx->egl.eglCreatePbufferFromClientBuffer(
1371                 dp->disp.dpy, buftype, buffer, config, attrib_list);
1372     }
1373     return setError(EGL_BAD_CONFIG, EGL_NO_SURFACE);
1374 }
1375
1376 // ----------------------------------------------------------------------------
1377 // EGL_EGLEXT_VERSION 3
1378 // ----------------------------------------------------------------------------
1379
1380 EGLBoolean eglLockSurfaceKHR(EGLDisplay dpy, EGLSurface surface,
1381         const EGLint *attrib_list)
1382 {
1383     clearError();
1384
1385     const egl_display_ptr dp = validate_display(dpy);
1386     if (!dp) return EGL_FALSE;
1387
1388     SurfaceRef _s(dp.get(), surface);
1389     if (!_s.get())
1390         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1391
1392     egl_surface_t const * const s = get_surface(surface);
1393     if (s->cnx->egl.eglLockSurfaceKHR) {
1394         return s->cnx->egl.eglLockSurfaceKHR(
1395                 dp->disp.dpy, s->surface, attrib_list);
1396     }
1397     return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1398 }
1399
1400 EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface)
1401 {
1402     clearError();
1403
1404     const egl_display_ptr dp = validate_display(dpy);
1405     if (!dp) return EGL_FALSE;
1406
1407     SurfaceRef _s(dp.get(), surface);
1408     if (!_s.get())
1409         return setError(EGL_BAD_SURFACE, EGL_FALSE);
1410
1411     egl_surface_t const * const s = get_surface(surface);
1412     if (s->cnx->egl.eglUnlockSurfaceKHR) {
1413         return s->cnx->egl.eglUnlockSurfaceKHR(dp->disp.dpy, s->surface);
1414     }
1415     return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1416 }
1417
1418 EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
1419         EGLClientBuffer buffer, const EGLint *attrib_list)
1420 {
1421     clearError();
1422
1423     const egl_display_ptr dp = validate_display(dpy);
1424     if (!dp) return EGL_NO_IMAGE_KHR;
1425
1426     ContextRef _c(dp.get(), ctx);
1427     egl_context_t * const c = _c.get();
1428
1429     EGLImageKHR result = EGL_NO_IMAGE_KHR;
1430     egl_connection_t* const cnx = &gEGLImpl;
1431     if (cnx->dso && cnx->egl.eglCreateImageKHR) {
1432         result = cnx->egl.eglCreateImageKHR(
1433                 dp->disp.dpy,
1434                 c ? c->context : EGL_NO_CONTEXT,
1435                 target, buffer, attrib_list);
1436     }
1437     return result;
1438 }
1439
1440 EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img)
1441 {
1442     clearError();
1443
1444     const egl_display_ptr dp = validate_display(dpy);
1445     if (!dp) return EGL_FALSE;
1446
1447     EGLBoolean result = EGL_FALSE;
1448     egl_connection_t* const cnx = &gEGLImpl;
1449     if (cnx->dso && cnx->egl.eglDestroyImageKHR) {
1450         result = cnx->egl.eglDestroyImageKHR(dp->disp.dpy, img);
1451     }
1452     return result;
1453 }
1454
1455 // ----------------------------------------------------------------------------
1456 // EGL_EGLEXT_VERSION 5
1457 // ----------------------------------------------------------------------------
1458
1459
1460 EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
1461 {
1462     clearError();
1463
1464     const egl_display_ptr dp = validate_display(dpy);
1465     if (!dp) return EGL_NO_SYNC_KHR;
1466
1467     EGLSyncKHR result = EGL_NO_SYNC_KHR;
1468     egl_connection_t* const cnx = &gEGLImpl;
1469     if (cnx->dso && cnx->egl.eglCreateSyncKHR) {
1470         result = cnx->egl.eglCreateSyncKHR(dp->disp.dpy, type, attrib_list);
1471     }
1472     return result;
1473 }
1474
1475 EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
1476 {
1477     clearError();
1478
1479     const egl_display_ptr dp = validate_display(dpy);
1480     if (!dp) return EGL_FALSE;
1481
1482     EGLBoolean result = EGL_FALSE;
1483     egl_connection_t* const cnx = &gEGLImpl;
1484     if (cnx->dso && cnx->egl.eglDestroySyncKHR) {
1485         result = cnx->egl.eglDestroySyncKHR(dp->disp.dpy, sync);
1486     }
1487     return result;
1488 }
1489
1490 EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) {
1491     clearError();
1492
1493     const egl_display_ptr dp = validate_display(dpy);
1494     if (!dp) return EGL_FALSE;
1495
1496     EGLBoolean result = EGL_FALSE;
1497     egl_connection_t* const cnx = &gEGLImpl;
1498     if (cnx->dso && cnx->egl.eglSignalSyncKHR) {
1499         result = cnx->egl.eglSignalSyncKHR(
1500                 dp->disp.dpy, sync, mode);
1501     }
1502     return result;
1503 }
1504
1505 EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync,
1506         EGLint flags, EGLTimeKHR timeout)
1507 {
1508     clearError();
1509
1510     const egl_display_ptr dp = validate_display(dpy);
1511     if (!dp) return EGL_FALSE;
1512
1513     EGLBoolean result = EGL_FALSE;
1514     egl_connection_t* const cnx = &gEGLImpl;
1515     if (cnx->dso && cnx->egl.eglClientWaitSyncKHR) {
1516         result = cnx->egl.eglClientWaitSyncKHR(
1517                 dp->disp.dpy, sync, flags, timeout);
1518     }
1519     return result;
1520 }
1521
1522 EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync,
1523         EGLint attribute, EGLint *value)
1524 {
1525     clearError();
1526
1527     const egl_display_ptr dp = validate_display(dpy);
1528     if (!dp) return EGL_FALSE;
1529
1530     EGLBoolean result = EGL_FALSE;
1531     egl_connection_t* const cnx = &gEGLImpl;
1532     if (cnx->dso && cnx->egl.eglGetSyncAttribKHR) {
1533         result = cnx->egl.eglGetSyncAttribKHR(
1534                 dp->disp.dpy, sync, attribute, value);
1535     }
1536     return result;
1537 }
1538
1539 EGLStreamKHR eglCreateStreamKHR(EGLDisplay dpy, const EGLint *attrib_list)
1540 {
1541     clearError();
1542
1543     const egl_display_ptr dp = validate_display(dpy);
1544     if (!dp) return EGL_NO_STREAM_KHR;
1545
1546     EGLStreamKHR result = EGL_NO_STREAM_KHR;
1547     egl_connection_t* const cnx = &gEGLImpl;
1548     if (cnx->dso && cnx->egl.eglCreateStreamKHR) {
1549         result = cnx->egl.eglCreateStreamKHR(
1550                 dp->disp.dpy, attrib_list);
1551     }
1552     return result;
1553 }
1554
1555 EGLBoolean eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream)
1556 {
1557     clearError();
1558
1559     const egl_display_ptr dp = validate_display(dpy);
1560     if (!dp) return EGL_FALSE;
1561
1562     EGLBoolean result = EGL_FALSE;
1563     egl_connection_t* const cnx = &gEGLImpl;
1564     if (cnx->dso && cnx->egl.eglDestroyStreamKHR) {
1565         result = cnx->egl.eglDestroyStreamKHR(
1566                 dp->disp.dpy, stream);
1567     }
1568     return result;
1569 }
1570
1571 EGLBoolean eglStreamAttribKHR(EGLDisplay dpy, EGLStreamKHR stream,
1572         EGLenum attribute, EGLint value)
1573 {
1574     clearError();
1575
1576     const egl_display_ptr dp = validate_display(dpy);
1577     if (!dp) return EGL_FALSE;
1578
1579     EGLBoolean result = EGL_FALSE;
1580     egl_connection_t* const cnx = &gEGLImpl;
1581     if (cnx->dso && cnx->egl.eglStreamAttribKHR) {
1582         result = cnx->egl.eglStreamAttribKHR(
1583                 dp->disp.dpy, stream, attribute, value);
1584     }
1585     return result;
1586 }
1587
1588 EGLBoolean eglQueryStreamKHR(EGLDisplay dpy, EGLStreamKHR stream,
1589         EGLenum attribute, EGLint *value)
1590 {
1591     clearError();
1592
1593     const egl_display_ptr dp = validate_display(dpy);
1594     if (!dp) return EGL_FALSE;
1595
1596     EGLBoolean result = EGL_FALSE;
1597     egl_connection_t* const cnx = &gEGLImpl;
1598     if (cnx->dso && cnx->egl.eglQueryStreamKHR) {
1599         result = cnx->egl.eglQueryStreamKHR(
1600                 dp->disp.dpy, stream, attribute, value);
1601     }
1602     return result;
1603 }
1604
1605 EGLBoolean eglQueryStreamu64KHR(EGLDisplay dpy, EGLStreamKHR stream,
1606         EGLenum attribute, EGLuint64KHR *value)
1607 {
1608     clearError();
1609
1610     const egl_display_ptr dp = validate_display(dpy);
1611     if (!dp) return EGL_FALSE;
1612
1613     EGLBoolean result = EGL_FALSE;
1614     egl_connection_t* const cnx = &gEGLImpl;
1615     if (cnx->dso && cnx->egl.eglQueryStreamu64KHR) {
1616         result = cnx->egl.eglQueryStreamu64KHR(
1617                 dp->disp.dpy, stream, attribute, value);
1618     }
1619     return result;
1620 }
1621
1622 EGLBoolean eglQueryStreamTimeKHR(EGLDisplay dpy, EGLStreamKHR stream,
1623         EGLenum attribute, EGLTimeKHR *value)
1624 {
1625     clearError();
1626
1627     const egl_display_ptr dp = validate_display(dpy);
1628     if (!dp) return EGL_FALSE;
1629
1630     EGLBoolean result = EGL_FALSE;
1631     egl_connection_t* const cnx = &gEGLImpl;
1632     if (cnx->dso && cnx->egl.eglQueryStreamTimeKHR) {
1633         result = cnx->egl.eglQueryStreamTimeKHR(
1634                 dp->disp.dpy, stream, attribute, value);
1635     }
1636     return result;
1637 }
1638
1639 EGLSurface eglCreateStreamProducerSurfaceKHR(EGLDisplay dpy, EGLConfig config,
1640         EGLStreamKHR stream, const EGLint *attrib_list)
1641 {
1642     clearError();
1643
1644     egl_display_ptr dp = validate_display(dpy);
1645     if (!dp) return EGL_NO_SURFACE;
1646
1647     egl_connection_t* const cnx = &gEGLImpl;
1648     if (cnx->dso && cnx->egl.eglCreateStreamProducerSurfaceKHR) {
1649         EGLSurface surface = cnx->egl.eglCreateStreamProducerSurfaceKHR(
1650                 dp->disp.dpy, config, stream, attrib_list);
1651         if (surface != EGL_NO_SURFACE) {
1652             egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL,
1653                     surface, cnx);
1654             return s;
1655         }
1656     }
1657     return EGL_NO_SURFACE;
1658 }
1659
1660 EGLBoolean eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy,
1661         EGLStreamKHR stream)
1662 {
1663     clearError();
1664
1665     const egl_display_ptr dp = validate_display(dpy);
1666     if (!dp) return EGL_FALSE;
1667
1668     EGLBoolean result = EGL_FALSE;
1669     egl_connection_t* const cnx = &gEGLImpl;
1670     if (cnx->dso && cnx->egl.eglStreamConsumerGLTextureExternalKHR) {
1671         result = cnx->egl.eglStreamConsumerGLTextureExternalKHR(
1672                 dp->disp.dpy, stream);
1673     }
1674     return result;
1675 }
1676
1677 EGLBoolean eglStreamConsumerAcquireKHR(EGLDisplay dpy,
1678         EGLStreamKHR stream)
1679 {
1680     clearError();
1681
1682     const egl_display_ptr dp = validate_display(dpy);
1683     if (!dp) return EGL_FALSE;
1684
1685     EGLBoolean result = EGL_FALSE;
1686     egl_connection_t* const cnx = &gEGLImpl;
1687     if (cnx->dso && cnx->egl.eglStreamConsumerAcquireKHR) {
1688         result = cnx->egl.eglStreamConsumerAcquireKHR(
1689                 dp->disp.dpy, stream);
1690     }
1691     return result;
1692 }
1693
1694 EGLBoolean eglStreamConsumerReleaseKHR(EGLDisplay dpy,
1695         EGLStreamKHR stream)
1696 {
1697     clearError();
1698
1699     const egl_display_ptr dp = validate_display(dpy);
1700     if (!dp) return EGL_FALSE;
1701
1702     EGLBoolean result = EGL_FALSE;
1703     egl_connection_t* const cnx = &gEGLImpl;
1704     if (cnx->dso && cnx->egl.eglStreamConsumerReleaseKHR) {
1705         result = cnx->egl.eglStreamConsumerReleaseKHR(
1706                 dp->disp.dpy, stream);
1707     }
1708     return result;
1709 }
1710
1711 EGLNativeFileDescriptorKHR eglGetStreamFileDescriptorKHR(
1712         EGLDisplay dpy, EGLStreamKHR stream)
1713 {
1714     clearError();
1715
1716     const egl_display_ptr dp = validate_display(dpy);
1717     if (!dp) return EGL_NO_FILE_DESCRIPTOR_KHR;
1718
1719     EGLNativeFileDescriptorKHR result = EGL_NO_FILE_DESCRIPTOR_KHR;
1720     egl_connection_t* const cnx = &gEGLImpl;
1721     if (cnx->dso && cnx->egl.eglGetStreamFileDescriptorKHR) {
1722         result = cnx->egl.eglGetStreamFileDescriptorKHR(
1723                 dp->disp.dpy, stream);
1724     }
1725     return result;
1726 }
1727
1728 EGLStreamKHR eglCreateStreamFromFileDescriptorKHR(
1729         EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor)
1730 {
1731     clearError();
1732
1733     const egl_display_ptr dp = validate_display(dpy);
1734     if (!dp) return EGL_NO_STREAM_KHR;
1735
1736     EGLStreamKHR result = EGL_NO_STREAM_KHR;
1737     egl_connection_t* const cnx = &gEGLImpl;
1738     if (cnx->dso && cnx->egl.eglCreateStreamFromFileDescriptorKHR) {
1739         result = cnx->egl.eglCreateStreamFromFileDescriptorKHR(
1740                 dp->disp.dpy, file_descriptor);
1741     }
1742     return result;
1743 }
1744
1745 // ----------------------------------------------------------------------------
1746 // EGL_EGLEXT_VERSION 15
1747 // ----------------------------------------------------------------------------
1748
1749 EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) {
1750     clearError();
1751     const egl_display_ptr dp = validate_display(dpy);
1752     if (!dp) return EGL_FALSE;
1753     EGLint result = EGL_FALSE;
1754     egl_connection_t* const cnx = &gEGLImpl;
1755     if (cnx->dso && cnx->egl.eglWaitSyncKHR) {
1756         result = cnx->egl.eglWaitSyncKHR(dp->disp.dpy, sync, flags);
1757     }
1758     return result;
1759 }
1760
1761 // ----------------------------------------------------------------------------
1762 // ANDROID extensions
1763 // ----------------------------------------------------------------------------
1764
1765 EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync)
1766 {
1767     clearError();
1768
1769     const egl_display_ptr dp = validate_display(dpy);
1770     if (!dp) return EGL_NO_NATIVE_FENCE_FD_ANDROID;
1771
1772     EGLint result = EGL_NO_NATIVE_FENCE_FD_ANDROID;
1773     egl_connection_t* const cnx = &gEGLImpl;
1774     if (cnx->dso && cnx->egl.eglDupNativeFenceFDANDROID) {
1775         result = cnx->egl.eglDupNativeFenceFDANDROID(dp->disp.dpy, sync);
1776     }
1777     return result;
1778 }
1779
1780 EGLBoolean eglPresentationTimeANDROID(EGLDisplay dpy, EGLSurface surface,
1781         EGLnsecsANDROID time)
1782 {
1783     clearError();
1784
1785     const egl_display_ptr dp = validate_display(dpy);
1786     if (!dp) {
1787         return EGL_FALSE;
1788     }
1789
1790     SurfaceRef _s(dp.get(), surface);
1791     if (!_s.get()) {
1792         setError(EGL_BAD_SURFACE, EGL_FALSE);
1793         return EGL_FALSE;
1794     }
1795
1796     egl_surface_t const * const s = get_surface(surface);
1797     native_window_set_buffers_timestamp(s->win.get(), time);
1798
1799     return EGL_TRUE;
1800 }
1801
1802 EGLClientBuffer eglCreateNativeClientBufferANDROID(const EGLint *attrib_list)
1803 {
1804     clearError();
1805
1806     int usage = 0;
1807     uint32_t width = 0;
1808     uint32_t height = 0;
1809     uint32_t format = 0;
1810     uint32_t red_size = 0;
1811     uint32_t green_size = 0;
1812     uint32_t blue_size = 0;
1813     uint32_t alpha_size = 0;
1814
1815 #define GET_NONNEGATIVE_VALUE(case_name, target) \
1816     case case_name: \
1817         if (value >= 0) { \
1818             target = value; \
1819         } else { \
1820             return setError(EGL_BAD_PARAMETER, (EGLClientBuffer)0); \
1821         } \
1822         break
1823
1824     if (attrib_list) {
1825         while (*attrib_list != EGL_NONE) {
1826             GLint attr = *attrib_list++;
1827             GLint value = *attrib_list++;
1828             switch (attr) {
1829                 GET_NONNEGATIVE_VALUE(EGL_WIDTH, width);
1830                 GET_NONNEGATIVE_VALUE(EGL_HEIGHT, height);
1831                 GET_NONNEGATIVE_VALUE(EGL_RED_SIZE, red_size);
1832                 GET_NONNEGATIVE_VALUE(EGL_GREEN_SIZE, green_size);
1833                 GET_NONNEGATIVE_VALUE(EGL_BLUE_SIZE, blue_size);
1834                 GET_NONNEGATIVE_VALUE(EGL_ALPHA_SIZE, alpha_size);
1835                 case EGL_NATIVE_BUFFER_USAGE_ANDROID:
1836                     if (value & EGL_NATIVE_BUFFER_USAGE_PROTECTED_BIT_ANDROID) {
1837                         usage |= GRALLOC_USAGE_PROTECTED;
1838                     }
1839                     if (value & EGL_NATIVE_BUFFER_USAGE_RENDERBUFFER_BIT_ANDROID) {
1840                         usage |= GRALLOC_USAGE_HW_RENDER;
1841                     }
1842                     if (value & EGL_NATIVE_BUFFER_USAGE_TEXTURE_BIT_ANDROID) {
1843                         usage |= GRALLOC_USAGE_HW_TEXTURE;
1844                     }
1845                     // The buffer must be used for either a texture or a
1846                     // renderbuffer.
1847                     if ((value & EGL_NATIVE_BUFFER_USAGE_RENDERBUFFER_BIT_ANDROID) &&
1848                         (value & EGL_NATIVE_BUFFER_USAGE_TEXTURE_BIT_ANDROID)) {
1849                         return setError(EGL_BAD_PARAMETER, (EGLClientBuffer)0);
1850                     }
1851                     break;
1852                 default:
1853                     return setError(EGL_BAD_PARAMETER, (EGLClientBuffer)0);
1854             }
1855         }
1856     }
1857 #undef GET_NONNEGATIVE_VALUE
1858
1859     // Validate format.
1860     if (red_size == 8 && green_size == 8 && blue_size == 8) {
1861         if (alpha_size == 8) {
1862             format = HAL_PIXEL_FORMAT_RGBA_8888;
1863         } else {
1864             format = HAL_PIXEL_FORMAT_RGB_888;
1865         }
1866     } else if (red_size == 5 && green_size == 6 && blue_size == 5 &&
1867                alpha_size == 0) {
1868         format = HAL_PIXEL_FORMAT_RGB_565;
1869     } else {
1870         ALOGE("Invalid native pixel format { r=%d, g=%d, b=%d, a=%d }",
1871                 red_size, green_size, blue_size, alpha_size);
1872         return setError(EGL_BAD_PARAMETER, (EGLClientBuffer)0);
1873     }
1874
1875     GraphicBuffer* gBuffer = new GraphicBuffer(width, height, format, usage,
1876             std::string("[eglCreateNativeClientBufferANDROID pid ") +
1877             std::to_string(getpid()) + ']');
1878     const status_t err = gBuffer->initCheck();
1879     if (err != NO_ERROR) {
1880         ALOGE("Unable to create native buffer { w=%d, h=%d, f=%d, u=%#x }: %#x",
1881                 width, height, format, usage, err);
1882         // Destroy the buffer.
1883         sp<GraphicBuffer> holder(gBuffer);
1884         return setError(EGL_BAD_ALLOC, (EGLClientBuffer)0);
1885     }
1886     ALOGD("Created new native buffer %p { w=%d, h=%d, f=%d, u=%#x }",
1887             gBuffer, width, height, format, usage);
1888     return static_cast<EGLClientBuffer>(gBuffer->getNativeBuffer());
1889 }
1890
1891 // ----------------------------------------------------------------------------
1892 // NVIDIA extensions
1893 // ----------------------------------------------------------------------------
1894 EGLuint64NV eglGetSystemTimeFrequencyNV()
1895 {
1896     clearError();
1897
1898     if (egl_init_drivers() == EGL_FALSE) {
1899         return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1900     }
1901
1902     EGLuint64NV ret = 0;
1903     egl_connection_t* const cnx = &gEGLImpl;
1904
1905     if (cnx->dso && cnx->egl.eglGetSystemTimeFrequencyNV) {
1906         return cnx->egl.eglGetSystemTimeFrequencyNV();
1907     }
1908
1909     return setErrorQuiet(EGL_BAD_DISPLAY, 0);
1910 }
1911
1912 EGLuint64NV eglGetSystemTimeNV()
1913 {
1914     clearError();
1915
1916     if (egl_init_drivers() == EGL_FALSE) {
1917         return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1918     }
1919
1920     EGLuint64NV ret = 0;
1921     egl_connection_t* const cnx = &gEGLImpl;
1922
1923     if (cnx->dso && cnx->egl.eglGetSystemTimeNV) {
1924         return cnx->egl.eglGetSystemTimeNV();
1925     }
1926
1927     return setErrorQuiet(EGL_BAD_DISPLAY, 0);
1928 }
1929
1930 // ----------------------------------------------------------------------------
1931 // Partial update extension
1932 // ----------------------------------------------------------------------------
1933 EGLBoolean eglSetDamageRegionKHR(EGLDisplay dpy, EGLSurface surface,
1934         EGLint *rects, EGLint n_rects)
1935 {
1936     clearError();
1937
1938     const egl_display_ptr dp = validate_display(dpy);
1939     if (!dp) {
1940         setError(EGL_BAD_DISPLAY, EGL_FALSE);
1941         return EGL_FALSE;
1942     }
1943
1944     SurfaceRef _s(dp.get(), surface);
1945     if (!_s.get()) {
1946         setError(EGL_BAD_SURFACE, EGL_FALSE);
1947         return EGL_FALSE;
1948     }
1949
1950     egl_surface_t const * const s = get_surface(surface);
1951     if (s->cnx->egl.eglSetDamageRegionKHR) {
1952         return s->cnx->egl.eglSetDamageRegionKHR(dp->disp.dpy, s->surface,
1953                 rects, n_rects);
1954     }
1955
1956     return EGL_FALSE;
1957 }
1958
1959 EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface,
1960         EGLint framesAgo, EGLint numTimestamps, const EGLint *timestamps,
1961         EGLnsecsANDROID *values)
1962 {
1963     clearError();
1964
1965     const egl_display_ptr dp = validate_display(dpy);
1966     if (!dp) {
1967         setError(EGL_BAD_DISPLAY, EGL_FALSE);
1968         return EGL_FALSE;
1969     }
1970
1971     SurfaceRef _s(dp.get(), surface);
1972     if (!_s.get()) {
1973         setError(EGL_BAD_SURFACE, EGL_FALSE);
1974         return EGL_FALSE;
1975     }
1976
1977     egl_surface_t const * const s = get_surface(surface);
1978
1979     if (!s->enableTimestamps) {
1980         setError(EGL_BAD_SURFACE, EGL_FALSE);
1981         return EGL_FALSE;
1982     }
1983
1984     nsecs_t* postedTime = nullptr;
1985     nsecs_t* acquireTime = nullptr;
1986     nsecs_t* refreshStartTime = nullptr;
1987     nsecs_t* GLCompositionDoneTime = nullptr;
1988     nsecs_t* displayRetireTime = nullptr;
1989     nsecs_t* releaseTime = nullptr;
1990
1991     for (int i = 0; i < numTimestamps; i++) {
1992         switch (timestamps[i]) {
1993             case EGL_QUEUE_TIME_ANDROID:
1994                 postedTime = &values[i];
1995                 break;
1996             case EGL_RENDERING_COMPLETE_TIME_ANDROID:
1997                 acquireTime = &values[i];
1998                 break;
1999             case EGL_COMPOSITION_START_TIME_ANDROID:
2000                 refreshStartTime = &values[i];
2001                 break;
2002             case EGL_COMPOSITION_FINISHED_TIME_ANDROID:
2003                 GLCompositionDoneTime = &values[i];
2004                 break;
2005             case EGL_DISPLAY_RETIRE_TIME_ANDROID:
2006                 displayRetireTime = &values[i];
2007                 break;
2008             case EGL_READS_DONE_TIME_ANDROID:
2009                 releaseTime = &values[i];
2010                 break;
2011             default:
2012                 setError(EGL_BAD_PARAMETER, EGL_FALSE);
2013                 return EGL_FALSE;
2014         }
2015     }
2016
2017     status_t ret = native_window_get_frame_timestamps(s->win.get(), framesAgo,
2018             postedTime, acquireTime, refreshStartTime, GLCompositionDoneTime,
2019             displayRetireTime, releaseTime);
2020
2021     if (ret != NO_ERROR) {
2022         setError(EGL_BAD_ACCESS, EGL_FALSE);
2023         return EGL_FALSE;
2024     }
2025
2026     return EGL_TRUE;
2027 }
2028
2029 EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface,
2030         EGLint timestamp)
2031 {
2032     clearError();
2033
2034     const egl_display_ptr dp = validate_display(dpy);
2035     if (!dp) {
2036         setError(EGL_BAD_DISPLAY, EGL_FALSE);
2037         return EGL_FALSE;
2038     }
2039
2040     SurfaceRef _s(dp.get(), surface);
2041     if (!_s.get()) {
2042         setError(EGL_BAD_SURFACE, EGL_FALSE);
2043         return EGL_FALSE;
2044     }
2045
2046     switch (timestamp) {
2047 #if ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS
2048         case EGL_QUEUE_TIME_ANDROID:
2049         case EGL_RENDERING_COMPLETE_TIME_ANDROID:
2050         case EGL_COMPOSITION_START_TIME_ANDROID:
2051         case EGL_COMPOSITION_FINISHED_TIME_ANDROID:
2052         case EGL_DISPLAY_RETIRE_TIME_ANDROID:
2053         case EGL_READS_DONE_TIME_ANDROID:
2054             return EGL_TRUE;
2055 #endif
2056         default:
2057             return EGL_FALSE;
2058     }
2059 }