eglApi.cpp revision 94cdba97ce1de140623d84c14fb15f12f7da89dd 
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
50using namespace android;
51
52// ----------------------------------------------------------------------------
53
54namespace android {
55
56struct extention_map_t {
57    const char* name;
58    __eglMustCastToProperFunctionPointerType address;
59};
60
61/*
62 * This is the list of EGL extensions exposed to applications,
63 * some of them are mandatory because used by the ANDROID system.
64 *
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.
69 *
70 * NOTE: gExtensionString MUST have a single space as the last character.
71 */
72extern 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 "
81        "EGL_KHR_fence_sync "
82        "EGL_KHR_create_context "
83        "EGL_EXT_create_context_robustness "
84        "EGL_NV_system_time "
85        "EGL_ANDROID_image_native_buffer "      // mandatory
86        "EGL_KHR_wait_sync "                    // strongly recommended
87        "EGL_ANDROID_presentation_time "
88        ;
89
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
96
97
98/*
99 * EGL Extensions entry-points exposed to 3rd party applications
100 * (keep in sync with gExtensionString above)
101 *
102 */
103static const extention_map_t sExtensionMap[] = {
104    // EGL_KHR_lock_surface
105    { "eglLockSurfaceKHR",
106            (__eglMustCastToProperFunctionPointerType)&eglLockSurfaceKHR },
107    { "eglUnlockSurfaceKHR",
108            (__eglMustCastToProperFunctionPointerType)&eglUnlockSurfaceKHR },
109
110    // EGL_KHR_image, EGL_KHR_image_base
111    { "eglCreateImageKHR",
112            (__eglMustCastToProperFunctionPointerType)&eglCreateImageKHR },
113    { "eglDestroyImageKHR",
114            (__eglMustCastToProperFunctionPointerType)&eglDestroyImageKHR },
115
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 },
127
128    // EGL_NV_system_time
129    { "eglGetSystemTimeFrequencyNV",
130            (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeFrequencyNV },
131    { "eglGetSystemTimeNV",
132            (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeNV },
133
134    // EGL_KHR_wait_sync
135    { "eglWaitSyncKHR",
136            (__eglMustCastToProperFunctionPointerType)&eglWaitSyncKHR },
137
138    // EGL_ANDROID_presentation_time
139    { "eglPresentationTimeANDROID",
140            (__eglMustCastToProperFunctionPointerType)&eglPresentationTimeANDROID },
141};
142
143/*
144 * These extensions entry-points should not be exposed to applications.
145 * They're used internally by the Android EGL layer.
146 */
147#define FILTER_EXTENSIONS(procname) \
148        (!strcmp((procname), "eglSetBlobCacheFuncsANDROID") ||    \
149         !strcmp((procname), "eglHibernateProcessIMG")      ||    \
150         !strcmp((procname), "eglAwakenProcessIMG")         ||    \
151         !strcmp((procname), "eglDupNativeFenceFDANDROID"))
152
153
154
155// accesses protected by sExtensionMapMutex
156static DefaultKeyedVector<String8, __eglMustCastToProperFunctionPointerType> sGLExtentionMap;
157static int sGLExtentionSlot = 0;
158static pthread_mutex_t sExtensionMapMutex = PTHREAD_MUTEX_INITIALIZER;
159
160static 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;
165        }
166    }
167    return NULL;
168}
169
170// ----------------------------------------------------------------------------
171
172extern void setGLHooksThreadSpecific(gl_hooks_t const *value);
173extern EGLBoolean egl_init_drivers();
174extern const __eglMustCastToProperFunctionPointerType gExtensionForwarders[MAX_NUMBER_OF_GL_EXTENSIONS];
175extern int getEGLDebugLevel();
176extern void setEGLDebugLevel(int level);
177extern gl_hooks_t gHooksTrace;
178
179} // namespace android;
180
181
182// ----------------------------------------------------------------------------
183
184static inline void clearError() { egl_tls_t::clearError(); }
185static inline EGLContext getContext() { return egl_tls_t::getContext(); }
186
187// ----------------------------------------------------------------------------
188
189EGLDisplay eglGetDisplay(EGLNativeDisplayType display)
190{
191    clearError();
192
193    uint32_t index = uint32_t(display);
194    if (index >= NUM_DISPLAYS) {
195        return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);
196    }
197
198    if (egl_init_drivers() == EGL_FALSE) {
199        return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);
200    }
201
202    EGLDisplay dpy = egl_display_t::getFromNativeDisplay(display);
203    return dpy;
204}
205
206// ----------------------------------------------------------------------------
207// Initialization
208// ----------------------------------------------------------------------------
209
210EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
211{
212    clearError();
213
214    egl_display_ptr dp = get_display(dpy);
215    if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
216
217    EGLBoolean res = dp->initialize(major, minor);
218
219    return res;
220}
221
222EGLBoolean eglTerminate(EGLDisplay dpy)
223{
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.
227
228    clearError();
229
230    egl_display_ptr dp = get_display(dpy);
231    if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
232
233    EGLBoolean res = dp->terminate();
234
235    return res;
236}
237
238// ----------------------------------------------------------------------------
239// configuration
240// ----------------------------------------------------------------------------
241
242EGLBoolean eglGetConfigs(   EGLDisplay dpy,
243                            EGLConfig *configs,
244                            EGLint config_size, EGLint *num_config)
245{
246    clearError();
247
248    const egl_display_ptr dp = validate_display(dpy);
249    if (!dp) return EGL_FALSE;
250
251    if (num_config==0) {
252        return setError(EGL_BAD_PARAMETER, EGL_FALSE);
253    }
254
255    EGLBoolean res = EGL_FALSE;
256    *num_config = 0;
257
258    egl_connection_t* const cnx = &gEGLImpl;
259    if (cnx->dso) {
260        res = cnx->egl.eglGetConfigs(
261                dp->disp.dpy, configs, config_size, num_config);
262    }
263
264    return res;
265}
266
267EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list,
268                            EGLConfig *configs, EGLint config_size,
269                            EGLint *num_config)
270{
271    clearError();
272
273    const egl_display_ptr dp = validate_display(dpy);
274    if (!dp) return EGL_FALSE;
275
276    if (num_config==0) {
277        return setError(EGL_BAD_PARAMETER, EGL_FALSE);
278    }
279
280    EGLBoolean res = EGL_FALSE;
281    *num_config = 0;
282
283    egl_connection_t* const cnx = &gEGLImpl;
284    if (cnx->dso) {
285        if (attrib_list) {
286            char value[PROPERTY_VALUE_MAX];
287            property_get("debug.egl.force_msaa", value, "false");
288
289            if (!strcmp(value, "true")) {
290                size_t attribCount = 0;
291                EGLint attrib = attrib_list[0];
292
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;
297
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];
302                    switch (attrib) {
303                        case EGL_RENDERABLE_TYPE:
304                            attribRendererable = &attrib_list[attribCount];
305                            break;
306                        case EGL_CONFIG_CAVEAT:
307                            attribCaveat = &attrib_list[attribCount];
308                            break;
309                    }
310                    attribCount++;
311                }
312
313                if (attribRendererable && attribRendererable[1] == EGL_OPENGL_ES2_BIT &&
314                        (!attribCaveat || attribCaveat[1] != EGL_NONE)) {
315
316                    // Insert 2 extra attributes to force-enable MSAA 4x
317                    EGLint aaAttribs[attribCount + 4];
318                    aaAttribs[0] = EGL_SAMPLE_BUFFERS;
319                    aaAttribs[1] = 1;
320                    aaAttribs[2] = EGL_SAMPLES;
321                    aaAttribs[3] = 4;
322
323                    memcpy(&aaAttribs[4], attrib_list, attribCount * sizeof(EGLint));
324
325                    EGLint numConfigAA;
326                    EGLBoolean resAA = cnx->egl.eglChooseConfig(
327                            dp->disp.dpy, aaAttribs, configs, config_size, &numConfigAA);
328
329                    if (resAA == EGL_TRUE && numConfigAA > 0) {
330                        ALOGD("Enabling MSAA 4x");
331                        *num_config = numConfigAA;
332                        return resAA;
333                    }
334                }
335            }
336        }
337
338        res = cnx->egl.eglChooseConfig(
339                dp->disp.dpy, attrib_list, configs, config_size, num_config);
340    }
341    return res;
342}
343
344EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
345        EGLint attribute, EGLint *value)
346{
347    clearError();
348
349    egl_connection_t* cnx = NULL;
350    const egl_display_ptr dp = validate_display_connection(dpy, cnx);
351    if (!dp) return EGL_FALSE;
352
353    return cnx->egl.eglGetConfigAttrib(
354            dp->disp.dpy, config, attribute, value);
355}
356
357// ----------------------------------------------------------------------------
358// surfaces
359// ----------------------------------------------------------------------------
360
361EGLSurface eglCreateWindowSurface(  EGLDisplay dpy, EGLConfig config,
362                                    NativeWindowType window,
363                                    const EGLint *attrib_list)
364{
365    clearError();
366
367    egl_connection_t* cnx = NULL;
368    egl_display_ptr dp = validate_display_connection(dpy, cnx);
369    if (dp) {
370        EGLDisplay iDpy = dp->disp.dpy;
371        EGLint format;
372
373        if (native_window_api_connect(window, NATIVE_WINDOW_API_EGL) != OK) {
374            ALOGE("EGLNativeWindowType %p already connected to another API",
375                    window);
376            return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
377        }
378
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)) {
382            if (format != 0) {
383                int err = native_window_set_buffers_format(window, format);
384                if (err != 0) {
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);
389                }
390            }
391        }
392
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);
397
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,
402                    surface, cnx);
403            return s;
404        }
405
406        // EGLSurface creation failed
407        native_window_set_buffers_format(window, 0);
408        native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
409    }
410    return EGL_NO_SURFACE;
411}
412
413EGLSurface eglCreatePixmapSurface(  EGLDisplay dpy, EGLConfig config,
414                                    NativePixmapType pixmap,
415                                    const EGLint *attrib_list)
416{
417    clearError();
418
419    egl_connection_t* cnx = NULL;
420    egl_display_ptr dp = validate_display_connection(dpy, cnx);
421    if (dp) {
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,
426                    surface, cnx);
427            return s;
428        }
429    }
430    return EGL_NO_SURFACE;
431}
432
433EGLSurface eglCreatePbufferSurface( EGLDisplay dpy, EGLConfig config,
434                                    const EGLint *attrib_list)
435{
436    clearError();
437
438    egl_connection_t* cnx = NULL;
439    egl_display_ptr dp = validate_display_connection(dpy, cnx);
440    if (dp) {
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,
445                    surface, cnx);
446            return s;
447        }
448    }
449    return EGL_NO_SURFACE;
450}
451
452EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
453{
454    clearError();
455
456    const egl_display_ptr dp = validate_display(dpy);
457    if (!dp) return EGL_FALSE;
458
459    SurfaceRef _s(dp.get(), surface);
460    if (!_s.get())
461        return setError(EGL_BAD_SURFACE, EGL_FALSE);
462
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) {
466        _s.terminate();
467    }
468    return result;
469}
470
471EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface surface,
472                            EGLint attribute, EGLint *value)
473{
474    clearError();
475
476    const egl_display_ptr dp = validate_display(dpy);
477    if (!dp) return EGL_FALSE;
478
479    SurfaceRef _s(dp.get(), surface);
480    if (!_s.get())
481        return setError(EGL_BAD_SURFACE, EGL_FALSE);
482
483    egl_surface_t const * const s = get_surface(surface);
484    return s->cnx->egl.eglQuerySurface(
485            dp->disp.dpy, s->surface, attribute, value);
486}
487
488void EGLAPI eglBeginFrame(EGLDisplay dpy, EGLSurface surface) {
489    ATRACE_CALL();
490    clearError();
491
492    const egl_display_ptr dp = validate_display(dpy);
493    if (!dp) {
494        return;
495    }
496
497    SurfaceRef _s(dp.get(), surface);
498    if (!_s.get()) {
499        setError(EGL_BAD_SURFACE, EGL_FALSE);
500        return;
501    }
502
503    int64_t timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
504
505    egl_surface_t const * const s = get_surface(surface);
506    native_window_set_buffers_timestamp(s->win.get(), timestamp);
507}
508
509// ----------------------------------------------------------------------------
510// Contexts
511// ----------------------------------------------------------------------------
512
513EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,
514                            EGLContext share_list, const EGLint *attrib_list)
515{
516    clearError();
517
518    egl_connection_t* cnx = NULL;
519    const egl_display_ptr dp = validate_display_connection(dpy, cnx);
520    if (dp) {
521        if (share_list != EGL_NO_CONTEXT) {
522            if (!ContextRef(dp.get(), share_list).get()) {
523                return setError(EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
524            }
525            egl_context_t* const c = get_context(share_list);
526            share_list = c->context;
527        }
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
532            int version = 0;
533            if (attrib_list) {
534                while (*attrib_list != EGL_NONE) {
535                    GLint attr = *attrib_list++;
536                    GLint value = *attrib_list++;
537                    if (attr == EGL_CONTEXT_CLIENT_VERSION) {
538                        if (value == 1) {
539                            version = egl_connection_t::GLESv1_INDEX;
540                        } else if (value == 2 || value == 3) {
541                            version = egl_connection_t::GLESv2_INDEX;
542                        }
543                    }
544                };
545            }
546            egl_context_t* c = new egl_context_t(dpy, context, config, cnx,
547                    version);
548#if EGL_TRACE
549            if (getEGLDebugLevel() > 0)
550                GLTrace_eglCreateContext(version, c);
551#endif
552            return c;
553        } else {
554            EGLint error = eglGetError();
555            ALOGE_IF(error == EGL_SUCCESS,
556                    "eglCreateContext(%p, %p, %p, %p) returned EGL_NO_CONTEXT "
557                    "but no EGL error!",
558                    dpy, config, share_list, attrib_list);
559        }
560    }
561    return EGL_NO_CONTEXT;
562}
563
564EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
565{
566    clearError();
567
568    const egl_display_ptr dp = validate_display(dpy);
569    if (!dp)
570        return EGL_FALSE;
571
572    ContextRef _c(dp.get(), ctx);
573    if (!_c.get())
574        return setError(EGL_BAD_CONTEXT, EGL_FALSE);
575
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) {
579        _c.terminate();
580    }
581    return result;
582}
583
584EGLBoolean eglMakeCurrent(  EGLDisplay dpy, EGLSurface draw,
585                            EGLSurface read, EGLContext ctx)
586{
587    clearError();
588
589    egl_display_ptr dp = validate_display(dpy);
590    if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
591
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);
598    }
599
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);
604
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);
609    }
610
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;
615
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;
620
621    // these are the current objects structs
622    egl_context_t * cur_c = get_context(getContext());
623
624    if (ctx != EGL_NO_CONTEXT) {
625        c = get_context(ctx);
626        impl_ctx = c->context;
627    } else {
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);
632        }
633        if (cur_c == NULL) {
634            // no current context
635            // not an error, there is just no current context.
636            return EGL_TRUE;
637        }
638    }
639
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;
645    }
646
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;
652    }
653
654
655    EGLBoolean result = dp->makeCurrent(c, cur_c,
656            draw, read, ctx,
657            impl_draw, impl_read, impl_ctx);
658
659    if (result == EGL_TRUE) {
660        if (c) {
661            setGLHooksThreadSpecific(c->cnx->hooks[c->version]);
662            egl_tls_t::setContext(ctx);
663#if EGL_TRACE
664            if (getEGLDebugLevel() > 0)
665                GLTrace_eglMakeCurrent(c->version, c->cnx->hooks[c->version], ctx);
666#endif
667            _c.acquire();
668            _r.acquire();
669            _d.acquire();
670        } else {
671            setGLHooksThreadSpecific(&gHooksNoContext);
672            egl_tls_t::setContext(EGL_NO_CONTEXT);
673        }
674    } else {
675        // this will ALOGE the error
676        result = setError(c->cnx->egl.eglGetError(), EGL_FALSE);
677    }
678    return result;
679}
680
681
682EGLBoolean eglQueryContext( EGLDisplay dpy, EGLContext ctx,
683                            EGLint attribute, EGLint *value)
684{
685    clearError();
686
687    const egl_display_ptr dp = validate_display(dpy);
688    if (!dp) return EGL_FALSE;
689
690    ContextRef _c(dp.get(), ctx);
691    if (!_c.get()) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
692
693    egl_context_t * const c = get_context(ctx);
694    return c->cnx->egl.eglQueryContext(
695            dp->disp.dpy, c->context, attribute, value);
696
697}
698
699EGLContext eglGetCurrentContext(void)
700{
701    // could be called before eglInitialize(), but we wouldn't have a context
702    // then, and this function would correctly return EGL_NO_CONTEXT.
703
704    clearError();
705
706    EGLContext ctx = getContext();
707    return ctx;
708}
709
710EGLSurface eglGetCurrentSurface(EGLint readdraw)
711{
712    // could be called before eglInitialize(), but we wouldn't have a context
713    // then, and this function would correctly return EGL_NO_SURFACE.
714
715    clearError();
716
717    EGLContext ctx = getContext();
718    if (ctx) {
719        egl_context_t const * const c = get_context(ctx);
720        if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
721        switch (readdraw) {
722            case EGL_READ: return c->read;
723            case EGL_DRAW: return c->draw;
724            default: return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
725        }
726    }
727    return EGL_NO_SURFACE;
728}
729
730EGLDisplay eglGetCurrentDisplay(void)
731{
732    // could be called before eglInitialize(), but we wouldn't have a context
733    // then, and this function would correctly return EGL_NO_DISPLAY.
734
735    clearError();
736
737    EGLContext ctx = getContext();
738    if (ctx) {
739        egl_context_t const * const c = get_context(ctx);
740        if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
741        return c->dpy;
742    }
743    return EGL_NO_DISPLAY;
744}
745
746EGLBoolean eglWaitGL(void)
747{
748    clearError();
749
750    egl_connection_t* const cnx = &gEGLImpl;
751    if (!cnx->dso)
752        return setError(EGL_BAD_CONTEXT, EGL_FALSE);
753
754    return cnx->egl.eglWaitGL();
755}
756
757EGLBoolean eglWaitNative(EGLint engine)
758{
759    clearError();
760
761    egl_connection_t* const cnx = &gEGLImpl;
762    if (!cnx->dso)
763        return setError(EGL_BAD_CONTEXT, EGL_FALSE);
764
765    return cnx->egl.eglWaitNative(engine);
766}
767
768EGLint eglGetError(void)
769{
770    EGLint err = EGL_SUCCESS;
771    egl_connection_t* const cnx = &gEGLImpl;
772    if (cnx->dso) {
773        err = cnx->egl.eglGetError();
774    }
775    if (err == EGL_SUCCESS) {
776        err = egl_tls_t::getError();
777    }
778    return err;
779}
780
781static __eglMustCastToProperFunctionPointerType findBuiltinGLWrapper(
782        const char* procname) {
783    const egl_connection_t* cnx = &gEGLImpl;
784    void* proc = NULL;
785
786    proc = dlsym(cnx->libGles2, procname);
787    if (proc) return (__eglMustCastToProperFunctionPointerType)proc;
788
789    proc = dlsym(cnx->libGles1, procname);
790    if (proc) return (__eglMustCastToProperFunctionPointerType)proc;
791
792    return NULL;
793}
794
795__eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname)
796{
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.
800
801    clearError();
802
803    if (egl_init_drivers() == EGL_FALSE) {
804        setError(EGL_BAD_PARAMETER, NULL);
805        return  NULL;
806    }
807
808    if (FILTER_EXTENSIONS(procname)) {
809        return NULL;
810    }
811
812    __eglMustCastToProperFunctionPointerType addr;
813    addr = findProcAddress(procname, sExtensionMap, NELEM(sExtensionMap));
814    if (addr) return addr;
815
816    addr = findBuiltinGLWrapper(procname);
817    if (addr) return addr;
818
819    // this protects accesses to sGLExtentionMap and sGLExtentionSlot
820    pthread_mutex_lock(&sExtensionMapMutex);
821
822        /*
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.
826         *
827         * For this reason, we return a "forwarder", a small stub that takes
828         * care of calling the function associated with the context
829         * currently bound.
830         *
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.
836         *
837         */
838
839        const String8 name(procname);
840        addr = sGLExtentionMap.valueFor(name);
841        const int slot = sGLExtentionSlot;
842
843        ALOGE_IF(slot >= MAX_NUMBER_OF_GL_EXTENSIONS,
844                "no more slots for eglGetProcAddress(\"%s\")",
845                procname);
846
847#if EGL_TRACE
848        gl_hooks_t *debugHooks = GLTrace_getGLHooks();
849#endif
850
851        if (!addr && (slot < MAX_NUMBER_OF_GL_EXTENSIONS)) {
852            bool found = false;
853
854            egl_connection_t* const cnx = &gEGLImpl;
855            if (cnx->dso && cnx->egl.eglGetProcAddress) {
856                // Extensions are independent of the bound context
857                addr =
858                cnx->hooks[egl_connection_t::GLESv1_INDEX]->ext.extensions[slot] =
859                cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[slot] =
860#if EGL_TRACE
861                debugHooks->ext.extensions[slot] =
862                gHooksTrace.ext.extensions[slot] =
863#endif
864                        cnx->egl.eglGetProcAddress(procname);
865                if (addr) found = true;
866            }
867
868            if (found) {
869                addr = gExtensionForwarders[slot];
870                sGLExtentionMap.add(name, addr);
871                sGLExtentionSlot++;
872            }
873        }
874
875    pthread_mutex_unlock(&sExtensionMapMutex);
876    return addr;
877}
878
879class FrameCompletionThread : public Thread {
880public:
881
882    static void queueSync(EGLSyncKHR sync) {
883        static sp<FrameCompletionThread> thread(new FrameCompletionThread);
884        static bool running = false;
885        if (!running) {
886            thread->run("GPUFrameCompletion");
887            running = true;
888        }
889        {
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());
897        }
898    }
899
900private:
901    FrameCompletionThread() : mFramesQueued(0), mFramesCompleted(0) {}
902
903    virtual bool threadLoop() {
904        EGLSyncKHR sync;
905        uint32_t frameNum;
906        {
907            Mutex::Autolock lock(mMutex);
908            while (mQueue.isEmpty()) {
909                mCondition.wait(mMutex);
910            }
911            sync = mQueue[0];
912            frameNum = mFramesCompleted;
913        }
914        EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
915        {
916            ScopedTrace st(ATRACE_TAG, String8::format("waiting for frame %d",
917                    frameNum).string());
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");
923            }
924            eglDestroySyncKHR(dpy, sync);
925        }
926        {
927            Mutex::Autolock lock(mMutex);
928            mQueue.removeAt(0);
929            mFramesCompleted++;
930            ATRACE_INT("GPU Frames Outstanding", mQueue.size());
931        }
932        return true;
933    }
934
935    uint32_t mFramesQueued;
936    uint32_t mFramesCompleted;
937    Vector<EGLSyncKHR> mQueue;
938    Condition mCondition;
939    Mutex mMutex;
940};
941
942EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw)
943{
944    ATRACE_CALL();
945    clearError();
946
947    const egl_display_ptr dp = validate_display(dpy);
948    if (!dp) return EGL_FALSE;
949
950    SurfaceRef _s(dp.get(), draw);
951    if (!_s.get())
952        return setError(EGL_BAD_SURFACE, EGL_FALSE);
953
954#if EGL_TRACE
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");
960                setEGLDebugLevel(0);
961            } else {
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);
965                if (c) {
966                    setGLHooksThreadSpecific(c->cnx->hooks[c->version]);
967                    GLTrace_eglMakeCurrent(c->version, c->cnx->hooks[c->version], ctx);
968                }
969            }
970        }
971
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]);
978        GLTrace_stop();
979    }
980#endif
981
982    egl_surface_t const * const s = get_surface(draw);
983
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);
988        }
989    }
990
991    if (CC_UNLIKELY(dp->finishOnSwap)) {
992        uint32_t pixel;
993        egl_context_t * const c = get_context( egl_tls_t::getContext() );
994        if (c) {
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);
998        }
999    }
1000
1001    return s->cnx->egl.eglSwapBuffers(dp->disp.dpy, s->surface);
1002}
1003
1004EGLBoolean eglCopyBuffers(  EGLDisplay dpy, EGLSurface surface,
1005                            NativePixmapType target)
1006{
1007    clearError();
1008
1009    const egl_display_ptr dp = validate_display(dpy);
1010    if (!dp) return EGL_FALSE;
1011
1012    SurfaceRef _s(dp.get(), surface);
1013    if (!_s.get())
1014        return setError(EGL_BAD_SURFACE, EGL_FALSE);
1015
1016    egl_surface_t const * const s = get_surface(surface);
1017    return s->cnx->egl.eglCopyBuffers(dp->disp.dpy, s->surface, target);
1018}
1019
1020const char* eglQueryString(EGLDisplay dpy, EGLint name)
1021{
1022    clearError();
1023
1024    const egl_display_ptr dp = validate_display(dpy);
1025    if (!dp) return (const char *) NULL;
1026
1027    switch (name) {
1028        case EGL_VENDOR:
1029            return dp->getVendorString();
1030        case EGL_VERSION:
1031            return dp->getVersionString();
1032        case EGL_EXTENSIONS:
1033            return dp->getExtensionString();
1034        case EGL_CLIENT_APIS:
1035            return dp->getClientApiString();
1036    }
1037    return setError(EGL_BAD_PARAMETER, (const char *)0);
1038}
1039
1040EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name)
1041{
1042    clearError();
1043
1044    const egl_display_ptr dp = validate_display(dpy);
1045    if (!dp) return (const char *) NULL;
1046
1047    switch (name) {
1048        case EGL_VENDOR:
1049            return dp->disp.queryString.vendor;
1050        case EGL_VERSION:
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;
1056    }
1057    return setError(EGL_BAD_PARAMETER, (const char *)0);
1058}
1059
1060// ----------------------------------------------------------------------------
1061// EGL 1.1
1062// ----------------------------------------------------------------------------
1063
1064EGLBoolean eglSurfaceAttrib(
1065        EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
1066{
1067    clearError();
1068
1069    const egl_display_ptr dp = validate_display(dpy);
1070    if (!dp) return EGL_FALSE;
1071
1072    SurfaceRef _s(dp.get(), surface);
1073    if (!_s.get())
1074        return setError(EGL_BAD_SURFACE, EGL_FALSE);
1075
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);
1080    }
1081    return setError(EGL_BAD_SURFACE, EGL_FALSE);
1082}
1083
1084EGLBoolean eglBindTexImage(
1085        EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1086{
1087    clearError();
1088
1089    const egl_display_ptr dp = validate_display(dpy);
1090    if (!dp) return EGL_FALSE;
1091
1092    SurfaceRef _s(dp.get(), surface);
1093    if (!_s.get())
1094        return setError(EGL_BAD_SURFACE, EGL_FALSE);
1095
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);
1100    }
1101    return setError(EGL_BAD_SURFACE, EGL_FALSE);
1102}
1103
1104EGLBoolean eglReleaseTexImage(
1105        EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1106{
1107    clearError();
1108
1109    const egl_display_ptr dp = validate_display(dpy);
1110    if (!dp) return EGL_FALSE;
1111
1112    SurfaceRef _s(dp.get(), surface);
1113    if (!_s.get())
1114        return setError(EGL_BAD_SURFACE, EGL_FALSE);
1115
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);
1120    }
1121    return setError(EGL_BAD_SURFACE, EGL_FALSE);
1122}
1123
1124EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)
1125{
1126    clearError();
1127
1128    const egl_display_ptr dp = validate_display(dpy);
1129    if (!dp) return EGL_FALSE;
1130
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);
1135    }
1136
1137    return res;
1138}
1139
1140
1141// ----------------------------------------------------------------------------
1142// EGL 1.2
1143// ----------------------------------------------------------------------------
1144
1145EGLBoolean eglWaitClient(void)
1146{
1147    clearError();
1148
1149    egl_connection_t* const cnx = &gEGLImpl;
1150    if (!cnx->dso)
1151        return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1152
1153    EGLBoolean res;
1154    if (cnx->egl.eglWaitClient) {
1155        res = cnx->egl.eglWaitClient();
1156    } else {
1157        res = cnx->egl.eglWaitGL();
1158    }
1159    return res;
1160}
1161
1162EGLBoolean eglBindAPI(EGLenum api)
1163{
1164    clearError();
1165
1166    if (egl_init_drivers() == EGL_FALSE) {
1167        return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1168    }
1169
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);
1175    }
1176    return res;
1177}
1178
1179EGLenum eglQueryAPI(void)
1180{
1181    clearError();
1182
1183    if (egl_init_drivers() == EGL_FALSE) {
1184        return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1185    }
1186
1187    egl_connection_t* const cnx = &gEGLImpl;
1188    if (cnx->dso && cnx->egl.eglQueryAPI) {
1189        return cnx->egl.eglQueryAPI();
1190    }
1191
1192    // or, it can only be OpenGL ES
1193    return EGL_OPENGL_ES_API;
1194}
1195
1196EGLBoolean eglReleaseThread(void)
1197{
1198    clearError();
1199
1200#if EGL_TRACE
1201    if (getEGLDebugLevel() > 0)
1202        GLTrace_eglReleaseThread();
1203#endif
1204
1205    // If there is context bound to the thread, release it
1206    egl_display_t::loseCurrent(get_context(getContext()));
1207
1208    egl_connection_t* const cnx = &gEGLImpl;
1209    if (cnx->dso && cnx->egl.eglReleaseThread) {
1210        cnx->egl.eglReleaseThread();
1211    }
1212    egl_tls_t::clearTLS();
1213    return EGL_TRUE;
1214}
1215
1216EGLSurface eglCreatePbufferFromClientBuffer(
1217          EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
1218          EGLConfig config, const EGLint *attrib_list)
1219{
1220    clearError();
1221
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);
1228    }
1229    return setError(EGL_BAD_CONFIG, EGL_NO_SURFACE);
1230}
1231
1232// ----------------------------------------------------------------------------
1233// EGL_EGLEXT_VERSION 3
1234// ----------------------------------------------------------------------------
1235
1236EGLBoolean eglLockSurfaceKHR(EGLDisplay dpy, EGLSurface surface,
1237        const EGLint *attrib_list)
1238{
1239    clearError();
1240
1241    const egl_display_ptr dp = validate_display(dpy);
1242    if (!dp) return EGL_FALSE;
1243
1244    SurfaceRef _s(dp.get(), surface);
1245    if (!_s.get())
1246        return setError(EGL_BAD_SURFACE, EGL_FALSE);
1247
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);
1252    }
1253    return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1254}
1255
1256EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface)
1257{
1258    clearError();
1259
1260    const egl_display_ptr dp = validate_display(dpy);
1261    if (!dp) return EGL_FALSE;
1262
1263    SurfaceRef _s(dp.get(), surface);
1264    if (!_s.get())
1265        return setError(EGL_BAD_SURFACE, EGL_FALSE);
1266
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);
1270    }
1271    return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1272}
1273
1274EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
1275        EGLClientBuffer buffer, const EGLint *attrib_list)
1276{
1277    clearError();
1278
1279    const egl_display_ptr dp = validate_display(dpy);
1280    if (!dp) return EGL_NO_IMAGE_KHR;
1281
1282    ContextRef _c(dp.get(), ctx);
1283    egl_context_t * const c = _c.get();
1284
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(
1289                dp->disp.dpy,
1290                c ? c->context : EGL_NO_CONTEXT,
1291                target, buffer, attrib_list);
1292    }
1293    return result;
1294}
1295
1296EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img)
1297{
1298    clearError();
1299
1300    const egl_display_ptr dp = validate_display(dpy);
1301    if (!dp) return EGL_FALSE;
1302
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);
1307    }
1308    return result;
1309}
1310
1311// ----------------------------------------------------------------------------
1312// EGL_EGLEXT_VERSION 5
1313// ----------------------------------------------------------------------------
1314
1315
1316EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
1317{
1318    clearError();
1319
1320    const egl_display_ptr dp = validate_display(dpy);
1321    if (!dp) return EGL_NO_SYNC_KHR;
1322
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);
1327    }
1328    return result;
1329}
1330
1331EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
1332{
1333    clearError();
1334
1335    const egl_display_ptr dp = validate_display(dpy);
1336    if (!dp) return EGL_FALSE;
1337
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);
1342    }
1343    return result;
1344}
1345
1346EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) {
1347    clearError();
1348
1349    const egl_display_ptr dp = validate_display(dpy);
1350    if (!dp) return EGL_FALSE;
1351
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);
1357    }
1358    return result;
1359}
1360
1361EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync,
1362        EGLint flags, EGLTimeKHR timeout)
1363{
1364    clearError();
1365
1366    const egl_display_ptr dp = validate_display(dpy);
1367    if (!dp) return EGL_FALSE;
1368
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);
1374    }
1375    return result;
1376}
1377
1378EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync,
1379        EGLint attribute, EGLint *value)
1380{
1381    clearError();
1382
1383    const egl_display_ptr dp = validate_display(dpy);
1384    if (!dp) return EGL_FALSE;
1385
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);
1391    }
1392    return result;
1393}
1394
1395// ----------------------------------------------------------------------------
1396// EGL_EGLEXT_VERSION 15
1397// ----------------------------------------------------------------------------
1398
1399EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) {
1400    clearError();
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);
1407    }
1408    return result;
1409}
1410
1411// ----------------------------------------------------------------------------
1412// ANDROID extensions
1413// ----------------------------------------------------------------------------
1414
1415EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync)
1416{
1417    clearError();
1418
1419    const egl_display_ptr dp = validate_display(dpy);
1420    if (!dp) return EGL_NO_NATIVE_FENCE_FD_ANDROID;
1421
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);
1426    }
1427    return result;
1428}
1429
1430EGLBoolean eglPresentationTimeANDROID(EGLDisplay dpy, EGLSurface surface,
1431        EGLnsecsANDROID time)
1432{
1433    clearError();
1434
1435    const egl_display_ptr dp = validate_display(dpy);
1436    if (!dp) {
1437        return EGL_FALSE;
1438    }
1439
1440    SurfaceRef _s(dp.get(), surface);
1441    if (!_s.get()) {
1442        setError(EGL_BAD_SURFACE, EGL_FALSE);
1443        return EGL_FALSE;
1444    }
1445
1446    egl_surface_t const * const s = get_surface(surface);
1447    native_window_set_buffers_timestamp(s->win.get(), time);
1448
1449    return EGL_TRUE;
1450}
1451
1452// ----------------------------------------------------------------------------
1453// NVIDIA extensions
1454// ----------------------------------------------------------------------------
1455EGLuint64NV eglGetSystemTimeFrequencyNV()
1456{
1457    clearError();
1458
1459    if (egl_init_drivers() == EGL_FALSE) {
1460        return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1461    }
1462
1463    EGLuint64NV ret = 0;
1464    egl_connection_t* const cnx = &gEGLImpl;
1465
1466    if (cnx->dso && cnx->egl.eglGetSystemTimeFrequencyNV) {
1467        return cnx->egl.eglGetSystemTimeFrequencyNV();
1468    }
1469
1470    return setErrorQuiet(EGL_BAD_DISPLAY, 0);
1471}
1472
1473EGLuint64NV eglGetSystemTimeNV()
1474{
1475    clearError();
1476
1477    if (egl_init_drivers() == EGL_FALSE) {
1478        return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1479    }
1480
1481    EGLuint64NV ret = 0;
1482    egl_connection_t* const cnx = &gEGLImpl;
1483
1484    if (cnx->dso && cnx->egl.eglGetSystemTimeNV) {
1485        return cnx->egl.eglGetSystemTimeNV();
1486    }
1487
1488    return setErrorQuiet(EGL_BAD_DISPLAY, 0);
1489}
1490