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