2 ** Copyright 2007, The Android Open Source Project
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
8 ** http://www.apache.org/licenses/LICENSE-2.0
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.
17 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
24 #include <hardware/gralloc.h>
25 #include <system/window.h>
28 #include <EGL/eglext.h>
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>
36 #include <utils/KeyedVector.h>
37 #include <utils/SortedVector.h>
38 #include <utils/String8.h>
39 #include <utils/Trace.h>
41 #include "../egl_impl.h"
42 #include "../glestrace.h"
45 #include "egl_display.h"
46 #include "egl_object.h"
50 using namespace android;
52 // ----------------------------------------------------------------------------
56 struct extention_map_t {
58 __eglMustCastToProperFunctionPointerType address;
62 * This is the list of EGL extensions exposed to applications,
63 * some of them are mandatory because used by the ANDROID system.
65 * Mandatory extensions are required per the CDD and not explicitly
66 * checked during EGL initialization. the system *assumes* these extensions
67 * are present. the system may not function properly if some mandatory
68 * extensions are missing.
70 * NOTE: gExtensionString MUST have a single space as the last character.
72 extern char const * const gExtensionString =
73 "EGL_KHR_image " // mandatory
74 "EGL_KHR_image_base " // mandatory
75 "EGL_KHR_image_pixmap "
76 "EGL_KHR_lock_surface "
77 "EGL_KHR_gl_texture_2D_image "
78 "EGL_KHR_gl_texture_cubemap_image "
79 "EGL_KHR_gl_renderbuffer_image "
80 "EGL_KHR_reusable_sync "
82 "EGL_KHR_create_context "
83 "EGL_EXT_create_context_robustness "
85 "EGL_ANDROID_image_native_buffer " // mandatory
86 "EGL_KHR_wait_sync " // strongly recommended
87 "EGL_ANDROID_presentation_time "
90 // extensions not exposed to applications but used by the ANDROID system
91 // "EGL_ANDROID_blob_cache " // strongly recommended
92 // "EGL_IMG_hibernate_process " // optional
93 // "EGL_ANDROID_native_fence_sync " // strongly recommended
94 // "EGL_ANDROID_framebuffer_target " // mandatory for HWC 1.1
95 // "EGL_ANDROID_recordable " // mandatory
99 * EGL Extensions entry-points exposed to 3rd party applications
100 * (keep in sync with gExtensionString above)
103 static const extention_map_t sExtensionMap[] = {
104 // EGL_KHR_lock_surface
105 { "eglLockSurfaceKHR",
106 (__eglMustCastToProperFunctionPointerType)&eglLockSurfaceKHR },
107 { "eglUnlockSurfaceKHR",
108 (__eglMustCastToProperFunctionPointerType)&eglUnlockSurfaceKHR },
110 // EGL_KHR_image, EGL_KHR_image_base
111 { "eglCreateImageKHR",
112 (__eglMustCastToProperFunctionPointerType)&eglCreateImageKHR },
113 { "eglDestroyImageKHR",
114 (__eglMustCastToProperFunctionPointerType)&eglDestroyImageKHR },
116 // EGL_KHR_reusable_sync, EGL_KHR_fence_sync
117 { "eglCreateSyncKHR",
118 (__eglMustCastToProperFunctionPointerType)&eglCreateSyncKHR },
119 { "eglDestroySyncKHR",
120 (__eglMustCastToProperFunctionPointerType)&eglDestroySyncKHR },
121 { "eglClientWaitSyncKHR",
122 (__eglMustCastToProperFunctionPointerType)&eglClientWaitSyncKHR },
123 { "eglSignalSyncKHR",
124 (__eglMustCastToProperFunctionPointerType)&eglSignalSyncKHR },
125 { "eglGetSyncAttribKHR",
126 (__eglMustCastToProperFunctionPointerType)&eglGetSyncAttribKHR },
128 // EGL_NV_system_time
129 { "eglGetSystemTimeFrequencyNV",
130 (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeFrequencyNV },
131 { "eglGetSystemTimeNV",
132 (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeNV },
136 (__eglMustCastToProperFunctionPointerType)&eglWaitSyncKHR },
138 // EGL_ANDROID_presentation_time
139 { "eglPresentationTimeANDROID",
140 (__eglMustCastToProperFunctionPointerType)&eglPresentationTimeANDROID },
144 * These extensions entry-points should not be exposed to applications.
145 * They're used internally by the Android EGL layer.
147 #define FILTER_EXTENSIONS(procname) \
148 (!strcmp((procname), "eglSetBlobCacheFuncsANDROID") || \
149 !strcmp((procname), "eglHibernateProcessIMG") || \
150 !strcmp((procname), "eglAwakenProcessIMG") || \
151 !strcmp((procname), "eglDupNativeFenceFDANDROID"))
155 // accesses protected by sExtensionMapMutex
156 static DefaultKeyedVector<String8, __eglMustCastToProperFunctionPointerType> sGLExtentionMap;
157 static int sGLExtentionSlot = 0;
158 static pthread_mutex_t sExtensionMapMutex = PTHREAD_MUTEX_INITIALIZER;
160 static void(*findProcAddress(const char* name,
161 const extention_map_t* map, size_t n))() {
162 for (uint32_t i=0 ; i<n ; i++) {
163 if (!strcmp(name, map[i].name)) {
164 return map[i].address;
170 // ----------------------------------------------------------------------------
172 extern void setGLHooksThreadSpecific(gl_hooks_t const *value);
173 extern EGLBoolean egl_init_drivers();
174 extern const __eglMustCastToProperFunctionPointerType gExtensionForwarders[MAX_NUMBER_OF_GL_EXTENSIONS];
175 extern int getEGLDebugLevel();
176 extern void setEGLDebugLevel(int level);
177 extern gl_hooks_t gHooksTrace;
179 } // namespace android;
182 // ----------------------------------------------------------------------------
184 static inline void clearError() { egl_tls_t::clearError(); }
185 static inline EGLContext getContext() { return egl_tls_t::getContext(); }
187 // ----------------------------------------------------------------------------
189 EGLDisplay eglGetDisplay(EGLNativeDisplayType display)
193 uint32_t index = uint32_t(display);
194 if (index >= NUM_DISPLAYS) {
195 return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);
198 if (egl_init_drivers() == EGL_FALSE) {
199 return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);
202 EGLDisplay dpy = egl_display_t::getFromNativeDisplay(display);
206 // ----------------------------------------------------------------------------
208 // ----------------------------------------------------------------------------
210 EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
214 egl_display_ptr dp = get_display(dpy);
215 if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
217 EGLBoolean res = dp->initialize(major, minor);
222 EGLBoolean eglTerminate(EGLDisplay dpy)
224 // NOTE: don't unload the drivers b/c some APIs can be called
225 // after eglTerminate() has been called. eglTerminate() only
226 // terminates an EGLDisplay, not a EGL itself.
230 egl_display_ptr dp = get_display(dpy);
231 if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
233 EGLBoolean res = dp->terminate();
238 // ----------------------------------------------------------------------------
240 // ----------------------------------------------------------------------------
242 EGLBoolean eglGetConfigs( EGLDisplay dpy,
244 EGLint config_size, EGLint *num_config)
248 const egl_display_ptr dp = validate_display(dpy);
249 if (!dp) return EGL_FALSE;
252 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
255 EGLBoolean res = EGL_FALSE;
258 egl_connection_t* const cnx = &gEGLImpl;
260 res = cnx->egl.eglGetConfigs(
261 dp->disp.dpy, configs, config_size, num_config);
267 EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list,
268 EGLConfig *configs, EGLint config_size,
273 const egl_display_ptr dp = validate_display(dpy);
274 if (!dp) return EGL_FALSE;
277 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
280 EGLBoolean res = EGL_FALSE;
283 egl_connection_t* const cnx = &gEGLImpl;
286 char value[PROPERTY_VALUE_MAX];
287 property_get("debug.egl.force_msaa", value, "false");
289 if (!strcmp(value, "true")) {
290 size_t attribCount = 0;
291 EGLint attrib = attrib_list[0];
293 // Only enable MSAA if the context is OpenGL ES 2.0 and
294 // if no caveat is requested
295 const EGLint *attribRendererable = NULL;
296 const EGLint *attribCaveat = NULL;
298 // Count the number of attributes and look for
299 // EGL_RENDERABLE_TYPE and EGL_CONFIG_CAVEAT
300 while (attrib != EGL_NONE) {
301 attrib = attrib_list[attribCount];
303 case EGL_RENDERABLE_TYPE:
304 attribRendererable = &attrib_list[attribCount];
306 case EGL_CONFIG_CAVEAT:
307 attribCaveat = &attrib_list[attribCount];
313 if (attribRendererable && attribRendererable[1] == EGL_OPENGL_ES2_BIT &&
314 (!attribCaveat || attribCaveat[1] != EGL_NONE)) {
316 // Insert 2 extra attributes to force-enable MSAA 4x
317 EGLint aaAttribs[attribCount + 4];
318 aaAttribs[0] = EGL_SAMPLE_BUFFERS;
320 aaAttribs[2] = EGL_SAMPLES;
323 memcpy(&aaAttribs[4], attrib_list, attribCount * sizeof(EGLint));
326 EGLBoolean resAA = cnx->egl.eglChooseConfig(
327 dp->disp.dpy, aaAttribs, configs, config_size, &numConfigAA);
329 if (resAA == EGL_TRUE && numConfigAA > 0) {
330 ALOGD("Enabling MSAA 4x");
331 *num_config = numConfigAA;
338 res = cnx->egl.eglChooseConfig(
339 dp->disp.dpy, attrib_list, configs, config_size, num_config);
344 EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
345 EGLint attribute, EGLint *value)
349 egl_connection_t* cnx = NULL;
350 const egl_display_ptr dp = validate_display_connection(dpy, cnx);
351 if (!dp) return EGL_FALSE;
353 return cnx->egl.eglGetConfigAttrib(
354 dp->disp.dpy, config, attribute, value);
357 // ----------------------------------------------------------------------------
359 // ----------------------------------------------------------------------------
361 EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config,
362 NativeWindowType window,
363 const EGLint *attrib_list)
367 egl_connection_t* cnx = NULL;
368 egl_display_ptr dp = validate_display_connection(dpy, cnx);
370 EGLDisplay iDpy = dp->disp.dpy;
373 if (native_window_api_connect(window, NATIVE_WINDOW_API_EGL) != OK) {
374 ALOGE("EGLNativeWindowType %p already connected to another API",
376 return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
379 // set the native window's buffers format to match this config
380 if (cnx->egl.eglGetConfigAttrib(iDpy,
381 config, EGL_NATIVE_VISUAL_ID, &format)) {
383 int err = native_window_set_buffers_format(window, format);
385 ALOGE("error setting native window pixel format: %s (%d)",
386 strerror(-err), err);
387 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
388 return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
393 // the EGL spec requires that a new EGLSurface default to swap interval
394 // 1, so explicitly set that on the window here.
395 ANativeWindow* anw = reinterpret_cast<ANativeWindow*>(window);
396 anw->setSwapInterval(anw, 1);
398 EGLSurface surface = cnx->egl.eglCreateWindowSurface(
399 iDpy, config, window, attrib_list);
400 if (surface != EGL_NO_SURFACE) {
401 egl_surface_t* s = new egl_surface_t(dp.get(), config, window,
406 // EGLSurface creation failed
407 native_window_set_buffers_format(window, 0);
408 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
410 return EGL_NO_SURFACE;
413 EGLSurface eglCreatePixmapSurface( EGLDisplay dpy, EGLConfig config,
414 NativePixmapType pixmap,
415 const EGLint *attrib_list)
419 egl_connection_t* cnx = NULL;
420 egl_display_ptr dp = validate_display_connection(dpy, cnx);
422 EGLSurface surface = cnx->egl.eglCreatePixmapSurface(
423 dp->disp.dpy, config, pixmap, attrib_list);
424 if (surface != EGL_NO_SURFACE) {
425 egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL,
430 return EGL_NO_SURFACE;
433 EGLSurface eglCreatePbufferSurface( EGLDisplay dpy, EGLConfig config,
434 const EGLint *attrib_list)
438 egl_connection_t* cnx = NULL;
439 egl_display_ptr dp = validate_display_connection(dpy, cnx);
441 EGLSurface surface = cnx->egl.eglCreatePbufferSurface(
442 dp->disp.dpy, config, attrib_list);
443 if (surface != EGL_NO_SURFACE) {
444 egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL,
449 return EGL_NO_SURFACE;
452 EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
456 const egl_display_ptr dp = validate_display(dpy);
457 if (!dp) return EGL_FALSE;
459 SurfaceRef _s(dp.get(), surface);
461 return setError(EGL_BAD_SURFACE, EGL_FALSE);
463 egl_surface_t * const s = get_surface(surface);
464 EGLBoolean result = s->cnx->egl.eglDestroySurface(dp->disp.dpy, s->surface);
465 if (result == EGL_TRUE) {
471 EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface surface,
472 EGLint attribute, EGLint *value)
476 const egl_display_ptr dp = validate_display(dpy);
477 if (!dp) return EGL_FALSE;
479 SurfaceRef _s(dp.get(), surface);
481 return setError(EGL_BAD_SURFACE, EGL_FALSE);
483 egl_surface_t const * const s = get_surface(surface);
484 return s->cnx->egl.eglQuerySurface(
485 dp->disp.dpy, s->surface, attribute, value);
488 void EGLAPI eglBeginFrame(EGLDisplay dpy, EGLSurface surface) {
492 const egl_display_ptr dp = validate_display(dpy);
497 SurfaceRef _s(dp.get(), surface);
499 setError(EGL_BAD_SURFACE, EGL_FALSE);
503 int64_t timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
505 egl_surface_t const * const s = get_surface(surface);
506 native_window_set_buffers_timestamp(s->win.get(), timestamp);
509 // ----------------------------------------------------------------------------
511 // ----------------------------------------------------------------------------
513 EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,
514 EGLContext share_list, const EGLint *attrib_list)
518 egl_connection_t* cnx = NULL;
519 const egl_display_ptr dp = validate_display_connection(dpy, cnx);
521 if (share_list != EGL_NO_CONTEXT) {
522 if (!ContextRef(dp.get(), share_list).get()) {
523 return setError(EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
525 egl_context_t* const c = get_context(share_list);
526 share_list = c->context;
528 EGLContext context = cnx->egl.eglCreateContext(
529 dp->disp.dpy, config, share_list, attrib_list);
530 if (context != EGL_NO_CONTEXT) {
531 // figure out if it's a GLESv1 or GLESv2
534 while (*attrib_list != EGL_NONE) {
535 GLint attr = *attrib_list++;
536 GLint value = *attrib_list++;
537 if (attr == EGL_CONTEXT_CLIENT_VERSION) {
539 version = egl_connection_t::GLESv1_INDEX;
540 } else if (value == 2 || value == 3) {
541 version = egl_connection_t::GLESv2_INDEX;
546 egl_context_t* c = new egl_context_t(dpy, context, config, cnx,
549 if (getEGLDebugLevel() > 0)
550 GLTrace_eglCreateContext(version, c);
554 EGLint error = eglGetError();
555 ALOGE_IF(error == EGL_SUCCESS,
556 "eglCreateContext(%p, %p, %p, %p) returned EGL_NO_CONTEXT "
558 dpy, config, share_list, attrib_list);
561 return EGL_NO_CONTEXT;
564 EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
568 const egl_display_ptr dp = validate_display(dpy);
572 ContextRef _c(dp.get(), ctx);
574 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
576 egl_context_t * const c = get_context(ctx);
577 EGLBoolean result = c->cnx->egl.eglDestroyContext(dp->disp.dpy, c->context);
578 if (result == EGL_TRUE) {
584 EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw,
585 EGLSurface read, EGLContext ctx)
589 egl_display_ptr dp = validate_display(dpy);
590 if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
592 // If ctx is not EGL_NO_CONTEXT, read is not EGL_NO_SURFACE, or draw is not
593 // EGL_NO_SURFACE, then an EGL_NOT_INITIALIZED error is generated if dpy is
594 // a valid but uninitialized display.
595 if ( (ctx != EGL_NO_CONTEXT) || (read != EGL_NO_SURFACE) ||
596 (draw != EGL_NO_SURFACE) ) {
597 if (!dp->isReady()) return setError(EGL_NOT_INITIALIZED, EGL_FALSE);
600 // get a reference to the object passed in
601 ContextRef _c(dp.get(), ctx);
602 SurfaceRef _d(dp.get(), draw);
603 SurfaceRef _r(dp.get(), read);
605 // validate the context (if not EGL_NO_CONTEXT)
606 if ((ctx != EGL_NO_CONTEXT) && !_c.get()) {
607 // EGL_NO_CONTEXT is valid
608 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
611 // these are the underlying implementation's object
612 EGLContext impl_ctx = EGL_NO_CONTEXT;
613 EGLSurface impl_draw = EGL_NO_SURFACE;
614 EGLSurface impl_read = EGL_NO_SURFACE;
616 // these are our objects structs passed in
617 egl_context_t * c = NULL;
618 egl_surface_t const * d = NULL;
619 egl_surface_t const * r = NULL;
621 // these are the current objects structs
622 egl_context_t * cur_c = get_context(getContext());
624 if (ctx != EGL_NO_CONTEXT) {
625 c = get_context(ctx);
626 impl_ctx = c->context;
628 // no context given, use the implementation of the current context
629 if (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE) {
630 // calling eglMakeCurrent( ..., !=0, !=0, EGL_NO_CONTEXT);
631 return setError(EGL_BAD_MATCH, EGL_FALSE);
634 // no current context
635 // not an error, there is just no current context.
640 // retrieve the underlying implementation's draw EGLSurface
641 if (draw != EGL_NO_SURFACE) {
642 if (!_d.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
643 d = get_surface(draw);
644 impl_draw = d->surface;
647 // retrieve the underlying implementation's read EGLSurface
648 if (read != EGL_NO_SURFACE) {
649 if (!_r.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
650 r = get_surface(read);
651 impl_read = r->surface;
655 EGLBoolean result = dp->makeCurrent(c, cur_c,
657 impl_draw, impl_read, impl_ctx);
659 if (result == EGL_TRUE) {
661 setGLHooksThreadSpecific(c->cnx->hooks[c->version]);
662 egl_tls_t::setContext(ctx);
664 if (getEGLDebugLevel() > 0)
665 GLTrace_eglMakeCurrent(c->version, c->cnx->hooks[c->version], ctx);
671 setGLHooksThreadSpecific(&gHooksNoContext);
672 egl_tls_t::setContext(EGL_NO_CONTEXT);
675 // this will ALOGE the error
676 result = setError(c->cnx->egl.eglGetError(), EGL_FALSE);
682 EGLBoolean eglQueryContext( EGLDisplay dpy, EGLContext ctx,
683 EGLint attribute, EGLint *value)
687 const egl_display_ptr dp = validate_display(dpy);
688 if (!dp) return EGL_FALSE;
690 ContextRef _c(dp.get(), ctx);
691 if (!_c.get()) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
693 egl_context_t * const c = get_context(ctx);
694 return c->cnx->egl.eglQueryContext(
695 dp->disp.dpy, c->context, attribute, value);
699 EGLContext eglGetCurrentContext(void)
701 // could be called before eglInitialize(), but we wouldn't have a context
702 // then, and this function would correctly return EGL_NO_CONTEXT.
706 EGLContext ctx = getContext();
710 EGLSurface eglGetCurrentSurface(EGLint readdraw)
712 // could be called before eglInitialize(), but we wouldn't have a context
713 // then, and this function would correctly return EGL_NO_SURFACE.
717 EGLContext ctx = getContext();
719 egl_context_t const * const c = get_context(ctx);
720 if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
722 case EGL_READ: return c->read;
723 case EGL_DRAW: return c->draw;
724 default: return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
727 return EGL_NO_SURFACE;
730 EGLDisplay eglGetCurrentDisplay(void)
732 // could be called before eglInitialize(), but we wouldn't have a context
733 // then, and this function would correctly return EGL_NO_DISPLAY.
737 EGLContext ctx = getContext();
739 egl_context_t const * const c = get_context(ctx);
740 if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
743 return EGL_NO_DISPLAY;
746 EGLBoolean eglWaitGL(void)
750 egl_connection_t* const cnx = &gEGLImpl;
752 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
754 return cnx->egl.eglWaitGL();
757 EGLBoolean eglWaitNative(EGLint engine)
761 egl_connection_t* const cnx = &gEGLImpl;
763 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
765 return cnx->egl.eglWaitNative(engine);
768 EGLint eglGetError(void)
770 EGLint err = EGL_SUCCESS;
771 egl_connection_t* const cnx = &gEGLImpl;
773 err = cnx->egl.eglGetError();
775 if (err == EGL_SUCCESS) {
776 err = egl_tls_t::getError();
781 static __eglMustCastToProperFunctionPointerType findBuiltinGLWrapper(
782 const char* procname) {
783 const egl_connection_t* cnx = &gEGLImpl;
786 proc = dlsym(cnx->libGles2, procname);
787 if (proc) return (__eglMustCastToProperFunctionPointerType)proc;
789 proc = dlsym(cnx->libGles1, procname);
790 if (proc) return (__eglMustCastToProperFunctionPointerType)proc;
795 __eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname)
797 // eglGetProcAddress() could be the very first function called
798 // in which case we must make sure we've initialized ourselves, this
799 // happens the first time egl_get_display() is called.
803 if (egl_init_drivers() == EGL_FALSE) {
804 setError(EGL_BAD_PARAMETER, NULL);
808 if (FILTER_EXTENSIONS(procname)) {
812 __eglMustCastToProperFunctionPointerType addr;
813 addr = findProcAddress(procname, sExtensionMap, NELEM(sExtensionMap));
814 if (addr) return addr;
816 addr = findBuiltinGLWrapper(procname);
817 if (addr) return addr;
819 // this protects accesses to sGLExtentionMap and sGLExtentionSlot
820 pthread_mutex_lock(&sExtensionMapMutex);
823 * Since eglGetProcAddress() is not associated to anything, it needs
824 * to return a function pointer that "works" regardless of what
825 * the current context is.
827 * For this reason, we return a "forwarder", a small stub that takes
828 * care of calling the function associated with the context
831 * We first look for extensions we've already resolved, if we're seeing
832 * this extension for the first time, we go through all our
833 * implementations and call eglGetProcAddress() and record the
834 * result in the appropriate implementation hooks and return the
835 * address of the forwarder corresponding to that hook set.
839 const String8 name(procname);
840 addr = sGLExtentionMap.valueFor(name);
841 const int slot = sGLExtentionSlot;
843 ALOGE_IF(slot >= MAX_NUMBER_OF_GL_EXTENSIONS,
844 "no more slots for eglGetProcAddress(\"%s\")",
848 gl_hooks_t *debugHooks = GLTrace_getGLHooks();
851 if (!addr && (slot < MAX_NUMBER_OF_GL_EXTENSIONS)) {
854 egl_connection_t* const cnx = &gEGLImpl;
855 if (cnx->dso && cnx->egl.eglGetProcAddress) {
856 // Extensions are independent of the bound context
858 cnx->hooks[egl_connection_t::GLESv1_INDEX]->ext.extensions[slot] =
859 cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[slot] =
861 debugHooks->ext.extensions[slot] =
862 gHooksTrace.ext.extensions[slot] =
864 cnx->egl.eglGetProcAddress(procname);
865 if (addr) found = true;
869 addr = gExtensionForwarders[slot];
870 sGLExtentionMap.add(name, addr);
875 pthread_mutex_unlock(&sExtensionMapMutex);
879 class FrameCompletionThread : public Thread {
882 static void queueSync(EGLSyncKHR sync) {
883 static sp<FrameCompletionThread> thread(new FrameCompletionThread);
884 static bool running = false;
886 thread->run("GPUFrameCompletion");
890 Mutex::Autolock lock(thread->mMutex);
891 ScopedTrace st(ATRACE_TAG, String8::format("kicked off frame %d",
892 thread->mFramesQueued).string());
893 thread->mQueue.push_back(sync);
894 thread->mCondition.signal();
895 thread->mFramesQueued++;
896 ATRACE_INT("GPU Frames Outstanding", thread->mQueue.size());
901 FrameCompletionThread() : mFramesQueued(0), mFramesCompleted(0) {}
903 virtual bool threadLoop() {
907 Mutex::Autolock lock(mMutex);
908 while (mQueue.isEmpty()) {
909 mCondition.wait(mMutex);
912 frameNum = mFramesCompleted;
914 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
916 ScopedTrace st(ATRACE_TAG, String8::format("waiting for frame %d",
918 EGLint result = eglClientWaitSyncKHR(dpy, sync, 0, EGL_FOREVER_KHR);
919 if (result == EGL_FALSE) {
920 ALOGE("FrameCompletion: error waiting for fence: %#x", eglGetError());
921 } else if (result == EGL_TIMEOUT_EXPIRED_KHR) {
922 ALOGE("FrameCompletion: timeout waiting for fence");
924 eglDestroySyncKHR(dpy, sync);
927 Mutex::Autolock lock(mMutex);
930 ATRACE_INT("GPU Frames Outstanding", mQueue.size());
935 uint32_t mFramesQueued;
936 uint32_t mFramesCompleted;
937 Vector<EGLSyncKHR> mQueue;
938 Condition mCondition;
942 EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw)
947 const egl_display_ptr dp = validate_display(dpy);
948 if (!dp) return EGL_FALSE;
950 SurfaceRef _s(dp.get(), draw);
952 return setError(EGL_BAD_SURFACE, EGL_FALSE);
955 gl_hooks_t const *trace_hooks = getGLTraceThreadSpecific();
956 if (getEGLDebugLevel() > 0) {
957 if (trace_hooks == NULL) {
958 if (GLTrace_start() < 0) {
959 ALOGE("Disabling Tracer for OpenGL ES");
962 // switch over to the trace version of hooks
963 EGLContext ctx = egl_tls_t::getContext();
964 egl_context_t * const c = get_context(ctx);
966 setGLHooksThreadSpecific(c->cnx->hooks[c->version]);
967 GLTrace_eglMakeCurrent(c->version, c->cnx->hooks[c->version], ctx);
972 GLTrace_eglSwapBuffers(dpy, draw);
973 } else if (trace_hooks != NULL) {
974 // tracing is now disabled, so switch back to the non trace version
975 EGLContext ctx = egl_tls_t::getContext();
976 egl_context_t * const c = get_context(ctx);
977 if (c) setGLHooksThreadSpecific(c->cnx->hooks[c->version]);
982 egl_surface_t const * const s = get_surface(draw);
984 if (CC_UNLIKELY(dp->traceGpuCompletion)) {
985 EGLSyncKHR sync = eglCreateSyncKHR(dpy, EGL_SYNC_FENCE_KHR, NULL);
986 if (sync != EGL_NO_SYNC_KHR) {
987 FrameCompletionThread::queueSync(sync);
991 if (CC_UNLIKELY(dp->finishOnSwap)) {
993 egl_context_t * const c = get_context( egl_tls_t::getContext() );
995 // glReadPixels() ensures that the frame is complete
996 s->cnx->hooks[c->version]->gl.glReadPixels(0,0,1,1,
997 GL_RGBA,GL_UNSIGNED_BYTE,&pixel);
1001 return s->cnx->egl.eglSwapBuffers(dp->disp.dpy, s->surface);
1004 EGLBoolean eglCopyBuffers( EGLDisplay dpy, EGLSurface surface,
1005 NativePixmapType target)
1009 const egl_display_ptr dp = validate_display(dpy);
1010 if (!dp) return EGL_FALSE;
1012 SurfaceRef _s(dp.get(), surface);
1014 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1016 egl_surface_t const * const s = get_surface(surface);
1017 return s->cnx->egl.eglCopyBuffers(dp->disp.dpy, s->surface, target);
1020 const char* eglQueryString(EGLDisplay dpy, EGLint name)
1024 const egl_display_ptr dp = validate_display(dpy);
1025 if (!dp) return (const char *) NULL;
1029 return dp->getVendorString();
1031 return dp->getVersionString();
1032 case EGL_EXTENSIONS:
1033 return dp->getExtensionString();
1034 case EGL_CLIENT_APIS:
1035 return dp->getClientApiString();
1037 return setError(EGL_BAD_PARAMETER, (const char *)0);
1040 EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name)
1044 const egl_display_ptr dp = validate_display(dpy);
1045 if (!dp) return (const char *) NULL;
1049 return dp->disp.queryString.vendor;
1051 return dp->disp.queryString.version;
1052 case EGL_EXTENSIONS:
1053 return dp->disp.queryString.extensions;
1054 case EGL_CLIENT_APIS:
1055 return dp->disp.queryString.clientApi;
1057 return setError(EGL_BAD_PARAMETER, (const char *)0);
1060 // ----------------------------------------------------------------------------
1062 // ----------------------------------------------------------------------------
1064 EGLBoolean eglSurfaceAttrib(
1065 EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
1069 const egl_display_ptr dp = validate_display(dpy);
1070 if (!dp) return EGL_FALSE;
1072 SurfaceRef _s(dp.get(), surface);
1074 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1076 egl_surface_t const * const s = get_surface(surface);
1077 if (s->cnx->egl.eglSurfaceAttrib) {
1078 return s->cnx->egl.eglSurfaceAttrib(
1079 dp->disp.dpy, s->surface, attribute, value);
1081 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1084 EGLBoolean eglBindTexImage(
1085 EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1089 const egl_display_ptr dp = validate_display(dpy);
1090 if (!dp) return EGL_FALSE;
1092 SurfaceRef _s(dp.get(), surface);
1094 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1096 egl_surface_t const * const s = get_surface(surface);
1097 if (s->cnx->egl.eglBindTexImage) {
1098 return s->cnx->egl.eglBindTexImage(
1099 dp->disp.dpy, s->surface, buffer);
1101 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1104 EGLBoolean eglReleaseTexImage(
1105 EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1109 const egl_display_ptr dp = validate_display(dpy);
1110 if (!dp) return EGL_FALSE;
1112 SurfaceRef _s(dp.get(), surface);
1114 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1116 egl_surface_t const * const s = get_surface(surface);
1117 if (s->cnx->egl.eglReleaseTexImage) {
1118 return s->cnx->egl.eglReleaseTexImage(
1119 dp->disp.dpy, s->surface, buffer);
1121 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1124 EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)
1128 const egl_display_ptr dp = validate_display(dpy);
1129 if (!dp) return EGL_FALSE;
1131 EGLBoolean res = EGL_TRUE;
1132 egl_connection_t* const cnx = &gEGLImpl;
1133 if (cnx->dso && cnx->egl.eglSwapInterval) {
1134 res = cnx->egl.eglSwapInterval(dp->disp.dpy, interval);
1141 // ----------------------------------------------------------------------------
1143 // ----------------------------------------------------------------------------
1145 EGLBoolean eglWaitClient(void)
1149 egl_connection_t* const cnx = &gEGLImpl;
1151 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1154 if (cnx->egl.eglWaitClient) {
1155 res = cnx->egl.eglWaitClient();
1157 res = cnx->egl.eglWaitGL();
1162 EGLBoolean eglBindAPI(EGLenum api)
1166 if (egl_init_drivers() == EGL_FALSE) {
1167 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1170 // bind this API on all EGLs
1171 EGLBoolean res = EGL_TRUE;
1172 egl_connection_t* const cnx = &gEGLImpl;
1173 if (cnx->dso && cnx->egl.eglBindAPI) {
1174 res = cnx->egl.eglBindAPI(api);
1179 EGLenum eglQueryAPI(void)
1183 if (egl_init_drivers() == EGL_FALSE) {
1184 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1187 egl_connection_t* const cnx = &gEGLImpl;
1188 if (cnx->dso && cnx->egl.eglQueryAPI) {
1189 return cnx->egl.eglQueryAPI();
1192 // or, it can only be OpenGL ES
1193 return EGL_OPENGL_ES_API;
1196 EGLBoolean eglReleaseThread(void)
1201 if (getEGLDebugLevel() > 0)
1202 GLTrace_eglReleaseThread();
1205 // If there is context bound to the thread, release it
1206 egl_display_t::loseCurrent(get_context(getContext()));
1208 egl_connection_t* const cnx = &gEGLImpl;
1209 if (cnx->dso && cnx->egl.eglReleaseThread) {
1210 cnx->egl.eglReleaseThread();
1212 egl_tls_t::clearTLS();
1216 EGLSurface eglCreatePbufferFromClientBuffer(
1217 EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
1218 EGLConfig config, const EGLint *attrib_list)
1222 egl_connection_t* cnx = NULL;
1223 const egl_display_ptr dp = validate_display_connection(dpy, cnx);
1224 if (!dp) return EGL_FALSE;
1225 if (cnx->egl.eglCreatePbufferFromClientBuffer) {
1226 return cnx->egl.eglCreatePbufferFromClientBuffer(
1227 dp->disp.dpy, buftype, buffer, config, attrib_list);
1229 return setError(EGL_BAD_CONFIG, EGL_NO_SURFACE);
1232 // ----------------------------------------------------------------------------
1233 // EGL_EGLEXT_VERSION 3
1234 // ----------------------------------------------------------------------------
1236 EGLBoolean eglLockSurfaceKHR(EGLDisplay dpy, EGLSurface surface,
1237 const EGLint *attrib_list)
1241 const egl_display_ptr dp = validate_display(dpy);
1242 if (!dp) return EGL_FALSE;
1244 SurfaceRef _s(dp.get(), surface);
1246 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1248 egl_surface_t const * const s = get_surface(surface);
1249 if (s->cnx->egl.eglLockSurfaceKHR) {
1250 return s->cnx->egl.eglLockSurfaceKHR(
1251 dp->disp.dpy, s->surface, attrib_list);
1253 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1256 EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface)
1260 const egl_display_ptr dp = validate_display(dpy);
1261 if (!dp) return EGL_FALSE;
1263 SurfaceRef _s(dp.get(), surface);
1265 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1267 egl_surface_t const * const s = get_surface(surface);
1268 if (s->cnx->egl.eglUnlockSurfaceKHR) {
1269 return s->cnx->egl.eglUnlockSurfaceKHR(dp->disp.dpy, s->surface);
1271 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1274 EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
1275 EGLClientBuffer buffer, const EGLint *attrib_list)
1279 const egl_display_ptr dp = validate_display(dpy);
1280 if (!dp) return EGL_NO_IMAGE_KHR;
1282 ContextRef _c(dp.get(), ctx);
1283 egl_context_t * const c = _c.get();
1285 EGLImageKHR result = EGL_NO_IMAGE_KHR;
1286 egl_connection_t* const cnx = &gEGLImpl;
1287 if (cnx->dso && cnx->egl.eglCreateImageKHR) {
1288 result = cnx->egl.eglCreateImageKHR(
1290 c ? c->context : EGL_NO_CONTEXT,
1291 target, buffer, attrib_list);
1296 EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img)
1300 const egl_display_ptr dp = validate_display(dpy);
1301 if (!dp) return EGL_FALSE;
1303 EGLBoolean result = EGL_FALSE;
1304 egl_connection_t* const cnx = &gEGLImpl;
1305 if (cnx->dso && cnx->egl.eglDestroyImageKHR) {
1306 result = cnx->egl.eglDestroyImageKHR(dp->disp.dpy, img);
1311 // ----------------------------------------------------------------------------
1312 // EGL_EGLEXT_VERSION 5
1313 // ----------------------------------------------------------------------------
1316 EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
1320 const egl_display_ptr dp = validate_display(dpy);
1321 if (!dp) return EGL_NO_SYNC_KHR;
1323 EGLSyncKHR result = EGL_NO_SYNC_KHR;
1324 egl_connection_t* const cnx = &gEGLImpl;
1325 if (cnx->dso && cnx->egl.eglCreateSyncKHR) {
1326 result = cnx->egl.eglCreateSyncKHR(dp->disp.dpy, type, attrib_list);
1331 EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
1335 const egl_display_ptr dp = validate_display(dpy);
1336 if (!dp) return EGL_FALSE;
1338 EGLBoolean result = EGL_FALSE;
1339 egl_connection_t* const cnx = &gEGLImpl;
1340 if (cnx->dso && cnx->egl.eglDestroySyncKHR) {
1341 result = cnx->egl.eglDestroySyncKHR(dp->disp.dpy, sync);
1346 EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) {
1349 const egl_display_ptr dp = validate_display(dpy);
1350 if (!dp) return EGL_FALSE;
1352 EGLBoolean result = EGL_FALSE;
1353 egl_connection_t* const cnx = &gEGLImpl;
1354 if (cnx->dso && cnx->egl.eglSignalSyncKHR) {
1355 result = cnx->egl.eglSignalSyncKHR(
1356 dp->disp.dpy, sync, mode);
1361 EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync,
1362 EGLint flags, EGLTimeKHR timeout)
1366 const egl_display_ptr dp = validate_display(dpy);
1367 if (!dp) return EGL_FALSE;
1369 EGLBoolean result = EGL_FALSE;
1370 egl_connection_t* const cnx = &gEGLImpl;
1371 if (cnx->dso && cnx->egl.eglClientWaitSyncKHR) {
1372 result = cnx->egl.eglClientWaitSyncKHR(
1373 dp->disp.dpy, sync, flags, timeout);
1378 EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync,
1379 EGLint attribute, EGLint *value)
1383 const egl_display_ptr dp = validate_display(dpy);
1384 if (!dp) return EGL_FALSE;
1386 EGLBoolean result = EGL_FALSE;
1387 egl_connection_t* const cnx = &gEGLImpl;
1388 if (cnx->dso && cnx->egl.eglGetSyncAttribKHR) {
1389 result = cnx->egl.eglGetSyncAttribKHR(
1390 dp->disp.dpy, sync, attribute, value);
1395 // ----------------------------------------------------------------------------
1396 // EGL_EGLEXT_VERSION 15
1397 // ----------------------------------------------------------------------------
1399 EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) {
1401 const egl_display_ptr dp = validate_display(dpy);
1402 if (!dp) return EGL_FALSE;
1403 EGLint result = EGL_FALSE;
1404 egl_connection_t* const cnx = &gEGLImpl;
1405 if (cnx->dso && cnx->egl.eglWaitSyncKHR) {
1406 result = cnx->egl.eglWaitSyncKHR(dp->disp.dpy, sync, flags);
1411 // ----------------------------------------------------------------------------
1412 // ANDROID extensions
1413 // ----------------------------------------------------------------------------
1415 EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync)
1419 const egl_display_ptr dp = validate_display(dpy);
1420 if (!dp) return EGL_NO_NATIVE_FENCE_FD_ANDROID;
1422 EGLint result = EGL_NO_NATIVE_FENCE_FD_ANDROID;
1423 egl_connection_t* const cnx = &gEGLImpl;
1424 if (cnx->dso && cnx->egl.eglDupNativeFenceFDANDROID) {
1425 result = cnx->egl.eglDupNativeFenceFDANDROID(dp->disp.dpy, sync);
1430 EGLBoolean eglPresentationTimeANDROID(EGLDisplay dpy, EGLSurface surface,
1431 EGLnsecsANDROID time)
1435 const egl_display_ptr dp = validate_display(dpy);
1440 SurfaceRef _s(dp.get(), surface);
1442 setError(EGL_BAD_SURFACE, EGL_FALSE);
1446 egl_surface_t const * const s = get_surface(surface);
1447 native_window_set_buffers_timestamp(s->win.get(), time);
1452 // ----------------------------------------------------------------------------
1453 // NVIDIA extensions
1454 // ----------------------------------------------------------------------------
1455 EGLuint64NV eglGetSystemTimeFrequencyNV()
1459 if (egl_init_drivers() == EGL_FALSE) {
1460 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1463 EGLuint64NV ret = 0;
1464 egl_connection_t* const cnx = &gEGLImpl;
1466 if (cnx->dso && cnx->egl.eglGetSystemTimeFrequencyNV) {
1467 return cnx->egl.eglGetSystemTimeFrequencyNV();
1470 return setErrorQuiet(EGL_BAD_DISPLAY, 0);
1473 EGLuint64NV eglGetSystemTimeNV()
1477 if (egl_init_drivers() == EGL_FALSE) {
1478 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1481 EGLuint64NV ret = 0;
1482 egl_connection_t* const cnx = &gEGLImpl;
1484 if (cnx->dso && cnx->egl.eglGetSystemTimeNV) {
1485 return cnx->egl.eglGetSystemTimeNV();
1488 return setErrorQuiet(EGL_BAD_DISPLAY, 0);