1 /* 2 ** Copyright 2007, The Android Open Source Project 3 ** 4 ** Licensed under the Apache License, Version 2.0 (the "License"); 5 ** you may not use this file except in compliance with the License. 6 ** You may obtain a copy of the License at 7 ** 8 ** http://www.apache.org/licenses/LICENSE-2.0 9 ** 10 ** Unless required by applicable law or agreed to in writing, software 11 ** distributed under the License is distributed on an "AS IS" BASIS, 12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 ** See the License for the specific language governing permissions and 14 ** limitations under the License. 15 */ 16 17 #define ATRACE_TAG ATRACE_TAG_GRAPHICS 18 19 #include <ctype.h> 20 #include <dlfcn.h> 21 #include <stdlib.h> 22 #include <string.h> 23 24 #include <hardware/gralloc1.h> 25 26 #include <EGL/egl.h> 27 #include <EGL/eglext.h> 28 29 #include <android/hardware_buffer.h> 30 #include <private/android/AHardwareBufferHelpers.h> 31 32 #include <cutils/compiler.h> 33 #include <cutils/properties.h> 34 #include <log/log.h> 35 36 #include <condition_variable> 37 #include <deque> 38 #include <mutex> 39 #include <unordered_map> 40 #include <string> 41 #include <thread> 42 43 #include "../egl_impl.h" 44 45 #include "egl_display.h" 46 #include "egl_object.h" 47 #include "egl_tls.h" 48 #include "egl_trace.h" 49 50 using namespace android; 51 52 // ---------------------------------------------------------------------------- 53 54 namespace android { 55 56 using nsecs_t = int64_t; 57 58 struct extention_map_t { 59 const char* name; 60 __eglMustCastToProperFunctionPointerType address; 61 }; 62 63 /* 64 * This is the list of EGL extensions exposed to applications. 65 * 66 * Some of them (gBuiltinExtensionString) are implemented entirely in this EGL 67 * wrapper and are always available. 68 * 69 * The rest (gExtensionString) depend on support in the EGL driver, and are 70 * only available if the driver supports them. However, some of these must be 71 * supported because they are used by the Android system itself; these are 72 * listed as mandatory below and are required by the CDD. The system *assumes* 73 * the mandatory extensions are present and may not function properly if some 74 * are missing. 75 * 76 * NOTE: Both strings MUST have a single space as the last character. 77 */ 78 79 extern char const * const gBuiltinExtensionString; 80 extern char const * const gExtensionString; 81 82 // clang-format off 83 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_get_native_client_buffer " 88 "EGL_ANDROID_front_buffer_auto_refresh " 89 "EGL_ANDROID_get_frame_timestamps " 90 ; 91 92 char const * const gExtensionString = 93 "EGL_KHR_image " // mandatory 94 "EGL_KHR_image_base " // mandatory 95 "EGL_KHR_image_pixmap " 96 "EGL_KHR_lock_surface " 97 "EGL_KHR_gl_colorspace " 98 "EGL_KHR_gl_texture_2D_image " 99 "EGL_KHR_gl_texture_3D_image " 100 "EGL_KHR_gl_texture_cubemap_image " 101 "EGL_KHR_gl_renderbuffer_image " 102 "EGL_KHR_reusable_sync " 103 "EGL_KHR_fence_sync " 104 "EGL_KHR_create_context " 105 "EGL_KHR_config_attribs " 106 "EGL_KHR_surfaceless_context " 107 "EGL_KHR_stream " 108 "EGL_KHR_stream_fifo " 109 "EGL_KHR_stream_producer_eglsurface " 110 "EGL_KHR_stream_consumer_gltexture " 111 "EGL_KHR_stream_cross_process_fd " 112 "EGL_EXT_create_context_robustness " 113 "EGL_NV_system_time " 114 "EGL_ANDROID_image_native_buffer " // mandatory 115 "EGL_KHR_wait_sync " // strongly recommended 116 "EGL_ANDROID_recordable " // mandatory 117 "EGL_KHR_partial_update " // strongly recommended 118 "EGL_EXT_pixel_format_float " 119 "EGL_EXT_buffer_age " // strongly recommended with partial_update 120 "EGL_KHR_create_context_no_error " 121 "EGL_KHR_mutable_render_buffer " 122 "EGL_EXT_yuv_surface " 123 "EGL_EXT_protected_content " 124 "EGL_IMG_context_priority " 125 "EGL_KHR_no_config_context " 126 ; 127 // clang-format on 128 129 // extensions not exposed to applications but used by the ANDROID system 130 // "EGL_ANDROID_blob_cache " // strongly recommended 131 // "EGL_IMG_hibernate_process " // optional 132 // "EGL_ANDROID_native_fence_sync " // strongly recommended 133 // "EGL_ANDROID_framebuffer_target " // mandatory for HWC 1.1 134 // "EGL_ANDROID_image_crop " // optional 135 136 /* 137 * EGL Extensions entry-points exposed to 3rd party applications 138 * (keep in sync with gExtensionString above) 139 * 140 */ 141 static const extention_map_t sExtensionMap[] = { 142 // EGL_KHR_lock_surface 143 { "eglLockSurfaceKHR", 144 (__eglMustCastToProperFunctionPointerType)&eglLockSurfaceKHR }, 145 { "eglUnlockSurfaceKHR", 146 (__eglMustCastToProperFunctionPointerType)&eglUnlockSurfaceKHR }, 147 148 // EGL_KHR_image, EGL_KHR_image_base 149 { "eglCreateImageKHR", 150 (__eglMustCastToProperFunctionPointerType)&eglCreateImageKHR }, 151 { "eglDestroyImageKHR", 152 (__eglMustCastToProperFunctionPointerType)&eglDestroyImageKHR }, 153 154 // EGL_KHR_reusable_sync, EGL_KHR_fence_sync 155 { "eglCreateSyncKHR", 156 (__eglMustCastToProperFunctionPointerType)&eglCreateSyncKHR }, 157 { "eglDestroySyncKHR", 158 (__eglMustCastToProperFunctionPointerType)&eglDestroySyncKHR }, 159 { "eglClientWaitSyncKHR", 160 (__eglMustCastToProperFunctionPointerType)&eglClientWaitSyncKHR }, 161 { "eglSignalSyncKHR", 162 (__eglMustCastToProperFunctionPointerType)&eglSignalSyncKHR }, 163 { "eglGetSyncAttribKHR", 164 (__eglMustCastToProperFunctionPointerType)&eglGetSyncAttribKHR }, 165 166 // EGL_NV_system_time 167 { "eglGetSystemTimeFrequencyNV", 168 (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeFrequencyNV }, 169 { "eglGetSystemTimeNV", 170 (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeNV }, 171 172 // EGL_KHR_wait_sync 173 { "eglWaitSyncKHR", 174 (__eglMustCastToProperFunctionPointerType)&eglWaitSyncKHR }, 175 176 // EGL_ANDROID_presentation_time 177 { "eglPresentationTimeANDROID", 178 (__eglMustCastToProperFunctionPointerType)&eglPresentationTimeANDROID }, 179 180 // EGL_KHR_swap_buffers_with_damage 181 { "eglSwapBuffersWithDamageKHR", 182 (__eglMustCastToProperFunctionPointerType)&eglSwapBuffersWithDamageKHR }, 183 184 // EGL_ANDROID_get_native_client_buffer 185 { "eglGetNativeClientBufferANDROID", 186 (__eglMustCastToProperFunctionPointerType)&eglGetNativeClientBufferANDROID }, 187 188 // EGL_KHR_partial_update 189 { "eglSetDamageRegionKHR", 190 (__eglMustCastToProperFunctionPointerType)&eglSetDamageRegionKHR }, 191 192 { "eglCreateStreamKHR", 193 (__eglMustCastToProperFunctionPointerType)&eglCreateStreamKHR }, 194 { "eglDestroyStreamKHR", 195 (__eglMustCastToProperFunctionPointerType)&eglDestroyStreamKHR }, 196 { "eglStreamAttribKHR", 197 (__eglMustCastToProperFunctionPointerType)&eglStreamAttribKHR }, 198 { "eglQueryStreamKHR", 199 (__eglMustCastToProperFunctionPointerType)&eglQueryStreamKHR }, 200 { "eglQueryStreamu64KHR", 201 (__eglMustCastToProperFunctionPointerType)&eglQueryStreamu64KHR }, 202 { "eglQueryStreamTimeKHR", 203 (__eglMustCastToProperFunctionPointerType)&eglQueryStreamTimeKHR }, 204 { "eglCreateStreamProducerSurfaceKHR", 205 (__eglMustCastToProperFunctionPointerType)&eglCreateStreamProducerSurfaceKHR }, 206 { "eglStreamConsumerGLTextureExternalKHR", 207 (__eglMustCastToProperFunctionPointerType)&eglStreamConsumerGLTextureExternalKHR }, 208 { "eglStreamConsumerAcquireKHR", 209 (__eglMustCastToProperFunctionPointerType)&eglStreamConsumerAcquireKHR }, 210 { "eglStreamConsumerReleaseKHR", 211 (__eglMustCastToProperFunctionPointerType)&eglStreamConsumerReleaseKHR }, 212 { "eglGetStreamFileDescriptorKHR", 213 (__eglMustCastToProperFunctionPointerType)&eglGetStreamFileDescriptorKHR }, 214 { "eglCreateStreamFromFileDescriptorKHR", 215 (__eglMustCastToProperFunctionPointerType)&eglCreateStreamFromFileDescriptorKHR }, 216 217 // EGL_ANDROID_get_frame_timestamps 218 { "eglGetNextFrameIdANDROID", 219 (__eglMustCastToProperFunctionPointerType)&eglGetNextFrameIdANDROID }, 220 { "eglGetCompositorTimingANDROID", 221 (__eglMustCastToProperFunctionPointerType)&eglGetCompositorTimingANDROID }, 222 { "eglGetCompositorTimingSupportedANDROID", 223 (__eglMustCastToProperFunctionPointerType)&eglGetCompositorTimingSupportedANDROID }, 224 { "eglGetFrameTimestampsANDROID", 225 (__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampsANDROID }, 226 { "eglGetFrameTimestampSupportedANDROID", 227 (__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampSupportedANDROID }, 228 229 // EGL_ANDROID_native_fence_sync 230 { "eglDupNativeFenceFDANDROID", 231 (__eglMustCastToProperFunctionPointerType)&eglDupNativeFenceFDANDROID }, 232 }; 233 234 /* 235 * These extensions entry-points should not be exposed to applications. 236 * They're used internally by the Android EGL layer. 237 */ 238 #define FILTER_EXTENSIONS(procname) \ 239 (!strcmp((procname), "eglSetBlobCacheFuncsANDROID") || \ 240 !strcmp((procname), "eglHibernateProcessIMG") || \ 241 !strcmp((procname), "eglAwakenProcessIMG")) 242 243 244 245 // accesses protected by sExtensionMapMutex 246 static std::unordered_map<std::string, __eglMustCastToProperFunctionPointerType> sGLExtentionMap; 247 248 static int sGLExtentionSlot = 0; 249 static pthread_mutex_t sExtensionMapMutex = PTHREAD_MUTEX_INITIALIZER; 250 251 static void(*findProcAddress(const char* name, 252 const extention_map_t* map, size_t n))() { 253 for (uint32_t i=0 ; i<n ; i++) { 254 if (!strcmp(name, map[i].name)) { 255 return map[i].address; 256 } 257 } 258 return NULL; 259 } 260 261 // ---------------------------------------------------------------------------- 262 263 extern void setGLHooksThreadSpecific(gl_hooks_t const *value); 264 extern EGLBoolean egl_init_drivers(); 265 extern const __eglMustCastToProperFunctionPointerType gExtensionForwarders[MAX_NUMBER_OF_GL_EXTENSIONS]; 266 extern gl_hooks_t gHooksTrace; 267 268 } // namespace android; 269 270 271 // ---------------------------------------------------------------------------- 272 273 static inline void clearError() { egl_tls_t::clearError(); } 274 static inline EGLContext getContext() { return egl_tls_t::getContext(); } 275 276 // ---------------------------------------------------------------------------- 277 278 EGLDisplay eglGetDisplay(EGLNativeDisplayType display) 279 { 280 ATRACE_CALL(); 281 clearError(); 282 283 uintptr_t index = reinterpret_cast<uintptr_t>(display); 284 if (index >= NUM_DISPLAYS) { 285 return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY); 286 } 287 288 if (egl_init_drivers() == EGL_FALSE) { 289 return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY); 290 } 291 292 EGLDisplay dpy = egl_display_t::getFromNativeDisplay(display); 293 return dpy; 294 } 295 296 // ---------------------------------------------------------------------------- 297 // Initialization 298 // ---------------------------------------------------------------------------- 299 300 EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) 301 { 302 clearError(); 303 304 egl_display_ptr dp = get_display(dpy); 305 if (!dp) return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); 306 307 EGLBoolean res = dp->initialize(major, minor); 308 309 return res; 310 } 311 312 EGLBoolean eglTerminate(EGLDisplay dpy) 313 { 314 // NOTE: don't unload the drivers b/c some APIs can be called 315 // after eglTerminate() has been called. eglTerminate() only 316 // terminates an EGLDisplay, not a EGL itself. 317 318 clearError(); 319 320 egl_display_ptr dp = get_display(dpy); 321 if (!dp) return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); 322 323 EGLBoolean res = dp->terminate(); 324 325 return res; 326 } 327 328 // ---------------------------------------------------------------------------- 329 // configuration 330 // ---------------------------------------------------------------------------- 331 332 EGLBoolean eglGetConfigs( EGLDisplay dpy, 333 EGLConfig *configs, 334 EGLint config_size, EGLint *num_config) 335 { 336 clearError(); 337 338 const egl_display_ptr dp = validate_display(dpy); 339 if (!dp) return EGL_FALSE; 340 341 if (num_config==0) { 342 return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); 343 } 344 345 EGLBoolean res = EGL_FALSE; 346 *num_config = 0; 347 348 egl_connection_t* const cnx = &gEGLImpl; 349 if (cnx->dso) { 350 res = cnx->egl.eglGetConfigs( 351 dp->disp.dpy, configs, config_size, num_config); 352 } 353 354 return res; 355 } 356 357 EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list, 358 EGLConfig *configs, EGLint config_size, 359 EGLint *num_config) 360 { 361 clearError(); 362 363 const egl_display_ptr dp = validate_display(dpy); 364 if (!dp) return EGL_FALSE; 365 366 if (num_config==0) { 367 return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); 368 } 369 370 EGLBoolean res = EGL_FALSE; 371 *num_config = 0; 372 373 egl_connection_t* const cnx = &gEGLImpl; 374 if (cnx->dso) { 375 if (attrib_list) { 376 char value[PROPERTY_VALUE_MAX]; 377 property_get("debug.egl.force_msaa", value, "false"); 378 379 if (!strcmp(value, "true")) { 380 size_t attribCount = 0; 381 EGLint attrib = attrib_list[0]; 382 383 // Only enable MSAA if the context is OpenGL ES 2.0 and 384 // if no caveat is requested 385 const EGLint *attribRendererable = NULL; 386 const EGLint *attribCaveat = NULL; 387 388 // Count the number of attributes and look for 389 // EGL_RENDERABLE_TYPE and EGL_CONFIG_CAVEAT 390 while (attrib != EGL_NONE) { 391 attrib = attrib_list[attribCount]; 392 switch (attrib) { 393 case EGL_RENDERABLE_TYPE: 394 attribRendererable = &attrib_list[attribCount]; 395 break; 396 case EGL_CONFIG_CAVEAT: 397 attribCaveat = &attrib_list[attribCount]; 398 break; 399 default: 400 break; 401 } 402 attribCount++; 403 } 404 405 if (attribRendererable && attribRendererable[1] == EGL_OPENGL_ES2_BIT && 406 (!attribCaveat || attribCaveat[1] != EGL_NONE)) { 407 408 // Insert 2 extra attributes to force-enable MSAA 4x 409 EGLint aaAttribs[attribCount + 4]; 410 aaAttribs[0] = EGL_SAMPLE_BUFFERS; 411 aaAttribs[1] = 1; 412 aaAttribs[2] = EGL_SAMPLES; 413 aaAttribs[3] = 4; 414 415 memcpy(&aaAttribs[4], attrib_list, attribCount * sizeof(EGLint)); 416 417 EGLint numConfigAA; 418 EGLBoolean resAA = cnx->egl.eglChooseConfig( 419 dp->disp.dpy, aaAttribs, configs, config_size, &numConfigAA); 420 421 if (resAA == EGL_TRUE && numConfigAA > 0) { 422 ALOGD("Enabling MSAA 4x"); 423 *num_config = numConfigAA; 424 return resAA; 425 } 426 } 427 } 428 } 429 430 res = cnx->egl.eglChooseConfig( 431 dp->disp.dpy, attrib_list, configs, config_size, num_config); 432 } 433 return res; 434 } 435 436 EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, 437 EGLint attribute, EGLint *value) 438 { 439 clearError(); 440 441 egl_connection_t* cnx = NULL; 442 const egl_display_ptr dp = validate_display_connection(dpy, cnx); 443 if (!dp) return EGL_FALSE; 444 445 return cnx->egl.eglGetConfigAttrib( 446 dp->disp.dpy, config, attribute, value); 447 } 448 449 // ---------------------------------------------------------------------------- 450 // surfaces 451 // ---------------------------------------------------------------------------- 452 453 // Turn linear formats into corresponding sRGB formats when colorspace is 454 // EGL_GL_COLORSPACE_SRGB_KHR, or turn sRGB formats into corresponding linear 455 // formats when colorspace is EGL_GL_COLORSPACE_LINEAR_KHR. In any cases where 456 // the modification isn't possible, the original dataSpace is returned. 457 static android_dataspace modifyBufferDataspace(android_dataspace dataSpace, 458 EGLint colorspace) { 459 if (colorspace == EGL_GL_COLORSPACE_LINEAR_KHR) { 460 return HAL_DATASPACE_SRGB_LINEAR; 461 } else if (colorspace == EGL_GL_COLORSPACE_SRGB_KHR) { 462 return HAL_DATASPACE_SRGB; 463 } else if (colorspace == EGL_GL_COLORSPACE_DISPLAY_P3_EXT) { 464 return HAL_DATASPACE_DISPLAY_P3; 465 } else if (colorspace == EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT) { 466 return HAL_DATASPACE_DISPLAY_P3_LINEAR; 467 } else if (colorspace == EGL_GL_COLORSPACE_SCRGB_EXT) { 468 return HAL_DATASPACE_V0_SCRGB; 469 } else if (colorspace == EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT) { 470 return HAL_DATASPACE_V0_SCRGB_LINEAR; 471 } 472 return dataSpace; 473 } 474 475 // Return true if we stripped any EGL_GL_COLORSPACE_KHR attributes. 476 static EGLBoolean stripColorSpaceAttribute(egl_display_ptr dp, const EGLint* attrib_list, 477 EGLint format, 478 std::vector<EGLint>& stripped_attrib_list) { 479 std::vector<EGLint> allowedColorSpaces; 480 switch (format) { 481 case HAL_PIXEL_FORMAT_RGBA_8888: 482 case HAL_PIXEL_FORMAT_RGB_565: 483 // driver okay with linear & sRGB for 8888, but can't handle 484 // Display-P3 or other spaces. 485 allowedColorSpaces.push_back(EGL_GL_COLORSPACE_SRGB_KHR); 486 allowedColorSpaces.push_back(EGL_GL_COLORSPACE_LINEAR_KHR); 487 break; 488 489 case HAL_PIXEL_FORMAT_RGBA_FP16: 490 case HAL_PIXEL_FORMAT_RGBA_1010102: 491 default: 492 // driver does not want to see colorspace attributes for 1010102 or fp16. 493 // Future: if driver supports XXXX extension, we can pass down that colorspace 494 break; 495 } 496 497 bool stripped = false; 498 if (attrib_list && dp->haveExtension("EGL_KHR_gl_colorspace")) { 499 for (const EGLint* attr = attrib_list; attr[0] != EGL_NONE; attr += 2) { 500 if (attr[0] == EGL_GL_COLORSPACE_KHR) { 501 EGLint colorSpace = attr[1]; 502 bool found = false; 503 // Verify that color space is allowed 504 for (auto it : allowedColorSpaces) { 505 if (colorSpace == it) { 506 found = true; 507 } 508 } 509 if (!found) { 510 stripped = true; 511 } else { 512 stripped_attrib_list.push_back(attr[0]); 513 stripped_attrib_list.push_back(attr[1]); 514 } 515 } else { 516 stripped_attrib_list.push_back(attr[0]); 517 stripped_attrib_list.push_back(attr[1]); 518 } 519 } 520 } 521 if (stripped) { 522 stripped_attrib_list.push_back(EGL_NONE); 523 stripped_attrib_list.push_back(EGL_NONE); 524 } 525 return stripped; 526 } 527 528 static EGLBoolean getColorSpaceAttribute(egl_display_ptr dp, NativeWindowType window, 529 const EGLint* attrib_list, EGLint& colorSpace, 530 android_dataspace& dataSpace) { 531 colorSpace = EGL_GL_COLORSPACE_LINEAR_KHR; 532 dataSpace = HAL_DATASPACE_UNKNOWN; 533 534 if (attrib_list && dp->haveExtension("EGL_KHR_gl_colorspace")) { 535 for (const EGLint* attr = attrib_list; *attr != EGL_NONE; attr += 2) { 536 if (*attr == EGL_GL_COLORSPACE_KHR) { 537 colorSpace = attr[1]; 538 bool found = false; 539 bool verify = true; 540 // Verify that color space is allowed 541 if (colorSpace == EGL_GL_COLORSPACE_SRGB_KHR || 542 colorSpace == EGL_GL_COLORSPACE_LINEAR_KHR) { 543 // SRGB and LINEAR are always supported when EGL_KHR_gl_colorspace 544 // is available, so no need to verify. 545 found = true; 546 verify = false; 547 } else if (colorSpace == EGL_EXT_gl_colorspace_bt2020_linear && 548 dp->haveExtension("EGL_EXT_gl_colorspace_bt2020_linear")) { 549 found = true; 550 } else if (colorSpace == EGL_EXT_gl_colorspace_bt2020_pq && 551 dp->haveExtension("EGL_EXT_gl_colorspace_bt2020_pq")) { 552 found = true; 553 } else if (colorSpace == EGL_GL_COLORSPACE_SCRGB_EXT && 554 dp->haveExtension("EGL_EXT_gl_colorspace_scrgb")) { 555 found = true; 556 } else if (colorSpace == EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT && 557 dp->haveExtension("EGL_EXT_gl_colorspace_scrgb_linear")) { 558 found = true; 559 } else if (colorSpace == EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT && 560 dp->haveExtension("EGL_EXT_gl_colorspace_display_p3_linear")) { 561 found = true; 562 } else if (colorSpace == EGL_GL_COLORSPACE_DISPLAY_P3_EXT && 563 dp->haveExtension("EGL_EXT_gl_colorspace_display_p3")) { 564 found = true; 565 } 566 if (!found) { 567 return false; 568 } 569 if (verify && window) { 570 bool wide_color_support = true; 571 // Ordinarily we'd put a call to native_window_get_wide_color_support 572 // at the beginning of the function so that we'll have the 573 // result when needed elsewhere in the function. 574 // However, because eglCreateWindowSurface is called by SurfaceFlinger and 575 // SurfaceFlinger is required to answer the call below we would 576 // end up in a deadlock situation. By moving the call to only happen 577 // if the application has specifically asked for wide-color we avoid 578 // the deadlock with SurfaceFlinger since it will not ask for a 579 // wide-color surface. 580 int err = native_window_get_wide_color_support(window, &wide_color_support); 581 582 if (err) { 583 ALOGE("getColorSpaceAttribute: invalid window (win=%p) " 584 "failed (%#x) (already connected to another API?)", 585 window, err); 586 return false; 587 } 588 if (!wide_color_support) { 589 // Application has asked for a wide-color colorspace but 590 // wide-color support isn't available on the display the window is on. 591 return false; 592 } 593 } 594 // Only change the dataSpace from default if the application 595 // has explicitly set the color space with a EGL_GL_COLORSPACE_KHR attribute. 596 dataSpace = modifyBufferDataspace(dataSpace, colorSpace); 597 } 598 } 599 } 600 return true; 601 } 602 603 static EGLBoolean getColorSpaceAttribute(egl_display_ptr dp, const EGLint* attrib_list, 604 EGLint& colorSpace, android_dataspace& dataSpace) { 605 return getColorSpaceAttribute(dp, NULL, attrib_list, colorSpace, dataSpace); 606 } 607 608 void getNativePixelFormat(EGLDisplay dpy, egl_connection_t* cnx, EGLConfig config, EGLint& format) { 609 // Set the native window's buffers format to match what this config requests. 610 // Whether to use sRGB gamma is not part of the EGLconfig, but is part 611 // of our native format. So if sRGB gamma is requested, we have to 612 // modify the EGLconfig's format before setting the native window's 613 // format. 614 615 EGLint componentType = EGL_COLOR_COMPONENT_TYPE_FIXED_EXT; 616 cnx->egl.eglGetConfigAttrib(dpy, config, EGL_COLOR_COMPONENT_TYPE_EXT, &componentType); 617 618 EGLint a = 0; 619 EGLint r, g, b; 620 r = g = b = 0; 621 cnx->egl.eglGetConfigAttrib(dpy, config, EGL_RED_SIZE, &r); 622 cnx->egl.eglGetConfigAttrib(dpy, config, EGL_GREEN_SIZE, &g); 623 cnx->egl.eglGetConfigAttrib(dpy, config, EGL_BLUE_SIZE, &b); 624 cnx->egl.eglGetConfigAttrib(dpy, config, EGL_ALPHA_SIZE, &a); 625 EGLint colorDepth = r + g + b; 626 627 // Today, the driver only understands sRGB and linear on 888X 628 // formats. Strip other colorspaces from the attribute list and 629 // only use them to set the dataspace via 630 // native_window_set_buffers_dataspace 631 // if pixel format is RGBX 8888 632 // TBD: Can test for future extensions that indicate that driver 633 // handles requested color space and we can let it through. 634 // allow SRGB and LINEAR. All others need to be stripped. 635 // else if 565, 4444 636 // TBD: Can we assume these are supported if 8888 is? 637 // else if FP16 or 1010102 638 // strip colorspace from attribs. 639 // endif 640 if (a == 0) { 641 if (colorDepth <= 16) { 642 format = HAL_PIXEL_FORMAT_RGB_565; 643 } else { 644 if (componentType == EGL_COLOR_COMPONENT_TYPE_FIXED_EXT) { 645 if (colorDepth > 24) { 646 format = HAL_PIXEL_FORMAT_RGBA_1010102; 647 } else { 648 format = HAL_PIXEL_FORMAT_RGBX_8888; 649 } 650 } else { 651 format = HAL_PIXEL_FORMAT_RGBA_FP16; 652 } 653 } 654 } else { 655 if (componentType == EGL_COLOR_COMPONENT_TYPE_FIXED_EXT) { 656 if (colorDepth > 24) { 657 format = HAL_PIXEL_FORMAT_RGBA_1010102; 658 } else { 659 format = HAL_PIXEL_FORMAT_RGBA_8888; 660 } 661 } else { 662 format = HAL_PIXEL_FORMAT_RGBA_FP16; 663 } 664 } 665 } 666 667 EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config, 668 NativeWindowType window, 669 const EGLint *attrib_list) 670 { 671 clearError(); 672 673 egl_connection_t* cnx = NULL; 674 egl_display_ptr dp = validate_display_connection(dpy, cnx); 675 if (dp) { 676 EGLDisplay iDpy = dp->disp.dpy; 677 678 if (!window) { 679 return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE); 680 } 681 682 int value = 0; 683 window->query(window, NATIVE_WINDOW_IS_VALID, &value); 684 if (!value) { 685 return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE); 686 } 687 688 int result = native_window_api_connect(window, NATIVE_WINDOW_API_EGL); 689 if (result < 0) { 690 ALOGE("eglCreateWindowSurface: native_window_api_connect (win=%p) " 691 "failed (%#x) (already connected to another API?)", 692 window, result); 693 return setError(EGL_BAD_ALLOC, EGL_NO_SURFACE); 694 } 695 696 EGLint format; 697 getNativePixelFormat(iDpy, cnx, config, format); 698 699 // now select correct colorspace and dataspace based on user's attribute list 700 EGLint colorSpace; 701 android_dataspace dataSpace; 702 if (!getColorSpaceAttribute(dp, window, attrib_list, colorSpace, dataSpace)) { 703 ALOGE("error invalid colorspace: %d", colorSpace); 704 return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); 705 } 706 707 std::vector<EGLint> strippedAttribList; 708 if (stripColorSpaceAttribute(dp, attrib_list, format, strippedAttribList)) { 709 // Had to modify the attribute list due to use of color space. 710 // Use modified list from here on. 711 attrib_list = strippedAttribList.data(); 712 } 713 714 if (format != 0) { 715 int err = native_window_set_buffers_format(window, format); 716 if (err != 0) { 717 ALOGE("error setting native window pixel format: %s (%d)", 718 strerror(-err), err); 719 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL); 720 return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE); 721 } 722 } 723 724 if (dataSpace != 0) { 725 int err = native_window_set_buffers_data_space(window, dataSpace); 726 if (err != 0) { 727 ALOGE("error setting native window pixel dataSpace: %s (%d)", 728 strerror(-err), err); 729 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL); 730 return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE); 731 } 732 } 733 734 // the EGL spec requires that a new EGLSurface default to swap interval 735 // 1, so explicitly set that on the window here. 736 ANativeWindow* anw = reinterpret_cast<ANativeWindow*>(window); 737 anw->setSwapInterval(anw, 1); 738 739 EGLSurface surface = cnx->egl.eglCreateWindowSurface( 740 iDpy, config, window, attrib_list); 741 if (surface != EGL_NO_SURFACE) { 742 egl_surface_t* s = 743 new egl_surface_t(dp.get(), config, window, surface, colorSpace, cnx); 744 return s; 745 } 746 747 // EGLSurface creation failed 748 native_window_set_buffers_format(window, 0); 749 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL); 750 } 751 return EGL_NO_SURFACE; 752 } 753 754 EGLSurface eglCreatePixmapSurface( EGLDisplay dpy, EGLConfig config, 755 NativePixmapType pixmap, 756 const EGLint *attrib_list) 757 { 758 clearError(); 759 760 egl_connection_t* cnx = NULL; 761 egl_display_ptr dp = validate_display_connection(dpy, cnx); 762 EGLint colorSpace; 763 android_dataspace dataSpace; 764 if (dp) { 765 // now select a corresponding sRGB format if needed 766 if (!getColorSpaceAttribute(dp, attrib_list, colorSpace, dataSpace)) { 767 ALOGE("error invalid colorspace: %d", colorSpace); 768 return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); 769 } 770 771 EGLSurface surface = cnx->egl.eglCreatePixmapSurface( 772 dp->disp.dpy, config, pixmap, attrib_list); 773 if (surface != EGL_NO_SURFACE) { 774 egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL, surface, colorSpace, cnx); 775 return s; 776 } 777 } 778 return EGL_NO_SURFACE; 779 } 780 781 EGLSurface eglCreatePbufferSurface( EGLDisplay dpy, EGLConfig config, 782 const EGLint *attrib_list) 783 { 784 clearError(); 785 786 egl_connection_t* cnx = NULL; 787 egl_display_ptr dp = validate_display_connection(dpy, cnx); 788 if (dp) { 789 EGLDisplay iDpy = dp->disp.dpy; 790 EGLint format; 791 getNativePixelFormat(iDpy, cnx, config, format); 792 793 // now select correct colorspace and dataspace based on user's attribute list 794 EGLint colorSpace; 795 android_dataspace dataSpace; 796 if (!getColorSpaceAttribute(dp, attrib_list, colorSpace, dataSpace)) { 797 ALOGE("error invalid colorspace: %d", colorSpace); 798 return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); 799 } 800 801 // Pbuffers are not displayed so we don't need to store the 802 // colorspace. We do need to filter out color spaces the 803 // driver doesn't know how to process. 804 std::vector<EGLint> strippedAttribList; 805 if (stripColorSpaceAttribute(dp, attrib_list, format, strippedAttribList)) { 806 // Had to modify the attribute list due to use of color space. 807 // Use modified list from here on. 808 attrib_list = strippedAttribList.data(); 809 } 810 811 EGLSurface surface = cnx->egl.eglCreatePbufferSurface( 812 dp->disp.dpy, config, attrib_list); 813 if (surface != EGL_NO_SURFACE) { 814 egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL, surface, colorSpace, cnx); 815 return s; 816 } 817 } 818 return EGL_NO_SURFACE; 819 } 820 821 EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface) 822 { 823 clearError(); 824 825 const egl_display_ptr dp = validate_display(dpy); 826 if (!dp) return EGL_FALSE; 827 828 SurfaceRef _s(dp.get(), surface); 829 if (!_s.get()) 830 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 831 832 egl_surface_t * const s = get_surface(surface); 833 EGLBoolean result = s->cnx->egl.eglDestroySurface(dp->disp.dpy, s->surface); 834 if (result == EGL_TRUE) { 835 _s.terminate(); 836 } 837 return result; 838 } 839 840 EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface surface, 841 EGLint attribute, EGLint *value) 842 { 843 clearError(); 844 845 const egl_display_ptr dp = validate_display(dpy); 846 if (!dp) return EGL_FALSE; 847 848 SurfaceRef _s(dp.get(), surface); 849 if (!_s.get()) 850 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 851 852 egl_surface_t const * const s = get_surface(surface); 853 if (attribute == EGL_GL_COLORSPACE_KHR) { 854 *value = s->getColorSpace(); 855 return EGL_TRUE; 856 } 857 return s->cnx->egl.eglQuerySurface( 858 dp->disp.dpy, s->surface, attribute, value); 859 } 860 861 void EGLAPI eglBeginFrame(EGLDisplay dpy, EGLSurface surface) { 862 ATRACE_CALL(); 863 clearError(); 864 865 const egl_display_ptr dp = validate_display(dpy); 866 if (!dp) { 867 return; 868 } 869 870 SurfaceRef _s(dp.get(), surface); 871 if (!_s.get()) { 872 setError(EGL_BAD_SURFACE, EGL_FALSE); 873 } 874 } 875 876 // ---------------------------------------------------------------------------- 877 // Contexts 878 // ---------------------------------------------------------------------------- 879 880 EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, 881 EGLContext share_list, const EGLint *attrib_list) 882 { 883 clearError(); 884 885 egl_connection_t* cnx = NULL; 886 const egl_display_ptr dp = validate_display_connection(dpy, cnx); 887 if (dp) { 888 if (share_list != EGL_NO_CONTEXT) { 889 if (!ContextRef(dp.get(), share_list).get()) { 890 return setError(EGL_BAD_CONTEXT, EGL_NO_CONTEXT); 891 } 892 egl_context_t* const c = get_context(share_list); 893 share_list = c->context; 894 } 895 EGLContext context = cnx->egl.eglCreateContext( 896 dp->disp.dpy, config, share_list, attrib_list); 897 if (context != EGL_NO_CONTEXT) { 898 // figure out if it's a GLESv1 or GLESv2 899 int version = 0; 900 if (attrib_list) { 901 while (*attrib_list != EGL_NONE) { 902 GLint attr = *attrib_list++; 903 GLint value = *attrib_list++; 904 if (attr == EGL_CONTEXT_CLIENT_VERSION) { 905 if (value == 1) { 906 version = egl_connection_t::GLESv1_INDEX; 907 } else if (value == 2 || value == 3) { 908 version = egl_connection_t::GLESv2_INDEX; 909 } 910 } 911 }; 912 } 913 egl_context_t* c = new egl_context_t(dpy, context, config, cnx, 914 version); 915 return c; 916 } 917 } 918 return EGL_NO_CONTEXT; 919 } 920 921 EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) 922 { 923 clearError(); 924 925 const egl_display_ptr dp = validate_display(dpy); 926 if (!dp) 927 return EGL_FALSE; 928 929 ContextRef _c(dp.get(), ctx); 930 if (!_c.get()) 931 return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); 932 933 egl_context_t * const c = get_context(ctx); 934 EGLBoolean result = c->cnx->egl.eglDestroyContext(dp->disp.dpy, c->context); 935 if (result == EGL_TRUE) { 936 _c.terminate(); 937 } 938 return result; 939 } 940 941 EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw, 942 EGLSurface read, EGLContext ctx) 943 { 944 clearError(); 945 946 egl_display_ptr dp = validate_display(dpy); 947 if (!dp) return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); 948 949 // If ctx is not EGL_NO_CONTEXT, read is not EGL_NO_SURFACE, or draw is not 950 // EGL_NO_SURFACE, then an EGL_NOT_INITIALIZED error is generated if dpy is 951 // a valid but uninitialized display. 952 if ( (ctx != EGL_NO_CONTEXT) || (read != EGL_NO_SURFACE) || 953 (draw != EGL_NO_SURFACE) ) { 954 if (!dp->isReady()) return setError(EGL_NOT_INITIALIZED, (EGLBoolean)EGL_FALSE); 955 } 956 957 // get a reference to the object passed in 958 ContextRef _c(dp.get(), ctx); 959 SurfaceRef _d(dp.get(), draw); 960 SurfaceRef _r(dp.get(), read); 961 962 // validate the context (if not EGL_NO_CONTEXT) 963 if ((ctx != EGL_NO_CONTEXT) && !_c.get()) { 964 // EGL_NO_CONTEXT is valid 965 return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); 966 } 967 968 // these are the underlying implementation's object 969 EGLContext impl_ctx = EGL_NO_CONTEXT; 970 EGLSurface impl_draw = EGL_NO_SURFACE; 971 EGLSurface impl_read = EGL_NO_SURFACE; 972 973 // these are our objects structs passed in 974 egl_context_t * c = NULL; 975 egl_surface_t const * d = NULL; 976 egl_surface_t const * r = NULL; 977 978 // these are the current objects structs 979 egl_context_t * cur_c = get_context(getContext()); 980 981 if (ctx != EGL_NO_CONTEXT) { 982 c = get_context(ctx); 983 impl_ctx = c->context; 984 } else { 985 // no context given, use the implementation of the current context 986 if (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE) { 987 // calling eglMakeCurrent( ..., !=0, !=0, EGL_NO_CONTEXT); 988 return setError(EGL_BAD_MATCH, (EGLBoolean)EGL_FALSE); 989 } 990 if (cur_c == NULL) { 991 // no current context 992 // not an error, there is just no current context. 993 return EGL_TRUE; 994 } 995 } 996 997 // retrieve the underlying implementation's draw EGLSurface 998 if (draw != EGL_NO_SURFACE) { 999 if (!_d.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1000 d = get_surface(draw); 1001 impl_draw = d->surface; 1002 } 1003 1004 // retrieve the underlying implementation's read EGLSurface 1005 if (read != EGL_NO_SURFACE) { 1006 if (!_r.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1007 r = get_surface(read); 1008 impl_read = r->surface; 1009 } 1010 1011 1012 EGLBoolean result = dp->makeCurrent(c, cur_c, 1013 draw, read, ctx, 1014 impl_draw, impl_read, impl_ctx); 1015 1016 if (result == EGL_TRUE) { 1017 if (c) { 1018 setGLHooksThreadSpecific(c->cnx->hooks[c->version]); 1019 egl_tls_t::setContext(ctx); 1020 _c.acquire(); 1021 _r.acquire(); 1022 _d.acquire(); 1023 } else { 1024 setGLHooksThreadSpecific(&gHooksNoContext); 1025 egl_tls_t::setContext(EGL_NO_CONTEXT); 1026 } 1027 } else { 1028 1029 if (cur_c != NULL) { 1030 // Force return to current context for drivers that cannot handle errors 1031 EGLBoolean restore_result = EGL_FALSE; 1032 // get a reference to the old current objects 1033 ContextRef _c2(dp.get(), cur_c); 1034 SurfaceRef _d2(dp.get(), cur_c->draw); 1035 SurfaceRef _r2(dp.get(), cur_c->read); 1036 1037 c = cur_c; 1038 impl_ctx = c->context; 1039 impl_draw = EGL_NO_SURFACE; 1040 if (cur_c->draw != EGL_NO_SURFACE) { 1041 d = get_surface(cur_c->draw); 1042 impl_draw = d->surface; 1043 } 1044 impl_read = EGL_NO_SURFACE; 1045 if (cur_c->read != EGL_NO_SURFACE) { 1046 r = get_surface(cur_c->read); 1047 impl_read = r->surface; 1048 } 1049 restore_result = dp->makeCurrent(c, cur_c, 1050 cur_c->draw, cur_c->read, cur_c->context, 1051 impl_draw, impl_read, impl_ctx); 1052 if (restore_result == EGL_TRUE) { 1053 _c2.acquire(); 1054 _r2.acquire(); 1055 _d2.acquire(); 1056 } else { 1057 ALOGE("Could not restore original EGL context"); 1058 } 1059 } 1060 // this will ALOGE the error 1061 egl_connection_t* const cnx = &gEGLImpl; 1062 result = setError(cnx->egl.eglGetError(), (EGLBoolean)EGL_FALSE); 1063 } 1064 return result; 1065 } 1066 1067 1068 EGLBoolean eglQueryContext( EGLDisplay dpy, EGLContext ctx, 1069 EGLint attribute, EGLint *value) 1070 { 1071 clearError(); 1072 1073 const egl_display_ptr dp = validate_display(dpy); 1074 if (!dp) return EGL_FALSE; 1075 1076 ContextRef _c(dp.get(), ctx); 1077 if (!_c.get()) return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); 1078 1079 egl_context_t * const c = get_context(ctx); 1080 return c->cnx->egl.eglQueryContext( 1081 dp->disp.dpy, c->context, attribute, value); 1082 1083 } 1084 1085 EGLContext eglGetCurrentContext(void) 1086 { 1087 // could be called before eglInitialize(), but we wouldn't have a context 1088 // then, and this function would correctly return EGL_NO_CONTEXT. 1089 1090 clearError(); 1091 1092 EGLContext ctx = getContext(); 1093 return ctx; 1094 } 1095 1096 EGLSurface eglGetCurrentSurface(EGLint readdraw) 1097 { 1098 // could be called before eglInitialize(), but we wouldn't have a context 1099 // then, and this function would correctly return EGL_NO_SURFACE. 1100 1101 clearError(); 1102 1103 EGLContext ctx = getContext(); 1104 if (ctx) { 1105 egl_context_t const * const c = get_context(ctx); 1106 if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE); 1107 switch (readdraw) { 1108 case EGL_READ: return c->read; 1109 case EGL_DRAW: return c->draw; 1110 default: return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE); 1111 } 1112 } 1113 return EGL_NO_SURFACE; 1114 } 1115 1116 EGLDisplay eglGetCurrentDisplay(void) 1117 { 1118 // could be called before eglInitialize(), but we wouldn't have a context 1119 // then, and this function would correctly return EGL_NO_DISPLAY. 1120 1121 clearError(); 1122 1123 EGLContext ctx = getContext(); 1124 if (ctx) { 1125 egl_context_t const * const c = get_context(ctx); 1126 if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE); 1127 return c->dpy; 1128 } 1129 return EGL_NO_DISPLAY; 1130 } 1131 1132 EGLBoolean eglWaitGL(void) 1133 { 1134 clearError(); 1135 1136 egl_connection_t* const cnx = &gEGLImpl; 1137 if (!cnx->dso) 1138 return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); 1139 1140 return cnx->egl.eglWaitGL(); 1141 } 1142 1143 EGLBoolean eglWaitNative(EGLint engine) 1144 { 1145 clearError(); 1146 1147 egl_connection_t* const cnx = &gEGLImpl; 1148 if (!cnx->dso) 1149 return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); 1150 1151 return cnx->egl.eglWaitNative(engine); 1152 } 1153 1154 EGLint eglGetError(void) 1155 { 1156 EGLint err = EGL_SUCCESS; 1157 egl_connection_t* const cnx = &gEGLImpl; 1158 if (cnx->dso) { 1159 err = cnx->egl.eglGetError(); 1160 } 1161 if (err == EGL_SUCCESS) { 1162 err = egl_tls_t::getError(); 1163 } 1164 return err; 1165 } 1166 1167 static __eglMustCastToProperFunctionPointerType findBuiltinWrapper( 1168 const char* procname) { 1169 const egl_connection_t* cnx = &gEGLImpl; 1170 void* proc = NULL; 1171 1172 proc = dlsym(cnx->libEgl, procname); 1173 if (proc) return (__eglMustCastToProperFunctionPointerType)proc; 1174 1175 proc = dlsym(cnx->libGles2, procname); 1176 if (proc) return (__eglMustCastToProperFunctionPointerType)proc; 1177 1178 proc = dlsym(cnx->libGles1, procname); 1179 if (proc) return (__eglMustCastToProperFunctionPointerType)proc; 1180 1181 return NULL; 1182 } 1183 1184 __eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname) 1185 { 1186 // eglGetProcAddress() could be the very first function called 1187 // in which case we must make sure we've initialized ourselves, this 1188 // happens the first time egl_get_display() is called. 1189 1190 clearError(); 1191 1192 if (egl_init_drivers() == EGL_FALSE) { 1193 setError(EGL_BAD_PARAMETER, NULL); 1194 return NULL; 1195 } 1196 1197 if (FILTER_EXTENSIONS(procname)) { 1198 return NULL; 1199 } 1200 1201 __eglMustCastToProperFunctionPointerType addr; 1202 addr = findProcAddress(procname, sExtensionMap, NELEM(sExtensionMap)); 1203 if (addr) return addr; 1204 1205 addr = findBuiltinWrapper(procname); 1206 if (addr) return addr; 1207 1208 // this protects accesses to sGLExtentionMap and sGLExtentionSlot 1209 pthread_mutex_lock(&sExtensionMapMutex); 1210 1211 /* 1212 * Since eglGetProcAddress() is not associated to anything, it needs 1213 * to return a function pointer that "works" regardless of what 1214 * the current context is. 1215 * 1216 * For this reason, we return a "forwarder", a small stub that takes 1217 * care of calling the function associated with the context 1218 * currently bound. 1219 * 1220 * We first look for extensions we've already resolved, if we're seeing 1221 * this extension for the first time, we go through all our 1222 * implementations and call eglGetProcAddress() and record the 1223 * result in the appropriate implementation hooks and return the 1224 * address of the forwarder corresponding to that hook set. 1225 * 1226 */ 1227 1228 const std::string name(procname); 1229 1230 auto& extentionMap = sGLExtentionMap; 1231 auto pos = extentionMap.find(name); 1232 addr = (pos != extentionMap.end()) ? pos->second : nullptr; 1233 const int slot = sGLExtentionSlot; 1234 1235 ALOGE_IF(slot >= MAX_NUMBER_OF_GL_EXTENSIONS, 1236 "no more slots for eglGetProcAddress(\"%s\")", 1237 procname); 1238 1239 if (!addr && (slot < MAX_NUMBER_OF_GL_EXTENSIONS)) { 1240 bool found = false; 1241 1242 egl_connection_t* const cnx = &gEGLImpl; 1243 if (cnx->dso && cnx->egl.eglGetProcAddress) { 1244 // Extensions are independent of the bound context 1245 addr = 1246 cnx->hooks[egl_connection_t::GLESv1_INDEX]->ext.extensions[slot] = 1247 cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[slot] = 1248 cnx->egl.eglGetProcAddress(procname); 1249 if (addr) found = true; 1250 } 1251 1252 if (found) { 1253 addr = gExtensionForwarders[slot]; 1254 extentionMap[name] = addr; 1255 sGLExtentionSlot++; 1256 } 1257 } 1258 1259 pthread_mutex_unlock(&sExtensionMapMutex); 1260 return addr; 1261 } 1262 1263 class FrameCompletionThread { 1264 public: 1265 1266 static void queueSync(EGLSyncKHR sync) { 1267 static FrameCompletionThread thread; 1268 1269 char name[64]; 1270 1271 std::lock_guard<std::mutex> lock(thread.mMutex); 1272 snprintf(name, sizeof(name), "kicked off frame %u", (unsigned int)thread.mFramesQueued); 1273 ATRACE_NAME(name); 1274 1275 thread.mQueue.push_back(sync); 1276 thread.mCondition.notify_one(); 1277 thread.mFramesQueued++; 1278 ATRACE_INT("GPU Frames Outstanding", int32_t(thread.mQueue.size())); 1279 } 1280 1281 private: 1282 1283 FrameCompletionThread() : mFramesQueued(0), mFramesCompleted(0) { 1284 std::thread thread(&FrameCompletionThread::loop, this); 1285 thread.detach(); 1286 } 1287 1288 #pragma clang diagnostic push 1289 #pragma clang diagnostic ignored "-Wmissing-noreturn" 1290 void loop() { 1291 while (true) { 1292 threadLoop(); 1293 } 1294 } 1295 #pragma clang diagnostic pop 1296 1297 void threadLoop() { 1298 EGLSyncKHR sync; 1299 uint32_t frameNum; 1300 { 1301 std::unique_lock<std::mutex> lock(mMutex); 1302 while (mQueue.empty()) { 1303 mCondition.wait(lock); 1304 } 1305 sync = mQueue[0]; 1306 frameNum = mFramesCompleted; 1307 } 1308 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY); 1309 { 1310 char name[64]; 1311 snprintf(name, sizeof(name), "waiting for frame %u", (unsigned int)frameNum); 1312 ATRACE_NAME(name); 1313 1314 EGLint result = eglClientWaitSyncKHR(dpy, sync, 0, EGL_FOREVER_KHR); 1315 if (result == EGL_FALSE) { 1316 ALOGE("FrameCompletion: error waiting for fence: %#x", eglGetError()); 1317 } else if (result == EGL_TIMEOUT_EXPIRED_KHR) { 1318 ALOGE("FrameCompletion: timeout waiting for fence"); 1319 } 1320 eglDestroySyncKHR(dpy, sync); 1321 } 1322 { 1323 std::lock_guard<std::mutex> lock(mMutex); 1324 mQueue.pop_front(); 1325 mFramesCompleted++; 1326 ATRACE_INT("GPU Frames Outstanding", int32_t(mQueue.size())); 1327 } 1328 } 1329 1330 uint32_t mFramesQueued; 1331 uint32_t mFramesCompleted; 1332 std::deque<EGLSyncKHR> mQueue; 1333 std::condition_variable mCondition; 1334 std::mutex mMutex; 1335 }; 1336 1337 EGLBoolean eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface draw, 1338 EGLint *rects, EGLint n_rects) 1339 { 1340 ATRACE_CALL(); 1341 clearError(); 1342 1343 const egl_display_ptr dp = validate_display(dpy); 1344 if (!dp) return EGL_FALSE; 1345 1346 SurfaceRef _s(dp.get(), draw); 1347 if (!_s.get()) 1348 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1349 1350 egl_surface_t const * const s = get_surface(draw); 1351 1352 if (CC_UNLIKELY(dp->traceGpuCompletion)) { 1353 EGLSyncKHR sync = eglCreateSyncKHR(dpy, EGL_SYNC_FENCE_KHR, NULL); 1354 if (sync != EGL_NO_SYNC_KHR) { 1355 FrameCompletionThread::queueSync(sync); 1356 } 1357 } 1358 1359 if (CC_UNLIKELY(dp->finishOnSwap)) { 1360 uint32_t pixel; 1361 egl_context_t * const c = get_context( egl_tls_t::getContext() ); 1362 if (c) { 1363 // glReadPixels() ensures that the frame is complete 1364 s->cnx->hooks[c->version]->gl.glReadPixels(0,0,1,1, 1365 GL_RGBA,GL_UNSIGNED_BYTE,&pixel); 1366 } 1367 } 1368 1369 if (n_rects == 0) { 1370 return s->cnx->egl.eglSwapBuffers(dp->disp.dpy, s->surface); 1371 } 1372 1373 std::vector<android_native_rect_t> androidRects((size_t)n_rects); 1374 for (int r = 0; r < n_rects; ++r) { 1375 int offset = r * 4; 1376 int x = rects[offset]; 1377 int y = rects[offset + 1]; 1378 int width = rects[offset + 2]; 1379 int height = rects[offset + 3]; 1380 android_native_rect_t androidRect; 1381 androidRect.left = x; 1382 androidRect.top = y + height; 1383 androidRect.right = x + width; 1384 androidRect.bottom = y; 1385 androidRects.push_back(androidRect); 1386 } 1387 native_window_set_surface_damage(s->getNativeWindow(), androidRects.data(), androidRects.size()); 1388 1389 if (s->cnx->egl.eglSwapBuffersWithDamageKHR) { 1390 return s->cnx->egl.eglSwapBuffersWithDamageKHR(dp->disp.dpy, s->surface, 1391 rects, n_rects); 1392 } else { 1393 return s->cnx->egl.eglSwapBuffers(dp->disp.dpy, s->surface); 1394 } 1395 } 1396 1397 EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) 1398 { 1399 return eglSwapBuffersWithDamageKHR(dpy, surface, NULL, 0); 1400 } 1401 1402 EGLBoolean eglCopyBuffers( EGLDisplay dpy, EGLSurface surface, 1403 NativePixmapType target) 1404 { 1405 clearError(); 1406 1407 const egl_display_ptr dp = validate_display(dpy); 1408 if (!dp) return EGL_FALSE; 1409 1410 SurfaceRef _s(dp.get(), surface); 1411 if (!_s.get()) 1412 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1413 1414 egl_surface_t const * const s = get_surface(surface); 1415 return s->cnx->egl.eglCopyBuffers(dp->disp.dpy, s->surface, target); 1416 } 1417 1418 const char* eglQueryString(EGLDisplay dpy, EGLint name) 1419 { 1420 clearError(); 1421 1422 // Generate an error quietly when client extensions (as defined by 1423 // EGL_EXT_client_extensions) are queried. We do not want to rely on 1424 // validate_display to generate the error as validate_display would log 1425 // the error, which can be misleading. 1426 // 1427 // If we want to support EGL_EXT_client_extensions later, we can return 1428 // the client extension string here instead. 1429 if (dpy == EGL_NO_DISPLAY && name == EGL_EXTENSIONS) 1430 return setErrorQuiet(EGL_BAD_DISPLAY, (const char*)0); 1431 1432 const egl_display_ptr dp = validate_display(dpy); 1433 if (!dp) return (const char *) NULL; 1434 1435 switch (name) { 1436 case EGL_VENDOR: 1437 return dp->getVendorString(); 1438 case EGL_VERSION: 1439 return dp->getVersionString(); 1440 case EGL_EXTENSIONS: 1441 return dp->getExtensionString(); 1442 case EGL_CLIENT_APIS: 1443 return dp->getClientApiString(); 1444 default: 1445 break; 1446 } 1447 return setError(EGL_BAD_PARAMETER, (const char *)0); 1448 } 1449 1450 extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name) 1451 { 1452 clearError(); 1453 1454 const egl_display_ptr dp = validate_display(dpy); 1455 if (!dp) return (const char *) NULL; 1456 1457 switch (name) { 1458 case EGL_VENDOR: 1459 return dp->disp.queryString.vendor; 1460 case EGL_VERSION: 1461 return dp->disp.queryString.version; 1462 case EGL_EXTENSIONS: 1463 return dp->disp.queryString.extensions; 1464 case EGL_CLIENT_APIS: 1465 return dp->disp.queryString.clientApi; 1466 default: 1467 break; 1468 } 1469 return setError(EGL_BAD_PARAMETER, (const char *)0); 1470 } 1471 1472 // ---------------------------------------------------------------------------- 1473 // EGL 1.1 1474 // ---------------------------------------------------------------------------- 1475 1476 EGLBoolean eglSurfaceAttrib( 1477 EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) 1478 { 1479 clearError(); 1480 1481 const egl_display_ptr dp = validate_display(dpy); 1482 if (!dp) return EGL_FALSE; 1483 1484 SurfaceRef _s(dp.get(), surface); 1485 if (!_s.get()) 1486 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1487 1488 egl_surface_t * const s = get_surface(surface); 1489 1490 if (attribute == EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID) { 1491 if (!s->getNativeWindow()) { 1492 setError(EGL_BAD_SURFACE, EGL_FALSE); 1493 } 1494 int err = native_window_set_auto_refresh(s->getNativeWindow(), value != 0); 1495 return (err == 0) ? EGL_TRUE : setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1496 } 1497 1498 if (attribute == EGL_TIMESTAMPS_ANDROID) { 1499 if (!s->getNativeWindow()) { 1500 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1501 } 1502 int err = native_window_enable_frame_timestamps(s->getNativeWindow(), value != 0); 1503 return (err == 0) ? EGL_TRUE : setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1504 } 1505 1506 if (s->cnx->egl.eglSurfaceAttrib) { 1507 return s->cnx->egl.eglSurfaceAttrib( 1508 dp->disp.dpy, s->surface, attribute, value); 1509 } 1510 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1511 } 1512 1513 EGLBoolean eglBindTexImage( 1514 EGLDisplay dpy, EGLSurface surface, EGLint buffer) 1515 { 1516 clearError(); 1517 1518 const egl_display_ptr dp = validate_display(dpy); 1519 if (!dp) return EGL_FALSE; 1520 1521 SurfaceRef _s(dp.get(), surface); 1522 if (!_s.get()) 1523 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1524 1525 egl_surface_t const * const s = get_surface(surface); 1526 if (s->cnx->egl.eglBindTexImage) { 1527 return s->cnx->egl.eglBindTexImage( 1528 dp->disp.dpy, s->surface, buffer); 1529 } 1530 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1531 } 1532 1533 EGLBoolean eglReleaseTexImage( 1534 EGLDisplay dpy, EGLSurface surface, EGLint buffer) 1535 { 1536 clearError(); 1537 1538 const egl_display_ptr dp = validate_display(dpy); 1539 if (!dp) return EGL_FALSE; 1540 1541 SurfaceRef _s(dp.get(), surface); 1542 if (!_s.get()) 1543 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1544 1545 egl_surface_t const * const s = get_surface(surface); 1546 if (s->cnx->egl.eglReleaseTexImage) { 1547 return s->cnx->egl.eglReleaseTexImage( 1548 dp->disp.dpy, s->surface, buffer); 1549 } 1550 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1551 } 1552 1553 EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) 1554 { 1555 clearError(); 1556 1557 const egl_display_ptr dp = validate_display(dpy); 1558 if (!dp) return EGL_FALSE; 1559 1560 EGLBoolean res = EGL_TRUE; 1561 egl_connection_t* const cnx = &gEGLImpl; 1562 if (cnx->dso && cnx->egl.eglSwapInterval) { 1563 res = cnx->egl.eglSwapInterval(dp->disp.dpy, interval); 1564 } 1565 1566 return res; 1567 } 1568 1569 1570 // ---------------------------------------------------------------------------- 1571 // EGL 1.2 1572 // ---------------------------------------------------------------------------- 1573 1574 EGLBoolean eglWaitClient(void) 1575 { 1576 clearError(); 1577 1578 egl_connection_t* const cnx = &gEGLImpl; 1579 if (!cnx->dso) 1580 return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); 1581 1582 EGLBoolean res; 1583 if (cnx->egl.eglWaitClient) { 1584 res = cnx->egl.eglWaitClient(); 1585 } else { 1586 res = cnx->egl.eglWaitGL(); 1587 } 1588 return res; 1589 } 1590 1591 EGLBoolean eglBindAPI(EGLenum api) 1592 { 1593 clearError(); 1594 1595 if (egl_init_drivers() == EGL_FALSE) { 1596 return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); 1597 } 1598 1599 // bind this API on all EGLs 1600 EGLBoolean res = EGL_TRUE; 1601 egl_connection_t* const cnx = &gEGLImpl; 1602 if (cnx->dso && cnx->egl.eglBindAPI) { 1603 res = cnx->egl.eglBindAPI(api); 1604 } 1605 return res; 1606 } 1607 1608 EGLenum eglQueryAPI(void) 1609 { 1610 clearError(); 1611 1612 if (egl_init_drivers() == EGL_FALSE) { 1613 return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); 1614 } 1615 1616 egl_connection_t* const cnx = &gEGLImpl; 1617 if (cnx->dso && cnx->egl.eglQueryAPI) { 1618 return cnx->egl.eglQueryAPI(); 1619 } 1620 1621 // or, it can only be OpenGL ES 1622 return EGL_OPENGL_ES_API; 1623 } 1624 1625 EGLBoolean eglReleaseThread(void) 1626 { 1627 clearError(); 1628 1629 egl_connection_t* const cnx = &gEGLImpl; 1630 if (cnx->dso && cnx->egl.eglReleaseThread) { 1631 cnx->egl.eglReleaseThread(); 1632 } 1633 1634 // If there is context bound to the thread, release it 1635 egl_display_t::loseCurrent(get_context(getContext())); 1636 1637 egl_tls_t::clearTLS(); 1638 return EGL_TRUE; 1639 } 1640 1641 EGLSurface eglCreatePbufferFromClientBuffer( 1642 EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, 1643 EGLConfig config, const EGLint *attrib_list) 1644 { 1645 clearError(); 1646 1647 egl_connection_t* cnx = NULL; 1648 const egl_display_ptr dp = validate_display_connection(dpy, cnx); 1649 if (!dp) return EGL_FALSE; 1650 if (cnx->egl.eglCreatePbufferFromClientBuffer) { 1651 return cnx->egl.eglCreatePbufferFromClientBuffer( 1652 dp->disp.dpy, buftype, buffer, config, attrib_list); 1653 } 1654 return setError(EGL_BAD_CONFIG, EGL_NO_SURFACE); 1655 } 1656 1657 // ---------------------------------------------------------------------------- 1658 // EGL_EGLEXT_VERSION 3 1659 // ---------------------------------------------------------------------------- 1660 1661 EGLBoolean eglLockSurfaceKHR(EGLDisplay dpy, EGLSurface surface, 1662 const EGLint *attrib_list) 1663 { 1664 clearError(); 1665 1666 const egl_display_ptr dp = validate_display(dpy); 1667 if (!dp) return EGL_FALSE; 1668 1669 SurfaceRef _s(dp.get(), surface); 1670 if (!_s.get()) 1671 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1672 1673 egl_surface_t const * const s = get_surface(surface); 1674 if (s->cnx->egl.eglLockSurfaceKHR) { 1675 return s->cnx->egl.eglLockSurfaceKHR( 1676 dp->disp.dpy, s->surface, attrib_list); 1677 } 1678 return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); 1679 } 1680 1681 EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface) 1682 { 1683 clearError(); 1684 1685 const egl_display_ptr dp = validate_display(dpy); 1686 if (!dp) return EGL_FALSE; 1687 1688 SurfaceRef _s(dp.get(), surface); 1689 if (!_s.get()) 1690 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 1691 1692 egl_surface_t const * const s = get_surface(surface); 1693 if (s->cnx->egl.eglUnlockSurfaceKHR) { 1694 return s->cnx->egl.eglUnlockSurfaceKHR(dp->disp.dpy, s->surface); 1695 } 1696 return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); 1697 } 1698 1699 EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, 1700 EGLClientBuffer buffer, const EGLint *attrib_list) 1701 { 1702 clearError(); 1703 1704 const egl_display_ptr dp = validate_display(dpy); 1705 if (!dp) return EGL_NO_IMAGE_KHR; 1706 1707 ContextRef _c(dp.get(), ctx); 1708 egl_context_t * const c = _c.get(); 1709 1710 EGLImageKHR result = EGL_NO_IMAGE_KHR; 1711 egl_connection_t* const cnx = &gEGLImpl; 1712 if (cnx->dso && cnx->egl.eglCreateImageKHR) { 1713 result = cnx->egl.eglCreateImageKHR( 1714 dp->disp.dpy, 1715 c ? c->context : EGL_NO_CONTEXT, 1716 target, buffer, attrib_list); 1717 } 1718 return result; 1719 } 1720 1721 EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img) 1722 { 1723 clearError(); 1724 1725 const egl_display_ptr dp = validate_display(dpy); 1726 if (!dp) return EGL_FALSE; 1727 1728 EGLBoolean result = EGL_FALSE; 1729 egl_connection_t* const cnx = &gEGLImpl; 1730 if (cnx->dso && cnx->egl.eglDestroyImageKHR) { 1731 result = cnx->egl.eglDestroyImageKHR(dp->disp.dpy, img); 1732 } 1733 return result; 1734 } 1735 1736 // ---------------------------------------------------------------------------- 1737 // EGL_EGLEXT_VERSION 5 1738 // ---------------------------------------------------------------------------- 1739 1740 1741 EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list) 1742 { 1743 clearError(); 1744 1745 const egl_display_ptr dp = validate_display(dpy); 1746 if (!dp) return EGL_NO_SYNC_KHR; 1747 1748 EGLSyncKHR result = EGL_NO_SYNC_KHR; 1749 egl_connection_t* const cnx = &gEGLImpl; 1750 if (cnx->dso && cnx->egl.eglCreateSyncKHR) { 1751 result = cnx->egl.eglCreateSyncKHR(dp->disp.dpy, type, attrib_list); 1752 } 1753 return result; 1754 } 1755 1756 EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) 1757 { 1758 clearError(); 1759 1760 const egl_display_ptr dp = validate_display(dpy); 1761 if (!dp) return EGL_FALSE; 1762 1763 EGLBoolean result = EGL_FALSE; 1764 egl_connection_t* const cnx = &gEGLImpl; 1765 if (cnx->dso && cnx->egl.eglDestroySyncKHR) { 1766 result = cnx->egl.eglDestroySyncKHR(dp->disp.dpy, sync); 1767 } 1768 return result; 1769 } 1770 1771 EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) { 1772 clearError(); 1773 1774 const egl_display_ptr dp = validate_display(dpy); 1775 if (!dp) return EGL_FALSE; 1776 1777 EGLBoolean result = EGL_FALSE; 1778 egl_connection_t* const cnx = &gEGLImpl; 1779 if (cnx->dso && cnx->egl.eglSignalSyncKHR) { 1780 result = cnx->egl.eglSignalSyncKHR( 1781 dp->disp.dpy, sync, mode); 1782 } 1783 return result; 1784 } 1785 1786 EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, 1787 EGLint flags, EGLTimeKHR timeout) 1788 { 1789 clearError(); 1790 1791 const egl_display_ptr dp = validate_display(dpy); 1792 if (!dp) return EGL_FALSE; 1793 1794 EGLint result = EGL_FALSE; 1795 egl_connection_t* const cnx = &gEGLImpl; 1796 if (cnx->dso && cnx->egl.eglClientWaitSyncKHR) { 1797 result = cnx->egl.eglClientWaitSyncKHR( 1798 dp->disp.dpy, sync, flags, timeout); 1799 } 1800 return result; 1801 } 1802 1803 EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, 1804 EGLint attribute, EGLint *value) 1805 { 1806 clearError(); 1807 1808 const egl_display_ptr dp = validate_display(dpy); 1809 if (!dp) return EGL_FALSE; 1810 1811 EGLBoolean result = EGL_FALSE; 1812 egl_connection_t* const cnx = &gEGLImpl; 1813 if (cnx->dso && cnx->egl.eglGetSyncAttribKHR) { 1814 result = cnx->egl.eglGetSyncAttribKHR( 1815 dp->disp.dpy, sync, attribute, value); 1816 } 1817 return result; 1818 } 1819 1820 EGLStreamKHR eglCreateStreamKHR(EGLDisplay dpy, const EGLint *attrib_list) 1821 { 1822 clearError(); 1823 1824 const egl_display_ptr dp = validate_display(dpy); 1825 if (!dp) return EGL_NO_STREAM_KHR; 1826 1827 EGLStreamKHR result = EGL_NO_STREAM_KHR; 1828 egl_connection_t* const cnx = &gEGLImpl; 1829 if (cnx->dso && cnx->egl.eglCreateStreamKHR) { 1830 result = cnx->egl.eglCreateStreamKHR( 1831 dp->disp.dpy, attrib_list); 1832 } 1833 return result; 1834 } 1835 1836 EGLBoolean eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream) 1837 { 1838 clearError(); 1839 1840 const egl_display_ptr dp = validate_display(dpy); 1841 if (!dp) return EGL_FALSE; 1842 1843 EGLBoolean result = EGL_FALSE; 1844 egl_connection_t* const cnx = &gEGLImpl; 1845 if (cnx->dso && cnx->egl.eglDestroyStreamKHR) { 1846 result = cnx->egl.eglDestroyStreamKHR( 1847 dp->disp.dpy, stream); 1848 } 1849 return result; 1850 } 1851 1852 EGLBoolean eglStreamAttribKHR(EGLDisplay dpy, EGLStreamKHR stream, 1853 EGLenum attribute, EGLint value) 1854 { 1855 clearError(); 1856 1857 const egl_display_ptr dp = validate_display(dpy); 1858 if (!dp) return EGL_FALSE; 1859 1860 EGLBoolean result = EGL_FALSE; 1861 egl_connection_t* const cnx = &gEGLImpl; 1862 if (cnx->dso && cnx->egl.eglStreamAttribKHR) { 1863 result = cnx->egl.eglStreamAttribKHR( 1864 dp->disp.dpy, stream, attribute, value); 1865 } 1866 return result; 1867 } 1868 1869 EGLBoolean eglQueryStreamKHR(EGLDisplay dpy, EGLStreamKHR stream, 1870 EGLenum attribute, EGLint *value) 1871 { 1872 clearError(); 1873 1874 const egl_display_ptr dp = validate_display(dpy); 1875 if (!dp) return EGL_FALSE; 1876 1877 EGLBoolean result = EGL_FALSE; 1878 egl_connection_t* const cnx = &gEGLImpl; 1879 if (cnx->dso && cnx->egl.eglQueryStreamKHR) { 1880 result = cnx->egl.eglQueryStreamKHR( 1881 dp->disp.dpy, stream, attribute, value); 1882 } 1883 return result; 1884 } 1885 1886 EGLBoolean eglQueryStreamu64KHR(EGLDisplay dpy, EGLStreamKHR stream, 1887 EGLenum attribute, EGLuint64KHR *value) 1888 { 1889 clearError(); 1890 1891 const egl_display_ptr dp = validate_display(dpy); 1892 if (!dp) return EGL_FALSE; 1893 1894 EGLBoolean result = EGL_FALSE; 1895 egl_connection_t* const cnx = &gEGLImpl; 1896 if (cnx->dso && cnx->egl.eglQueryStreamu64KHR) { 1897 result = cnx->egl.eglQueryStreamu64KHR( 1898 dp->disp.dpy, stream, attribute, value); 1899 } 1900 return result; 1901 } 1902 1903 EGLBoolean eglQueryStreamTimeKHR(EGLDisplay dpy, EGLStreamKHR stream, 1904 EGLenum attribute, EGLTimeKHR *value) 1905 { 1906 clearError(); 1907 1908 const egl_display_ptr dp = validate_display(dpy); 1909 if (!dp) return EGL_FALSE; 1910 1911 EGLBoolean result = EGL_FALSE; 1912 egl_connection_t* const cnx = &gEGLImpl; 1913 if (cnx->dso && cnx->egl.eglQueryStreamTimeKHR) { 1914 result = cnx->egl.eglQueryStreamTimeKHR( 1915 dp->disp.dpy, stream, attribute, value); 1916 } 1917 return result; 1918 } 1919 1920 EGLSurface eglCreateStreamProducerSurfaceKHR(EGLDisplay dpy, EGLConfig config, 1921 EGLStreamKHR stream, const EGLint *attrib_list) 1922 { 1923 clearError(); 1924 1925 egl_display_ptr dp = validate_display(dpy); 1926 if (!dp) return EGL_NO_SURFACE; 1927 1928 EGLint colorSpace = EGL_GL_COLORSPACE_LINEAR_KHR; 1929 android_dataspace dataSpace = HAL_DATASPACE_UNKNOWN; 1930 // TODO: Probably need to update EGL_KHR_stream_producer_eglsurface to 1931 // indicate support for EGL_GL_COLORSPACE_KHR. 1932 // now select a corresponding sRGB format if needed 1933 if (!getColorSpaceAttribute(dp, attrib_list, colorSpace, dataSpace)) { 1934 ALOGE("error invalid colorspace: %d", colorSpace); 1935 return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); 1936 } 1937 1938 egl_connection_t* const cnx = &gEGLImpl; 1939 if (cnx->dso && cnx->egl.eglCreateStreamProducerSurfaceKHR) { 1940 EGLSurface surface = cnx->egl.eglCreateStreamProducerSurfaceKHR( 1941 dp->disp.dpy, config, stream, attrib_list); 1942 if (surface != EGL_NO_SURFACE) { 1943 egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL, surface, colorSpace, cnx); 1944 return s; 1945 } 1946 } 1947 return EGL_NO_SURFACE; 1948 } 1949 1950 EGLBoolean eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy, 1951 EGLStreamKHR stream) 1952 { 1953 clearError(); 1954 1955 const egl_display_ptr dp = validate_display(dpy); 1956 if (!dp) return EGL_FALSE; 1957 1958 EGLBoolean result = EGL_FALSE; 1959 egl_connection_t* const cnx = &gEGLImpl; 1960 if (cnx->dso && cnx->egl.eglStreamConsumerGLTextureExternalKHR) { 1961 result = cnx->egl.eglStreamConsumerGLTextureExternalKHR( 1962 dp->disp.dpy, stream); 1963 } 1964 return result; 1965 } 1966 1967 EGLBoolean eglStreamConsumerAcquireKHR(EGLDisplay dpy, 1968 EGLStreamKHR stream) 1969 { 1970 clearError(); 1971 1972 const egl_display_ptr dp = validate_display(dpy); 1973 if (!dp) return EGL_FALSE; 1974 1975 EGLBoolean result = EGL_FALSE; 1976 egl_connection_t* const cnx = &gEGLImpl; 1977 if (cnx->dso && cnx->egl.eglStreamConsumerAcquireKHR) { 1978 result = cnx->egl.eglStreamConsumerAcquireKHR( 1979 dp->disp.dpy, stream); 1980 } 1981 return result; 1982 } 1983 1984 EGLBoolean eglStreamConsumerReleaseKHR(EGLDisplay dpy, 1985 EGLStreamKHR stream) 1986 { 1987 clearError(); 1988 1989 const egl_display_ptr dp = validate_display(dpy); 1990 if (!dp) return EGL_FALSE; 1991 1992 EGLBoolean result = EGL_FALSE; 1993 egl_connection_t* const cnx = &gEGLImpl; 1994 if (cnx->dso && cnx->egl.eglStreamConsumerReleaseKHR) { 1995 result = cnx->egl.eglStreamConsumerReleaseKHR( 1996 dp->disp.dpy, stream); 1997 } 1998 return result; 1999 } 2000 2001 EGLNativeFileDescriptorKHR eglGetStreamFileDescriptorKHR( 2002 EGLDisplay dpy, EGLStreamKHR stream) 2003 { 2004 clearError(); 2005 2006 const egl_display_ptr dp = validate_display(dpy); 2007 if (!dp) return EGL_NO_FILE_DESCRIPTOR_KHR; 2008 2009 EGLNativeFileDescriptorKHR result = EGL_NO_FILE_DESCRIPTOR_KHR; 2010 egl_connection_t* const cnx = &gEGLImpl; 2011 if (cnx->dso && cnx->egl.eglGetStreamFileDescriptorKHR) { 2012 result = cnx->egl.eglGetStreamFileDescriptorKHR( 2013 dp->disp.dpy, stream); 2014 } 2015 return result; 2016 } 2017 2018 EGLStreamKHR eglCreateStreamFromFileDescriptorKHR( 2019 EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor) 2020 { 2021 clearError(); 2022 2023 const egl_display_ptr dp = validate_display(dpy); 2024 if (!dp) return EGL_NO_STREAM_KHR; 2025 2026 EGLStreamKHR result = EGL_NO_STREAM_KHR; 2027 egl_connection_t* const cnx = &gEGLImpl; 2028 if (cnx->dso && cnx->egl.eglCreateStreamFromFileDescriptorKHR) { 2029 result = cnx->egl.eglCreateStreamFromFileDescriptorKHR( 2030 dp->disp.dpy, file_descriptor); 2031 } 2032 return result; 2033 } 2034 2035 // ---------------------------------------------------------------------------- 2036 // EGL_EGLEXT_VERSION 15 2037 // ---------------------------------------------------------------------------- 2038 2039 EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) { 2040 clearError(); 2041 const egl_display_ptr dp = validate_display(dpy); 2042 if (!dp) return EGL_FALSE; 2043 EGLint result = EGL_FALSE; 2044 egl_connection_t* const cnx = &gEGLImpl; 2045 if (cnx->dso && cnx->egl.eglWaitSyncKHR) { 2046 result = cnx->egl.eglWaitSyncKHR(dp->disp.dpy, sync, flags); 2047 } 2048 return result; 2049 } 2050 2051 // ---------------------------------------------------------------------------- 2052 // ANDROID extensions 2053 // ---------------------------------------------------------------------------- 2054 2055 EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync) 2056 { 2057 clearError(); 2058 2059 const egl_display_ptr dp = validate_display(dpy); 2060 if (!dp) return EGL_NO_NATIVE_FENCE_FD_ANDROID; 2061 2062 EGLint result = EGL_NO_NATIVE_FENCE_FD_ANDROID; 2063 egl_connection_t* const cnx = &gEGLImpl; 2064 if (cnx->dso && cnx->egl.eglDupNativeFenceFDANDROID) { 2065 result = cnx->egl.eglDupNativeFenceFDANDROID(dp->disp.dpy, sync); 2066 } 2067 return result; 2068 } 2069 2070 EGLBoolean eglPresentationTimeANDROID(EGLDisplay dpy, EGLSurface surface, 2071 EGLnsecsANDROID time) 2072 { 2073 clearError(); 2074 2075 const egl_display_ptr dp = validate_display(dpy); 2076 if (!dp) { 2077 return EGL_FALSE; 2078 } 2079 2080 SurfaceRef _s(dp.get(), surface); 2081 if (!_s.get()) { 2082 setError(EGL_BAD_SURFACE, EGL_FALSE); 2083 return EGL_FALSE; 2084 } 2085 2086 egl_surface_t const * const s = get_surface(surface); 2087 native_window_set_buffers_timestamp(s->getNativeWindow(), time); 2088 2089 return EGL_TRUE; 2090 } 2091 2092 EGLClientBuffer eglGetNativeClientBufferANDROID(const AHardwareBuffer *buffer) { 2093 clearError(); 2094 // AHardwareBuffer_to_ANativeWindowBuffer is a platform-only symbol and thus 2095 // this function cannot be implemented when this libEGL is built for 2096 // vendors. 2097 #ifndef __ANDROID_VNDK__ 2098 if (!buffer) return setError(EGL_BAD_PARAMETER, (EGLClientBuffer)0); 2099 return const_cast<ANativeWindowBuffer *>(AHardwareBuffer_to_ANativeWindowBuffer(buffer)); 2100 #else 2101 return setError(EGL_BAD_PARAMETER, (EGLClientBuffer)0); 2102 #endif 2103 } 2104 2105 // ---------------------------------------------------------------------------- 2106 // NVIDIA extensions 2107 // ---------------------------------------------------------------------------- 2108 EGLuint64NV eglGetSystemTimeFrequencyNV() 2109 { 2110 clearError(); 2111 2112 if (egl_init_drivers() == EGL_FALSE) { 2113 return setError(EGL_BAD_PARAMETER, (EGLuint64NV)EGL_FALSE); 2114 } 2115 2116 EGLuint64NV ret = 0; 2117 egl_connection_t* const cnx = &gEGLImpl; 2118 2119 if (cnx->dso && cnx->egl.eglGetSystemTimeFrequencyNV) { 2120 return cnx->egl.eglGetSystemTimeFrequencyNV(); 2121 } 2122 2123 return setErrorQuiet(EGL_BAD_DISPLAY, (EGLuint64NV)0); 2124 } 2125 2126 EGLuint64NV eglGetSystemTimeNV() 2127 { 2128 clearError(); 2129 2130 if (egl_init_drivers() == EGL_FALSE) { 2131 return setError(EGL_BAD_PARAMETER, (EGLuint64NV)EGL_FALSE); 2132 } 2133 2134 EGLuint64NV ret = 0; 2135 egl_connection_t* const cnx = &gEGLImpl; 2136 2137 if (cnx->dso && cnx->egl.eglGetSystemTimeNV) { 2138 return cnx->egl.eglGetSystemTimeNV(); 2139 } 2140 2141 return setErrorQuiet(EGL_BAD_DISPLAY, (EGLuint64NV)0); 2142 } 2143 2144 // ---------------------------------------------------------------------------- 2145 // Partial update extension 2146 // ---------------------------------------------------------------------------- 2147 EGLBoolean eglSetDamageRegionKHR(EGLDisplay dpy, EGLSurface surface, 2148 EGLint *rects, EGLint n_rects) 2149 { 2150 clearError(); 2151 2152 const egl_display_ptr dp = validate_display(dpy); 2153 if (!dp) { 2154 setError(EGL_BAD_DISPLAY, EGL_FALSE); 2155 return EGL_FALSE; 2156 } 2157 2158 SurfaceRef _s(dp.get(), surface); 2159 if (!_s.get()) { 2160 setError(EGL_BAD_SURFACE, EGL_FALSE); 2161 return EGL_FALSE; 2162 } 2163 2164 egl_surface_t const * const s = get_surface(surface); 2165 if (s->cnx->egl.eglSetDamageRegionKHR) { 2166 return s->cnx->egl.eglSetDamageRegionKHR(dp->disp.dpy, s->surface, 2167 rects, n_rects); 2168 } 2169 2170 return EGL_FALSE; 2171 } 2172 2173 EGLBoolean eglGetNextFrameIdANDROID(EGLDisplay dpy, EGLSurface surface, 2174 EGLuint64KHR *frameId) { 2175 clearError(); 2176 2177 const egl_display_ptr dp = validate_display(dpy); 2178 if (!dp) { 2179 return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); 2180 } 2181 2182 SurfaceRef _s(dp.get(), surface); 2183 if (!_s.get()) { 2184 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 2185 } 2186 2187 egl_surface_t const * const s = get_surface(surface); 2188 2189 if (!s->getNativeWindow()) { 2190 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 2191 } 2192 2193 uint64_t nextFrameId = 0; 2194 int ret = native_window_get_next_frame_id(s->getNativeWindow(), &nextFrameId); 2195 2196 if (ret != 0) { 2197 // This should not happen. Return an error that is not in the spec 2198 // so it's obvious something is very wrong. 2199 ALOGE("eglGetNextFrameId: Unexpected error."); 2200 return setError(EGL_NOT_INITIALIZED, (EGLBoolean)EGL_FALSE); 2201 } 2202 2203 *frameId = nextFrameId; 2204 return EGL_TRUE; 2205 } 2206 2207 EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy, EGLSurface surface, 2208 EGLint numTimestamps, const EGLint *names, EGLnsecsANDROID *values) 2209 { 2210 clearError(); 2211 2212 const egl_display_ptr dp = validate_display(dpy); 2213 if (!dp) { 2214 return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); 2215 } 2216 2217 SurfaceRef _s(dp.get(), surface); 2218 if (!_s.get()) { 2219 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 2220 } 2221 2222 egl_surface_t const * const s = get_surface(surface); 2223 2224 if (!s->getNativeWindow()) { 2225 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 2226 } 2227 2228 nsecs_t* compositeDeadline = nullptr; 2229 nsecs_t* compositeInterval = nullptr; 2230 nsecs_t* compositeToPresentLatency = nullptr; 2231 2232 for (int i = 0; i < numTimestamps; i++) { 2233 switch (names[i]) { 2234 case EGL_COMPOSITE_DEADLINE_ANDROID: 2235 compositeDeadline = &values[i]; 2236 break; 2237 case EGL_COMPOSITE_INTERVAL_ANDROID: 2238 compositeInterval = &values[i]; 2239 break; 2240 case EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID: 2241 compositeToPresentLatency = &values[i]; 2242 break; 2243 default: 2244 return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); 2245 } 2246 } 2247 2248 int ret = native_window_get_compositor_timing(s->getNativeWindow(), 2249 compositeDeadline, compositeInterval, compositeToPresentLatency); 2250 2251 switch (ret) { 2252 case 0: 2253 return EGL_TRUE; 2254 case -ENOSYS: 2255 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 2256 default: 2257 // This should not happen. Return an error that is not in the spec 2258 // so it's obvious something is very wrong. 2259 ALOGE("eglGetCompositorTiming: Unexpected error."); 2260 return setError(EGL_NOT_INITIALIZED, (EGLBoolean)EGL_FALSE); 2261 } 2262 } 2263 2264 EGLBoolean eglGetCompositorTimingSupportedANDROID( 2265 EGLDisplay dpy, EGLSurface surface, EGLint name) 2266 { 2267 clearError(); 2268 2269 const egl_display_ptr dp = validate_display(dpy); 2270 if (!dp) { 2271 return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); 2272 } 2273 2274 SurfaceRef _s(dp.get(), surface); 2275 if (!_s.get()) { 2276 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 2277 } 2278 2279 egl_surface_t const * const s = get_surface(surface); 2280 2281 ANativeWindow* window = s->getNativeWindow(); 2282 if (!window) { 2283 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 2284 } 2285 2286 switch (name) { 2287 case EGL_COMPOSITE_DEADLINE_ANDROID: 2288 case EGL_COMPOSITE_INTERVAL_ANDROID: 2289 case EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID: 2290 return EGL_TRUE; 2291 default: 2292 return EGL_FALSE; 2293 } 2294 } 2295 2296 EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface, 2297 EGLuint64KHR frameId, EGLint numTimestamps, const EGLint *timestamps, 2298 EGLnsecsANDROID *values) 2299 { 2300 clearError(); 2301 2302 const egl_display_ptr dp = validate_display(dpy); 2303 if (!dp) { 2304 return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); 2305 } 2306 2307 SurfaceRef _s(dp.get(), surface); 2308 if (!_s.get()) { 2309 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 2310 } 2311 2312 egl_surface_t const * const s = get_surface(surface); 2313 2314 if (!s->getNativeWindow()) { 2315 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 2316 } 2317 2318 nsecs_t* requestedPresentTime = nullptr; 2319 nsecs_t* acquireTime = nullptr; 2320 nsecs_t* latchTime = nullptr; 2321 nsecs_t* firstRefreshStartTime = nullptr; 2322 nsecs_t* gpuCompositionDoneTime = nullptr; 2323 nsecs_t* lastRefreshStartTime = nullptr; 2324 nsecs_t* displayPresentTime = nullptr; 2325 nsecs_t* dequeueReadyTime = nullptr; 2326 nsecs_t* releaseTime = nullptr; 2327 2328 for (int i = 0; i < numTimestamps; i++) { 2329 switch (timestamps[i]) { 2330 case EGL_REQUESTED_PRESENT_TIME_ANDROID: 2331 requestedPresentTime = &values[i]; 2332 break; 2333 case EGL_RENDERING_COMPLETE_TIME_ANDROID: 2334 acquireTime = &values[i]; 2335 break; 2336 case EGL_COMPOSITION_LATCH_TIME_ANDROID: 2337 latchTime = &values[i]; 2338 break; 2339 case EGL_FIRST_COMPOSITION_START_TIME_ANDROID: 2340 firstRefreshStartTime = &values[i]; 2341 break; 2342 case EGL_LAST_COMPOSITION_START_TIME_ANDROID: 2343 lastRefreshStartTime = &values[i]; 2344 break; 2345 case EGL_FIRST_COMPOSITION_GPU_FINISHED_TIME_ANDROID: 2346 gpuCompositionDoneTime = &values[i]; 2347 break; 2348 case EGL_DISPLAY_PRESENT_TIME_ANDROID: 2349 displayPresentTime = &values[i]; 2350 break; 2351 case EGL_DEQUEUE_READY_TIME_ANDROID: 2352 dequeueReadyTime = &values[i]; 2353 break; 2354 case EGL_READS_DONE_TIME_ANDROID: 2355 releaseTime = &values[i]; 2356 break; 2357 default: 2358 return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); 2359 } 2360 } 2361 2362 int ret = native_window_get_frame_timestamps(s->getNativeWindow(), frameId, 2363 requestedPresentTime, acquireTime, latchTime, firstRefreshStartTime, 2364 lastRefreshStartTime, gpuCompositionDoneTime, displayPresentTime, 2365 dequeueReadyTime, releaseTime); 2366 2367 switch (ret) { 2368 case 0: 2369 return EGL_TRUE; 2370 case -ENOENT: 2371 return setError(EGL_BAD_ACCESS, (EGLBoolean)EGL_FALSE); 2372 case -ENOSYS: 2373 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 2374 case -EINVAL: 2375 return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); 2376 default: 2377 // This should not happen. Return an error that is not in the spec 2378 // so it's obvious something is very wrong. 2379 ALOGE("eglGetFrameTimestamps: Unexpected error."); 2380 return setError(EGL_NOT_INITIALIZED, (EGLBoolean)EGL_FALSE); 2381 } 2382 } 2383 2384 EGLBoolean eglGetFrameTimestampSupportedANDROID( 2385 EGLDisplay dpy, EGLSurface surface, EGLint timestamp) 2386 { 2387 clearError(); 2388 2389 const egl_display_ptr dp = validate_display(dpy); 2390 if (!dp) { 2391 return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); 2392 } 2393 2394 SurfaceRef _s(dp.get(), surface); 2395 if (!_s.get()) { 2396 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 2397 } 2398 2399 egl_surface_t const * const s = get_surface(surface); 2400 2401 ANativeWindow* window = s->getNativeWindow(); 2402 if (!window) { 2403 return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); 2404 } 2405 2406 switch (timestamp) { 2407 case EGL_COMPOSITE_DEADLINE_ANDROID: 2408 case EGL_COMPOSITE_INTERVAL_ANDROID: 2409 case EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID: 2410 case EGL_REQUESTED_PRESENT_TIME_ANDROID: 2411 case EGL_RENDERING_COMPLETE_TIME_ANDROID: 2412 case EGL_COMPOSITION_LATCH_TIME_ANDROID: 2413 case EGL_FIRST_COMPOSITION_START_TIME_ANDROID: 2414 case EGL_LAST_COMPOSITION_START_TIME_ANDROID: 2415 case EGL_FIRST_COMPOSITION_GPU_FINISHED_TIME_ANDROID: 2416 case EGL_DEQUEUE_READY_TIME_ANDROID: 2417 case EGL_READS_DONE_TIME_ANDROID: 2418 return EGL_TRUE; 2419 case EGL_DISPLAY_PRESENT_TIME_ANDROID: { 2420 int value = 0; 2421 window->query(window, 2422 NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &value); 2423 return value == 0 ? EGL_FALSE : EGL_TRUE; 2424 } 2425 default: 2426 return EGL_FALSE; 2427 } 2428 } 2429
