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
findProcAddress(const char * name,const extention_map_t * map,size_t n)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
clearError()243 static inline void clearError() { egl_tls_t::clearError(); }
getContext()244 static inline EGLContext getContext() { return egl_tls_t::getContext(); }
245
246 // ----------------------------------------------------------------------------
247
eglGetDisplay(EGLNativeDisplayType display)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
eglInitialize(EGLDisplay dpy,EGLint * major,EGLint * minor)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
eglTerminate(EGLDisplay dpy)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
eglGetConfigs(EGLDisplay dpy,EGLConfig * configs,EGLint config_size,EGLint * num_config)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
eglChooseConfig(EGLDisplay dpy,const EGLint * attrib_list,EGLConfig * configs,EGLint config_size,EGLint * num_config)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
eglGetConfigAttrib(EGLDisplay dpy,EGLConfig config,EGLint attribute,EGLint * value)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.
modifyBufferDataspace(android_dataspace dataSpace,EGLint colorspace)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
eglCreateWindowSurface(EGLDisplay dpy,EGLConfig config,NativeWindowType window,const EGLint * attrib_list)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
eglCreatePixmapSurface(EGLDisplay dpy,EGLConfig config,NativePixmapType pixmap,const EGLint * attrib_list)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
eglCreatePbufferSurface(EGLDisplay dpy,EGLConfig config,const EGLint * attrib_list)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
eglDestroySurface(EGLDisplay dpy,EGLSurface surface)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
eglQuerySurface(EGLDisplay dpy,EGLSurface surface,EGLint attribute,EGLint * value)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
eglBeginFrame(EGLDisplay dpy,EGLSurface surface)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
eglCreateContext(EGLDisplay dpy,EGLConfig config,EGLContext share_list,const EGLint * attrib_list)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
eglDestroyContext(EGLDisplay dpy,EGLContext ctx)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
eglMakeCurrent(EGLDisplay dpy,EGLSurface draw,EGLSurface read,EGLContext ctx)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
eglQueryContext(EGLDisplay dpy,EGLContext ctx,EGLint attribute,EGLint * value)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
eglGetCurrentContext(void)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
eglGetCurrentSurface(EGLint readdraw)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
eglGetCurrentDisplay(void)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
eglWaitGL(void)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
eglWaitNative(EGLint engine)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
eglGetError(void)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
findBuiltinWrapper(const char * procname)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
eglGetProcAddress(const char * procname)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
queueSync(EGLSyncKHR sync)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:
FrameCompletionThread()1037 FrameCompletionThread() : mFramesQueued(0), mFramesCompleted(0) {}
1038
threadLoop()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
eglSwapBuffersWithDamageKHR(EGLDisplay dpy,EGLSurface draw,EGLint * rects,EGLint n_rects)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
eglSwapBuffers(EGLDisplay dpy,EGLSurface surface)1167 EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
1168 {
1169 return eglSwapBuffersWithDamageKHR(dpy, surface, NULL, 0);
1170 }
1171
eglCopyBuffers(EGLDisplay dpy,EGLSurface surface,NativePixmapType target)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
eglQueryString(EGLDisplay dpy,EGLint name)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
eglQueryStringImplementationANDROID(EGLDisplay dpy,EGLint name)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
eglSurfaceAttrib(EGLDisplay dpy,EGLSurface surface,EGLint attribute,EGLint value)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
eglBindTexImage(EGLDisplay dpy,EGLSurface surface,EGLint buffer)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
eglReleaseTexImage(EGLDisplay dpy,EGLSurface surface,EGLint buffer)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
eglSwapInterval(EGLDisplay dpy,EGLint interval)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
eglWaitClient(void)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
eglBindAPI(EGLenum api)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
eglQueryAPI(void)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
eglReleaseThread(void)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
eglCreatePbufferFromClientBuffer(EGLDisplay dpy,EGLenum buftype,EGLClientBuffer buffer,EGLConfig config,const EGLint * attrib_list)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
eglLockSurfaceKHR(EGLDisplay dpy,EGLSurface surface,const EGLint * attrib_list)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
eglUnlockSurfaceKHR(EGLDisplay dpy,EGLSurface surface)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
eglCreateImageKHR(EGLDisplay dpy,EGLContext ctx,EGLenum target,EGLClientBuffer buffer,const EGLint * attrib_list)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
eglDestroyImageKHR(EGLDisplay dpy,EGLImageKHR img)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
eglCreateSyncKHR(EGLDisplay dpy,EGLenum type,const EGLint * attrib_list)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
eglDestroySyncKHR(EGLDisplay dpy,EGLSyncKHR sync)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
eglSignalSyncKHR(EGLDisplay dpy,EGLSyncKHR sync,EGLenum mode)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
eglClientWaitSyncKHR(EGLDisplay dpy,EGLSyncKHR sync,EGLint flags,EGLTimeKHR timeout)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
eglGetSyncAttribKHR(EGLDisplay dpy,EGLSyncKHR sync,EGLint attribute,EGLint * value)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
eglCreateStreamKHR(EGLDisplay dpy,const EGLint * attrib_list)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
eglDestroyStreamKHR(EGLDisplay dpy,EGLStreamKHR stream)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
eglStreamAttribKHR(EGLDisplay dpy,EGLStreamKHR stream,EGLenum attribute,EGLint value)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
eglQueryStreamKHR(EGLDisplay dpy,EGLStreamKHR stream,EGLenum attribute,EGLint * value)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
eglQueryStreamu64KHR(EGLDisplay dpy,EGLStreamKHR stream,EGLenum attribute,EGLuint64KHR * value)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
eglQueryStreamTimeKHR(EGLDisplay dpy,EGLStreamKHR stream,EGLenum attribute,EGLTimeKHR * value)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
eglCreateStreamProducerSurfaceKHR(EGLDisplay dpy,EGLConfig config,EGLStreamKHR stream,const EGLint * attrib_list)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
eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy,EGLStreamKHR stream)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
eglStreamConsumerAcquireKHR(EGLDisplay dpy,EGLStreamKHR stream)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
eglStreamConsumerReleaseKHR(EGLDisplay dpy,EGLStreamKHR stream)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
eglGetStreamFileDescriptorKHR(EGLDisplay dpy,EGLStreamKHR stream)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
eglCreateStreamFromFileDescriptorKHR(EGLDisplay dpy,EGLNativeFileDescriptorKHR file_descriptor)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
eglWaitSyncKHR(EGLDisplay dpy,EGLSyncKHR sync,EGLint flags)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
eglDupNativeFenceFDANDROID(EGLDisplay dpy,EGLSyncKHR sync)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
eglPresentationTimeANDROID(EGLDisplay dpy,EGLSurface surface,EGLnsecsANDROID time)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 // ----------------------------------------------------------------------------
eglGetSystemTimeFrequencyNV()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
eglGetSystemTimeNV()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 // ----------------------------------------------------------------------------
eglSetDamageRegionKHR(EGLDisplay dpy,EGLSurface surface,EGLint * rects,EGLint n_rects)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