blob: 1be4961e3f5c4411671791616188c8c92821b5d9 [file] [log] [blame]
Jesse Hall47743382013-02-08 11:13:46 -08001/*
Mathias Agopian518ec112011-05-13 16:21:08 -07002 ** Copyright 2007, The Android Open Source Project
3 **
Jesse Hall47743382013-02-08 11:13:46 -08004 ** 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
Mathias Agopian518ec112011-05-13 16:21:08 -07007 **
Jesse Hall47743382013-02-08 11:13:46 -08008 ** http://www.apache.org/licenses/LICENSE-2.0
Mathias Agopian518ec112011-05-13 16:21:08 -07009 **
Jesse Hall47743382013-02-08 11:13:46 -080010 ** 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
Mathias Agopian518ec112011-05-13 16:21:08 -070014 ** limitations under the License.
15 */
16
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080017#define ATRACE_TAG ATRACE_TAG_GRAPHICS
18
Mathias Agopian518ec112011-05-13 16:21:08 -070019#include <ctype.h>
20#include <stdlib.h>
21#include <string.h>
22
23#include <hardware/gralloc.h>
24#include <system/window.h>
25
26#include <EGL/egl.h>
27#include <EGL/eglext.h>
Mathias Agopian518ec112011-05-13 16:21:08 -070028
29#include <cutils/log.h>
30#include <cutils/atomic.h>
Mathias Agopian7db993a2012-03-25 00:49:46 -070031#include <cutils/compiler.h>
Mathias Agopian518ec112011-05-13 16:21:08 -070032#include <cutils/properties.h>
33#include <cutils/memory.h>
34
35#include <utils/KeyedVector.h>
36#include <utils/SortedVector.h>
37#include <utils/String8.h>
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080038#include <utils/Trace.h>
Mathias Agopian518ec112011-05-13 16:21:08 -070039
40#include "egl_impl.h"
41#include "egl_tls.h"
Siva Velusamy0469dd62011-11-30 15:05:37 -080042#include "glestrace.h"
Mathias Agopian518ec112011-05-13 16:21:08 -070043#include "hooks.h"
44
45#include "egl_display.h"
46#include "egl_impl.h"
47#include "egl_object.h"
48#include "egl_tls.h"
Mathias Agopianada798b2012-02-13 17:09:30 -080049#include "egldefs.h"
Mathias Agopian518ec112011-05-13 16:21:08 -070050
51using namespace android;
52
53// ----------------------------------------------------------------------------
54
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -070055namespace android {
56
Mathias Agopian518ec112011-05-13 16:21:08 -070057struct extention_map_t {
58 const char* name;
59 __eglMustCastToProperFunctionPointerType address;
60};
61
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -070062/*
63 * This is the list of EGL extensions exposed to applications,
64 * some of them are mandatory because used by the ANDROID system.
65 *
66 * Mandatory extensions are required per the CDD and not explicitly
67 * checked during EGL initialization. the system *assumes* these extensions
68 * are present. the system may not function properly if some mandatory
69 * extensions are missing.
70 *
71 * NOTE: gExtensionString MUST have a single space as the last character.
72 */
73extern char const * const gExtensionString =
74 "EGL_KHR_image " // mandatory
75 "EGL_KHR_image_base " // mandatory
76 "EGL_KHR_image_pixmap "
77 "EGL_KHR_lock_surface "
78 "EGL_KHR_gl_texture_2D_image "
79 "EGL_KHR_gl_texture_cubemap_image "
80 "EGL_KHR_gl_renderbuffer_image "
81 "EGL_KHR_reusable_sync "
82 "EGL_KHR_fence_sync "
83 "EGL_EXT_create_context_robustness "
84 "EGL_NV_system_time "
85 "EGL_ANDROID_image_native_buffer " // mandatory
Mathias Agopian2bb71682013-03-27 17:32:41 -070086 "EGL_KHR_wait_sync " // strongly recommended
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -070087 "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
Mathias Agopian518ec112011-05-13 16:21:08 -0700105 { "eglLockSurfaceKHR",
106 (__eglMustCastToProperFunctionPointerType)&eglLockSurfaceKHR },
107 { "eglUnlockSurfaceKHR",
108 (__eglMustCastToProperFunctionPointerType)&eglUnlockSurfaceKHR },
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -0700109
110 // EGL_KHR_image, EGL_KHR_image_base
Mathias Agopian518ec112011-05-13 16:21:08 -0700111 { "eglCreateImageKHR",
112 (__eglMustCastToProperFunctionPointerType)&eglCreateImageKHR },
113 { "eglDestroyImageKHR",
114 (__eglMustCastToProperFunctionPointerType)&eglDestroyImageKHR },
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -0700115
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
Jonas Yang1c3d72a2011-08-26 20:04:39 +0800129 { "eglGetSystemTimeFrequencyNV",
130 (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeFrequencyNV },
131 { "eglGetSystemTimeNV",
132 (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeNV },
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -0700133
Mathias Agopian2bb71682013-03-27 17:32:41 -0700134 // EGL_KHR_wait_sync
135 { "eglWaitSyncKHR",
136 (__eglMustCastToProperFunctionPointerType)&eglWaitSyncKHR },
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -0700137
138 // EGL_ANDROID_presentation_time
139 { "eglPresentationTimeANDROID",
140 (__eglMustCastToProperFunctionPointerType)&eglPresentationTimeANDROID },
Mathias Agopian518ec112011-05-13 16:21:08 -0700141};
142
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -0700143/*
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
Mathias Agopian518ec112011-05-13 16:21:08 -0700155// 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
Mathias Agopian518ec112011-05-13 16:21:08 -0700172extern void setGLHooksThreadSpecific(gl_hooks_t const *value);
173extern EGLBoolean egl_init_drivers();
174extern const __eglMustCastToProperFunctionPointerType gExtensionForwarders[MAX_NUMBER_OF_GL_EXTENSIONS];
Siva Velusamya73a9772012-12-18 14:56:55 -0800175extern int getEGLDebugLevel();
176extern void setEGLDebugLevel(int level);
Mathias Agopian518ec112011-05-13 16:21:08 -0700177extern gl_hooks_t gHooksTrace;
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -0700178
Mathias Agopian518ec112011-05-13 16:21:08 -0700179} // namespace android;
180
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -0700181
Mathias Agopian518ec112011-05-13 16:21:08 -0700182// ----------------------------------------------------------------------------
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
Jesse Hallb29e5e82012-04-04 16:53:42 -0700214 egl_display_ptr dp = get_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -0700215 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
Jesse Hallb29e5e82012-04-04 16:53:42 -0700230 egl_display_ptr dp = get_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -0700231 if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
232
233 EGLBoolean res = dp->terminate();
Jesse Hall47743382013-02-08 11:13:46 -0800234
Mathias Agopian518ec112011-05-13 16:21:08 -0700235 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
Jesse Hallb29e5e82012-04-04 16:53:42 -0700248 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -0700249 if (!dp) return EGL_FALSE;
250
Mathias Agopian7773c432012-02-13 20:06:08 -0800251 if (num_config==0) {
252 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
Mathias Agopian518ec112011-05-13 16:21:08 -0700253 }
254
Mathias Agopian7773c432012-02-13 20:06:08 -0800255 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);
Mathias Agopian518ec112011-05-13 16:21:08 -0700262 }
Mathias Agopian7773c432012-02-13 20:06:08 -0800263
264 return res;
Mathias Agopian518ec112011-05-13 16:21:08 -0700265}
266
267EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list,
268 EGLConfig *configs, EGLint config_size,
269 EGLint *num_config)
270{
271 clearError();
272
Jesse Hallb29e5e82012-04-04 16:53:42 -0700273 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -0700274 if (!dp) return EGL_FALSE;
275
276 if (num_config==0) {
277 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
278 }
279
Mathias Agopian518ec112011-05-13 16:21:08 -0700280 EGLBoolean res = EGL_FALSE;
281 *num_config = 0;
282
Mathias Agopianada798b2012-02-13 17:09:30 -0800283 egl_connection_t* const cnx = &gEGLImpl;
284 if (cnx->dso) {
Romain Guy1cffc802012-10-15 18:13:05 -0700285 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
Romain Guybe3c3e42012-10-15 19:25:18 -0700294 // if no caveat is requested
Romain Guy1cffc802012-10-15 18:13:05 -0700295 const EGLint *attribRendererable = NULL;
296 const EGLint *attribCaveat = NULL;
297
298 // Count the number of attributes and look for
Romain Guybe3c3e42012-10-15 19:25:18 -0700299 // EGL_RENDERABLE_TYPE and EGL_CONFIG_CAVEAT
Romain Guy1cffc802012-10-15 18:13:05 -0700300 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)) {
Jesse Hall47743382013-02-08 11:13:46 -0800315
Romain Guy1cffc802012-10-15 18:13:05 -0700316 // 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
Mathias Agopian7773c432012-02-13 20:06:08 -0800338 res = cnx->egl.eglChooseConfig(
339 dp->disp.dpy, attrib_list, configs, config_size, num_config);
Mathias Agopian518ec112011-05-13 16:21:08 -0700340 }
341 return res;
342}
343
344EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
345 EGLint attribute, EGLint *value)
346{
347 clearError();
348
Jesse Hallb29e5e82012-04-04 16:53:42 -0700349 egl_connection_t* cnx = NULL;
350 const egl_display_ptr dp = validate_display_connection(dpy, cnx);
351 if (!dp) return EGL_FALSE;
Jesse Hall47743382013-02-08 11:13:46 -0800352
Mathias Agopian518ec112011-05-13 16:21:08 -0700353 return cnx->egl.eglGetConfigAttrib(
Mathias Agopian7773c432012-02-13 20:06:08 -0800354 dp->disp.dpy, config, attribute, value);
Mathias Agopian518ec112011-05-13 16:21:08 -0700355}
356
357// ----------------------------------------------------------------------------
358// surfaces
359// ----------------------------------------------------------------------------
360
361EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config,
362 NativeWindowType window,
363 const EGLint *attrib_list)
364{
365 clearError();
366
Jesse Hallb29e5e82012-04-04 16:53:42 -0700367 egl_connection_t* cnx = NULL;
368 egl_display_ptr dp = validate_display_connection(dpy, cnx);
369 if (dp) {
Mathias Agopianada798b2012-02-13 17:09:30 -0800370 EGLDisplay iDpy = dp->disp.dpy;
Mathias Agopian518ec112011-05-13 16:21:08 -0700371 EGLint format;
372
Mathias Agopian81a63352011-07-29 17:55:48 -0700373 if (native_window_api_connect(window, NATIVE_WINDOW_API_EGL) != OK) {
Steve Blocke6f43dd2012-01-06 19:20:56 +0000374 ALOGE("EGLNativeWindowType %p already connected to another API",
Mathias Agopian81a63352011-07-29 17:55:48 -0700375 window);
376 return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
377 }
378
Mathias Agopian518ec112011-05-13 16:21:08 -0700379 // set the native window's buffers format to match this config
380 if (cnx->egl.eglGetConfigAttrib(iDpy,
Mathias Agopian7773c432012-02-13 20:06:08 -0800381 config, EGL_NATIVE_VISUAL_ID, &format)) {
Mathias Agopian518ec112011-05-13 16:21:08 -0700382 if (format != 0) {
Jamie Gennisbee205f2011-07-01 13:12:07 -0700383 int err = native_window_set_buffers_format(window, format);
384 if (err != 0) {
Steve Blocke6f43dd2012-01-06 19:20:56 +0000385 ALOGE("error setting native window pixel format: %s (%d)",
Jamie Gennisbee205f2011-07-01 13:12:07 -0700386 strerror(-err), err);
Mathias Agopian81a63352011-07-29 17:55:48 -0700387 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
Jamie Gennisbee205f2011-07-01 13:12:07 -0700388 return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
389 }
Mathias Agopian518ec112011-05-13 16:21:08 -0700390 }
391 }
392
Jamie Gennis59769462011-11-19 18:04:43 -0800393 // 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
Mathias Agopian518ec112011-05-13 16:21:08 -0700398 EGLSurface surface = cnx->egl.eglCreateWindowSurface(
Mathias Agopian7773c432012-02-13 20:06:08 -0800399 iDpy, config, window, attrib_list);
Mathias Agopian518ec112011-05-13 16:21:08 -0700400 if (surface != EGL_NO_SURFACE) {
Jesse Hallb29e5e82012-04-04 16:53:42 -0700401 egl_surface_t* s = new egl_surface_t(dp.get(), config, window,
402 surface, cnx);
Mathias Agopian518ec112011-05-13 16:21:08 -0700403 return s;
404 }
Mathias Agopian81a63352011-07-29 17:55:48 -0700405
406 // EGLSurface creation failed
407 native_window_set_buffers_format(window, 0);
408 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
Mathias Agopian518ec112011-05-13 16:21:08 -0700409 }
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
Jesse Hallb29e5e82012-04-04 16:53:42 -0700419 egl_connection_t* cnx = NULL;
420 egl_display_ptr dp = validate_display_connection(dpy, cnx);
421 if (dp) {
Mathias Agopian518ec112011-05-13 16:21:08 -0700422 EGLSurface surface = cnx->egl.eglCreatePixmapSurface(
Mathias Agopian7773c432012-02-13 20:06:08 -0800423 dp->disp.dpy, config, pixmap, attrib_list);
Mathias Agopian518ec112011-05-13 16:21:08 -0700424 if (surface != EGL_NO_SURFACE) {
Jesse Hallb29e5e82012-04-04 16:53:42 -0700425 egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL,
426 surface, cnx);
Mathias Agopian518ec112011-05-13 16:21:08 -0700427 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
Jesse Hallb29e5e82012-04-04 16:53:42 -0700438 egl_connection_t* cnx = NULL;
439 egl_display_ptr dp = validate_display_connection(dpy, cnx);
440 if (dp) {
Mathias Agopian518ec112011-05-13 16:21:08 -0700441 EGLSurface surface = cnx->egl.eglCreatePbufferSurface(
Mathias Agopian7773c432012-02-13 20:06:08 -0800442 dp->disp.dpy, config, attrib_list);
Mathias Agopian518ec112011-05-13 16:21:08 -0700443 if (surface != EGL_NO_SURFACE) {
Jesse Hallb29e5e82012-04-04 16:53:42 -0700444 egl_surface_t* s = new egl_surface_t(dp.get(), config, NULL,
445 surface, cnx);
Mathias Agopian518ec112011-05-13 16:21:08 -0700446 return s;
447 }
448 }
449 return EGL_NO_SURFACE;
450}
Jesse Hall47743382013-02-08 11:13:46 -0800451
Mathias Agopian518ec112011-05-13 16:21:08 -0700452EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
453{
454 clearError();
455
Jesse Hallb29e5e82012-04-04 16:53:42 -0700456 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -0700457 if (!dp) return EGL_FALSE;
458
Jesse Hallb29e5e82012-04-04 16:53:42 -0700459 SurfaceRef _s(dp.get(), surface);
Mathias Agopian5b287a62011-05-16 18:58:55 -0700460 if (!_s.get())
461 return setError(EGL_BAD_SURFACE, EGL_FALSE);
Mathias Agopian518ec112011-05-13 16:21:08 -0700462
463 egl_surface_t * const s = get_surface(surface);
Mathias Agopianada798b2012-02-13 17:09:30 -0800464 EGLBoolean result = s->cnx->egl.eglDestroySurface(dp->disp.dpy, s->surface);
Mathias Agopian518ec112011-05-13 16:21:08 -0700465 if (result == EGL_TRUE) {
Mathias Agopian518ec112011-05-13 16:21:08 -0700466 _s.terminate();
467 }
468 return result;
469}
470
471EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface surface,
472 EGLint attribute, EGLint *value)
473{
474 clearError();
475
Jesse Hallb29e5e82012-04-04 16:53:42 -0700476 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -0700477 if (!dp) return EGL_FALSE;
478
Jesse Hallb29e5e82012-04-04 16:53:42 -0700479 SurfaceRef _s(dp.get(), surface);
Mathias Agopian5b287a62011-05-16 18:58:55 -0700480 if (!_s.get())
481 return setError(EGL_BAD_SURFACE, EGL_FALSE);
Mathias Agopian518ec112011-05-13 16:21:08 -0700482
Mathias Agopian518ec112011-05-13 16:21:08 -0700483 egl_surface_t const * const s = get_surface(surface);
Mathias Agopian7773c432012-02-13 20:06:08 -0800484 return s->cnx->egl.eglQuerySurface(
485 dp->disp.dpy, s->surface, attribute, value);
Mathias Agopian518ec112011-05-13 16:21:08 -0700486}
487
Jamie Gennise8696a42012-01-15 18:54:57 -0800488void EGLAPI eglBeginFrame(EGLDisplay dpy, EGLSurface surface) {
Jamie Gennis1c8e95c2012-02-23 19:27:23 -0800489 ATRACE_CALL();
Jamie Gennise8696a42012-01-15 18:54:57 -0800490 clearError();
491
Jesse Hallb29e5e82012-04-04 16:53:42 -0700492 const egl_display_ptr dp = validate_display(dpy);
Jamie Gennise8696a42012-01-15 18:54:57 -0800493 if (!dp) {
494 return;
495 }
496
Jesse Hallb29e5e82012-04-04 16:53:42 -0700497 SurfaceRef _s(dp.get(), surface);
Jamie Gennise8696a42012-01-15 18:54:57 -0800498 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
Mathias Agopian518ec112011-05-13 16:21:08 -0700509// ----------------------------------------------------------------------------
510// Contexts
511// ----------------------------------------------------------------------------
512
513EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,
514 EGLContext share_list, const EGLint *attrib_list)
515{
516 clearError();
517
Jesse Hallb29e5e82012-04-04 16:53:42 -0700518 egl_connection_t* cnx = NULL;
519 const egl_display_ptr dp = validate_display_connection(dpy, cnx);
520 if (dpy) {
Mathias Agopian518ec112011-05-13 16:21:08 -0700521 if (share_list != EGL_NO_CONTEXT) {
522 egl_context_t* const c = get_context(share_list);
523 share_list = c->context;
524 }
525 EGLContext context = cnx->egl.eglCreateContext(
Mathias Agopian7773c432012-02-13 20:06:08 -0800526 dp->disp.dpy, config, share_list, attrib_list);
Mathias Agopian518ec112011-05-13 16:21:08 -0700527 if (context != EGL_NO_CONTEXT) {
528 // figure out if it's a GLESv1 or GLESv2
529 int version = 0;
530 if (attrib_list) {
531 while (*attrib_list != EGL_NONE) {
532 GLint attr = *attrib_list++;
533 GLint value = *attrib_list++;
534 if (attr == EGL_CONTEXT_CLIENT_VERSION) {
535 if (value == 1) {
Mathias Agopian7773c432012-02-13 20:06:08 -0800536 version = egl_connection_t::GLESv1_INDEX;
Jesse Hall47743382013-02-08 11:13:46 -0800537 } else if (value == 2 || value == 3) {
Mathias Agopian7773c432012-02-13 20:06:08 -0800538 version = egl_connection_t::GLESv2_INDEX;
Mathias Agopian518ec112011-05-13 16:21:08 -0700539 }
540 }
541 };
542 }
Jesse Hallb29e5e82012-04-04 16:53:42 -0700543 egl_context_t* c = new egl_context_t(dpy, context, config, cnx,
544 version);
Siva Velusamy0469dd62011-11-30 15:05:37 -0800545#if EGL_TRACE
Siva Velusamya73a9772012-12-18 14:56:55 -0800546 if (getEGLDebugLevel() > 0)
Siva Velusamy0469dd62011-11-30 15:05:37 -0800547 GLTrace_eglCreateContext(version, c);
548#endif
Mathias Agopian518ec112011-05-13 16:21:08 -0700549 return c;
Mathias Agopian500407a2012-09-24 17:57:48 -0700550 } else {
551 EGLint error = eglGetError();
552 ALOGE_IF(error == EGL_SUCCESS,
553 "eglCreateContext(%p, %p, %p, %p) returned EGL_NO_CONTEXT "
554 "but no EGL error!",
555 dpy, config, share_list, attrib_list);
Mathias Agopian518ec112011-05-13 16:21:08 -0700556 }
557 }
558 return EGL_NO_CONTEXT;
559}
560
561EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
562{
563 clearError();
564
Jesse Hallb29e5e82012-04-04 16:53:42 -0700565 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian5b287a62011-05-16 18:58:55 -0700566 if (!dp)
567 return EGL_FALSE;
Mathias Agopian518ec112011-05-13 16:21:08 -0700568
Jesse Hallb29e5e82012-04-04 16:53:42 -0700569 ContextRef _c(dp.get(), ctx);
Mathias Agopian5b287a62011-05-16 18:58:55 -0700570 if (!_c.get())
571 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
Jesse Hall47743382013-02-08 11:13:46 -0800572
Mathias Agopian518ec112011-05-13 16:21:08 -0700573 egl_context_t * const c = get_context(ctx);
Mathias Agopianada798b2012-02-13 17:09:30 -0800574 EGLBoolean result = c->cnx->egl.eglDestroyContext(dp->disp.dpy, c->context);
Mathias Agopian518ec112011-05-13 16:21:08 -0700575 if (result == EGL_TRUE) {
576 _c.terminate();
577 }
578 return result;
579}
580
Mathias Agopian518ec112011-05-13 16:21:08 -0700581EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw,
582 EGLSurface read, EGLContext ctx)
583{
584 clearError();
585
Jesse Hallb29e5e82012-04-04 16:53:42 -0700586 egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -0700587 if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
588
Mathias Agopian5b287a62011-05-16 18:58:55 -0700589 // If ctx is not EGL_NO_CONTEXT, read is not EGL_NO_SURFACE, or draw is not
590 // EGL_NO_SURFACE, then an EGL_NOT_INITIALIZED error is generated if dpy is
591 // a valid but uninitialized display.
Mathias Agopian518ec112011-05-13 16:21:08 -0700592 if ( (ctx != EGL_NO_CONTEXT) || (read != EGL_NO_SURFACE) ||
593 (draw != EGL_NO_SURFACE) ) {
594 if (!dp->isReady()) return setError(EGL_NOT_INITIALIZED, EGL_FALSE);
595 }
596
597 // get a reference to the object passed in
Jesse Hallb29e5e82012-04-04 16:53:42 -0700598 ContextRef _c(dp.get(), ctx);
599 SurfaceRef _d(dp.get(), draw);
600 SurfaceRef _r(dp.get(), read);
Mathias Agopian518ec112011-05-13 16:21:08 -0700601
602 // validate the context (if not EGL_NO_CONTEXT)
Mathias Agopian5b287a62011-05-16 18:58:55 -0700603 if ((ctx != EGL_NO_CONTEXT) && !_c.get()) {
Mathias Agopian518ec112011-05-13 16:21:08 -0700604 // EGL_NO_CONTEXT is valid
605 return EGL_FALSE;
606 }
607
608 // these are the underlying implementation's object
609 EGLContext impl_ctx = EGL_NO_CONTEXT;
610 EGLSurface impl_draw = EGL_NO_SURFACE;
611 EGLSurface impl_read = EGL_NO_SURFACE;
612
613 // these are our objects structs passed in
614 egl_context_t * c = NULL;
615 egl_surface_t const * d = NULL;
616 egl_surface_t const * r = NULL;
617
618 // these are the current objects structs
619 egl_context_t * cur_c = get_context(getContext());
Jesse Hall47743382013-02-08 11:13:46 -0800620
Mathias Agopian518ec112011-05-13 16:21:08 -0700621 if (ctx != EGL_NO_CONTEXT) {
622 c = get_context(ctx);
623 impl_ctx = c->context;
624 } else {
625 // no context given, use the implementation of the current context
626 if (cur_c == NULL) {
627 // no current context
628 if (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE) {
629 // calling eglMakeCurrent( ..., !=0, !=0, EGL_NO_CONTEXT);
630 return setError(EGL_BAD_MATCH, EGL_FALSE);
631 }
632 // not an error, there is just no current context.
633 return EGL_TRUE;
634 }
635 }
636
637 // retrieve the underlying implementation's draw EGLSurface
638 if (draw != EGL_NO_SURFACE) {
639 d = get_surface(draw);
Mathias Agopian518ec112011-05-13 16:21:08 -0700640 impl_draw = d->surface;
641 }
642
643 // retrieve the underlying implementation's read EGLSurface
644 if (read != EGL_NO_SURFACE) {
645 r = get_surface(read);
Mathias Agopian518ec112011-05-13 16:21:08 -0700646 impl_read = r->surface;
647 }
648
Mathias Agopian518ec112011-05-13 16:21:08 -0700649
Jesse Hallb29e5e82012-04-04 16:53:42 -0700650 EGLBoolean result = dp->makeCurrent(c, cur_c,
Mathias Agopianfb87e542012-01-30 18:20:52 -0800651 draw, read, ctx,
652 impl_draw, impl_read, impl_ctx);
Mathias Agopian518ec112011-05-13 16:21:08 -0700653
654 if (result == EGL_TRUE) {
Mathias Agopianfb87e542012-01-30 18:20:52 -0800655 if (c) {
Mathias Agopian518ec112011-05-13 16:21:08 -0700656 setGLHooksThreadSpecific(c->cnx->hooks[c->version]);
657 egl_tls_t::setContext(ctx);
Siva Velusamy0469dd62011-11-30 15:05:37 -0800658#if EGL_TRACE
Siva Velusamya73a9772012-12-18 14:56:55 -0800659 if (getEGLDebugLevel() > 0)
Siva Velusamy93a826f2011-12-14 12:19:56 -0800660 GLTrace_eglMakeCurrent(c->version, c->cnx->hooks[c->version], ctx);
Siva Velusamy0469dd62011-11-30 15:05:37 -0800661#endif
Mathias Agopian518ec112011-05-13 16:21:08 -0700662 _c.acquire();
663 _r.acquire();
664 _d.acquire();
Mathias Agopian518ec112011-05-13 16:21:08 -0700665 } else {
666 setGLHooksThreadSpecific(&gHooksNoContext);
667 egl_tls_t::setContext(EGL_NO_CONTEXT);
668 }
Mathias Agopian5fecea72011-08-25 18:38:24 -0700669 } else {
Steve Blocke6f43dd2012-01-06 19:20:56 +0000670 // this will ALOGE the error
Mathias Agopian5fecea72011-08-25 18:38:24 -0700671 result = setError(c->cnx->egl.eglGetError(), EGL_FALSE);
Mathias Agopian518ec112011-05-13 16:21:08 -0700672 }
673 return result;
674}
675
676
677EGLBoolean eglQueryContext( EGLDisplay dpy, EGLContext ctx,
678 EGLint attribute, EGLint *value)
679{
680 clearError();
681
Jesse Hallb29e5e82012-04-04 16:53:42 -0700682 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -0700683 if (!dp) return EGL_FALSE;
684
Jesse Hallb29e5e82012-04-04 16:53:42 -0700685 ContextRef _c(dp.get(), ctx);
Mathias Agopian518ec112011-05-13 16:21:08 -0700686 if (!_c.get()) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
687
Mathias Agopian518ec112011-05-13 16:21:08 -0700688 egl_context_t * const c = get_context(ctx);
Mathias Agopian7773c432012-02-13 20:06:08 -0800689 return c->cnx->egl.eglQueryContext(
690 dp->disp.dpy, c->context, attribute, value);
Mathias Agopian518ec112011-05-13 16:21:08 -0700691
Mathias Agopian518ec112011-05-13 16:21:08 -0700692}
693
694EGLContext eglGetCurrentContext(void)
695{
696 // could be called before eglInitialize(), but we wouldn't have a context
697 // then, and this function would correctly return EGL_NO_CONTEXT.
698
699 clearError();
700
701 EGLContext ctx = getContext();
702 return ctx;
703}
704
705EGLSurface eglGetCurrentSurface(EGLint readdraw)
706{
707 // could be called before eglInitialize(), but we wouldn't have a context
708 // then, and this function would correctly return EGL_NO_SURFACE.
709
710 clearError();
711
712 EGLContext ctx = getContext();
713 if (ctx) {
714 egl_context_t const * const c = get_context(ctx);
715 if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
716 switch (readdraw) {
717 case EGL_READ: return c->read;
Jesse Hall47743382013-02-08 11:13:46 -0800718 case EGL_DRAW: return c->draw;
Mathias Agopian518ec112011-05-13 16:21:08 -0700719 default: return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
720 }
721 }
722 return EGL_NO_SURFACE;
723}
724
725EGLDisplay eglGetCurrentDisplay(void)
726{
727 // could be called before eglInitialize(), but we wouldn't have a context
728 // then, and this function would correctly return EGL_NO_DISPLAY.
729
730 clearError();
731
732 EGLContext ctx = getContext();
733 if (ctx) {
734 egl_context_t const * const c = get_context(ctx);
735 if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
736 return c->dpy;
737 }
738 return EGL_NO_DISPLAY;
739}
740
741EGLBoolean eglWaitGL(void)
742{
Mathias Agopian518ec112011-05-13 16:21:08 -0700743 clearError();
744
Mathias Agopianada798b2012-02-13 17:09:30 -0800745 egl_connection_t* const cnx = &gEGLImpl;
746 if (!cnx->dso)
747 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
748
749 return cnx->egl.eglWaitGL();
Mathias Agopian518ec112011-05-13 16:21:08 -0700750}
751
752EGLBoolean eglWaitNative(EGLint engine)
753{
Mathias Agopian518ec112011-05-13 16:21:08 -0700754 clearError();
755
Mathias Agopianada798b2012-02-13 17:09:30 -0800756 egl_connection_t* const cnx = &gEGLImpl;
757 if (!cnx->dso)
758 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
759
760 return cnx->egl.eglWaitNative(engine);
Mathias Agopian518ec112011-05-13 16:21:08 -0700761}
762
763EGLint eglGetError(void)
764{
Mathias Agopianada798b2012-02-13 17:09:30 -0800765 EGLint err = EGL_SUCCESS;
766 egl_connection_t* const cnx = &gEGLImpl;
767 if (cnx->dso) {
768 err = cnx->egl.eglGetError();
Mathias Agopian518ec112011-05-13 16:21:08 -0700769 }
Mathias Agopianada798b2012-02-13 17:09:30 -0800770 if (err == EGL_SUCCESS) {
771 err = egl_tls_t::getError();
772 }
773 return err;
Mathias Agopian518ec112011-05-13 16:21:08 -0700774}
775
Mathias Agopian518ec112011-05-13 16:21:08 -0700776__eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname)
777{
778 // eglGetProcAddress() could be the very first function called
779 // in which case we must make sure we've initialized ourselves, this
780 // happens the first time egl_get_display() is called.
781
782 clearError();
783
784 if (egl_init_drivers() == EGL_FALSE) {
785 setError(EGL_BAD_PARAMETER, NULL);
786 return NULL;
787 }
788
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -0700789 if (FILTER_EXTENSIONS(procname)) {
Jamie Gennisaca51c02011-11-03 17:42:43 -0700790 return NULL;
791 }
792
Mathias Agopian518ec112011-05-13 16:21:08 -0700793 __eglMustCastToProperFunctionPointerType addr;
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -0700794 addr = findProcAddress(procname, sExtensionMap, NELEM(sExtensionMap));
Mathias Agopian518ec112011-05-13 16:21:08 -0700795 if (addr) return addr;
796
Jamie Gennisaca51c02011-11-03 17:42:43 -0700797
Mathias Agopian518ec112011-05-13 16:21:08 -0700798 // this protects accesses to sGLExtentionMap and sGLExtentionSlot
799 pthread_mutex_lock(&sExtensionMapMutex);
800
801 /*
802 * Since eglGetProcAddress() is not associated to anything, it needs
803 * to return a function pointer that "works" regardless of what
804 * the current context is.
805 *
806 * For this reason, we return a "forwarder", a small stub that takes
807 * care of calling the function associated with the context
808 * currently bound.
809 *
810 * We first look for extensions we've already resolved, if we're seeing
811 * this extension for the first time, we go through all our
812 * implementations and call eglGetProcAddress() and record the
813 * result in the appropriate implementation hooks and return the
814 * address of the forwarder corresponding to that hook set.
815 *
816 */
817
818 const String8 name(procname);
819 addr = sGLExtentionMap.valueFor(name);
820 const int slot = sGLExtentionSlot;
821
Steve Blocke6f43dd2012-01-06 19:20:56 +0000822 ALOGE_IF(slot >= MAX_NUMBER_OF_GL_EXTENSIONS,
Mathias Agopian518ec112011-05-13 16:21:08 -0700823 "no more slots for eglGetProcAddress(\"%s\")",
824 procname);
825
Siva Velusamy0469dd62011-11-30 15:05:37 -0800826#if EGL_TRACE
827 gl_hooks_t *debugHooks = GLTrace_getGLHooks();
828#endif
829
Mathias Agopian518ec112011-05-13 16:21:08 -0700830 if (!addr && (slot < MAX_NUMBER_OF_GL_EXTENSIONS)) {
831 bool found = false;
Mathias Agopianada798b2012-02-13 17:09:30 -0800832
833 egl_connection_t* const cnx = &gEGLImpl;
834 if (cnx->dso && cnx->egl.eglGetProcAddress) {
Mathias Agopianada798b2012-02-13 17:09:30 -0800835 // Extensions are independent of the bound context
luliuhui69d10072012-08-30 11:15:36 +0800836 addr =
Mathias Agopian7773c432012-02-13 20:06:08 -0800837 cnx->hooks[egl_connection_t::GLESv1_INDEX]->ext.extensions[slot] =
838 cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[slot] =
Mathias Agopian518ec112011-05-13 16:21:08 -0700839#if EGL_TRACE
Mathias Agopianada798b2012-02-13 17:09:30 -0800840 debugHooks->ext.extensions[slot] =
841 gHooksTrace.ext.extensions[slot] =
Mathias Agopian518ec112011-05-13 16:21:08 -0700842#endif
Mathias Agopianada798b2012-02-13 17:09:30 -0800843 cnx->egl.eglGetProcAddress(procname);
luliuhui69d10072012-08-30 11:15:36 +0800844 if (addr) found = true;
Mathias Agopian518ec112011-05-13 16:21:08 -0700845 }
Mathias Agopianada798b2012-02-13 17:09:30 -0800846
Mathias Agopian518ec112011-05-13 16:21:08 -0700847 if (found) {
luliuhui69d10072012-08-30 11:15:36 +0800848#if USE_FAST_TLS_KEY
Mathias Agopian518ec112011-05-13 16:21:08 -0700849 addr = gExtensionForwarders[slot];
luliuhui69d10072012-08-30 11:15:36 +0800850#endif
Mathias Agopian518ec112011-05-13 16:21:08 -0700851 sGLExtentionMap.add(name, addr);
852 sGLExtentionSlot++;
853 }
854 }
855
856 pthread_mutex_unlock(&sExtensionMapMutex);
857 return addr;
858}
859
Jamie Gennis28ef8d72012-04-05 20:34:54 -0700860class FrameCompletionThread : public Thread {
861public:
862
863 static void queueSync(EGLSyncKHR sync) {
864 static sp<FrameCompletionThread> thread(new FrameCompletionThread);
865 static bool running = false;
866 if (!running) {
867 thread->run("GPUFrameCompletion");
868 running = true;
869 }
870 {
871 Mutex::Autolock lock(thread->mMutex);
872 ScopedTrace st(ATRACE_TAG, String8::format("kicked off frame %d",
873 thread->mFramesQueued).string());
874 thread->mQueue.push_back(sync);
875 thread->mCondition.signal();
876 thread->mFramesQueued++;
877 ATRACE_INT("GPU Frames Outstanding", thread->mQueue.size());
878 }
879 }
880
881private:
882 FrameCompletionThread() : mFramesQueued(0), mFramesCompleted(0) {}
883
884 virtual bool threadLoop() {
885 EGLSyncKHR sync;
886 uint32_t frameNum;
887 {
888 Mutex::Autolock lock(mMutex);
889 while (mQueue.isEmpty()) {
890 mCondition.wait(mMutex);
891 }
892 sync = mQueue[0];
893 frameNum = mFramesCompleted;
894 }
895 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
896 {
897 ScopedTrace st(ATRACE_TAG, String8::format("waiting for frame %d",
898 frameNum).string());
899 EGLint result = eglClientWaitSyncKHR(dpy, sync, 0, EGL_FOREVER_KHR);
900 if (result == EGL_FALSE) {
901 ALOGE("FrameCompletion: error waiting for fence: %#x", eglGetError());
902 } else if (result == EGL_TIMEOUT_EXPIRED_KHR) {
903 ALOGE("FrameCompletion: timeout waiting for fence");
904 }
905 eglDestroySyncKHR(dpy, sync);
906 }
907 {
908 Mutex::Autolock lock(mMutex);
909 mQueue.removeAt(0);
910 mFramesCompleted++;
911 ATRACE_INT("GPU Frames Outstanding", mQueue.size());
912 }
913 return true;
914 }
915
916 uint32_t mFramesQueued;
917 uint32_t mFramesCompleted;
918 Vector<EGLSyncKHR> mQueue;
919 Condition mCondition;
920 Mutex mMutex;
921};
922
Mathias Agopian518ec112011-05-13 16:21:08 -0700923EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw)
924{
Jamie Gennis1c8e95c2012-02-23 19:27:23 -0800925 ATRACE_CALL();
Mathias Agopian518ec112011-05-13 16:21:08 -0700926 clearError();
927
Jesse Hallb29e5e82012-04-04 16:53:42 -0700928 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -0700929 if (!dp) return EGL_FALSE;
930
Jesse Hallb29e5e82012-04-04 16:53:42 -0700931 SurfaceRef _s(dp.get(), draw);
Mathias Agopian5b287a62011-05-16 18:58:55 -0700932 if (!_s.get())
933 return setError(EGL_BAD_SURFACE, EGL_FALSE);
Mathias Agopian518ec112011-05-13 16:21:08 -0700934
Siva Velusamy0469dd62011-11-30 15:05:37 -0800935#if EGL_TRACE
Siva Velusamya73a9772012-12-18 14:56:55 -0800936 gl_hooks_t const *trace_hooks = getGLTraceThreadSpecific();
937 if (getEGLDebugLevel() > 0) {
938 if (trace_hooks == NULL) {
939 if (GLTrace_start() < 0) {
940 ALOGE("Disabling Tracer for OpenGL ES");
941 setEGLDebugLevel(0);
942 } else {
943 // switch over to the trace version of hooks
944 EGLContext ctx = egl_tls_t::getContext();
945 egl_context_t * const c = get_context(ctx);
946 if (c) {
947 setGLHooksThreadSpecific(c->cnx->hooks[c->version]);
948 GLTrace_eglMakeCurrent(c->version, c->cnx->hooks[c->version], ctx);
949 }
950 }
951 }
952
Siva Velusamy0469dd62011-11-30 15:05:37 -0800953 GLTrace_eglSwapBuffers(dpy, draw);
Siva Velusamya73a9772012-12-18 14:56:55 -0800954 } else if (trace_hooks != NULL) {
955 // tracing is now disabled, so switch back to the non trace version
956 EGLContext ctx = egl_tls_t::getContext();
957 egl_context_t * const c = get_context(ctx);
958 if (c) setGLHooksThreadSpecific(c->cnx->hooks[c->version]);
959 GLTrace_stop();
960 }
Siva Velusamy0469dd62011-11-30 15:05:37 -0800961#endif
962
Mathias Agopian518ec112011-05-13 16:21:08 -0700963 egl_surface_t const * const s = get_surface(draw);
Mathias Agopian7db993a2012-03-25 00:49:46 -0700964
965 if (CC_UNLIKELY(dp->finishOnSwap)) {
966 uint32_t pixel;
967 egl_context_t * const c = get_context( egl_tls_t::getContext() );
968 if (c) {
969 // glReadPixels() ensures that the frame is complete
970 s->cnx->hooks[c->version]->gl.glReadPixels(0,0,1,1,
971 GL_RGBA,GL_UNSIGNED_BYTE,&pixel);
972 }
973 }
974
Jamie Gennis28ef8d72012-04-05 20:34:54 -0700975 EGLBoolean result = s->cnx->egl.eglSwapBuffers(dp->disp.dpy, s->surface);
976
977 if (CC_UNLIKELY(dp->traceGpuCompletion)) {
978 EGLSyncKHR sync = EGL_NO_SYNC_KHR;
979 {
980 sync = eglCreateSyncKHR(dpy, EGL_SYNC_FENCE_KHR, NULL);
981 }
982 if (sync != EGL_NO_SYNC_KHR) {
983 FrameCompletionThread::queueSync(sync);
984 }
985 }
986
987 return result;
Mathias Agopian518ec112011-05-13 16:21:08 -0700988}
989
990EGLBoolean eglCopyBuffers( EGLDisplay dpy, EGLSurface surface,
991 NativePixmapType target)
992{
993 clearError();
994
Jesse Hallb29e5e82012-04-04 16:53:42 -0700995 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -0700996 if (!dp) return EGL_FALSE;
997
Jesse Hallb29e5e82012-04-04 16:53:42 -0700998 SurfaceRef _s(dp.get(), surface);
Mathias Agopian5b287a62011-05-16 18:58:55 -0700999 if (!_s.get())
1000 return setError(EGL_BAD_SURFACE, EGL_FALSE);
Mathias Agopian518ec112011-05-13 16:21:08 -07001001
Mathias Agopian518ec112011-05-13 16:21:08 -07001002 egl_surface_t const * const s = get_surface(surface);
Mathias Agopianada798b2012-02-13 17:09:30 -08001003 return s->cnx->egl.eglCopyBuffers(dp->disp.dpy, s->surface, target);
Mathias Agopian518ec112011-05-13 16:21:08 -07001004}
1005
1006const char* eglQueryString(EGLDisplay dpy, EGLint name)
1007{
1008 clearError();
1009
Jesse Hallb29e5e82012-04-04 16:53:42 -07001010 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001011 if (!dp) return (const char *) NULL;
1012
1013 switch (name) {
1014 case EGL_VENDOR:
Mathias Agopian4b9511c2011-11-13 23:52:47 -08001015 return dp->getVendorString();
Mathias Agopian518ec112011-05-13 16:21:08 -07001016 case EGL_VERSION:
Mathias Agopian4b9511c2011-11-13 23:52:47 -08001017 return dp->getVersionString();
Mathias Agopian518ec112011-05-13 16:21:08 -07001018 case EGL_EXTENSIONS:
Mathias Agopian4b9511c2011-11-13 23:52:47 -08001019 return dp->getExtensionString();
Mathias Agopian518ec112011-05-13 16:21:08 -07001020 case EGL_CLIENT_APIS:
Mathias Agopian4b9511c2011-11-13 23:52:47 -08001021 return dp->getClientApiString();
Mathias Agopian518ec112011-05-13 16:21:08 -07001022 }
1023 return setError(EGL_BAD_PARAMETER, (const char *)0);
1024}
1025
Mathias Agopianca088332013-03-28 17:44:13 -07001026EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name)
1027{
1028 clearError();
1029
1030 const egl_display_ptr dp = validate_display(dpy);
1031 if (!dp) return (const char *) NULL;
1032
1033 switch (name) {
1034 case EGL_VENDOR:
1035 return dp->disp.queryString.vendor;
1036 case EGL_VERSION:
1037 return dp->disp.queryString.version;
1038 case EGL_EXTENSIONS:
1039 return dp->disp.queryString.extensions;
1040 case EGL_CLIENT_APIS:
1041 return dp->disp.queryString.clientApi;
1042 }
1043 return setError(EGL_BAD_PARAMETER, (const char *)0);
1044}
Mathias Agopian518ec112011-05-13 16:21:08 -07001045
1046// ----------------------------------------------------------------------------
1047// EGL 1.1
1048// ----------------------------------------------------------------------------
1049
1050EGLBoolean eglSurfaceAttrib(
1051 EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
1052{
1053 clearError();
1054
Jesse Hallb29e5e82012-04-04 16:53:42 -07001055 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001056 if (!dp) return EGL_FALSE;
1057
Jesse Hallb29e5e82012-04-04 16:53:42 -07001058 SurfaceRef _s(dp.get(), surface);
Mathias Agopian5b287a62011-05-16 18:58:55 -07001059 if (!_s.get())
1060 return setError(EGL_BAD_SURFACE, EGL_FALSE);
Mathias Agopian518ec112011-05-13 16:21:08 -07001061
Mathias Agopian518ec112011-05-13 16:21:08 -07001062 egl_surface_t const * const s = get_surface(surface);
1063 if (s->cnx->egl.eglSurfaceAttrib) {
1064 return s->cnx->egl.eglSurfaceAttrib(
Mathias Agopianada798b2012-02-13 17:09:30 -08001065 dp->disp.dpy, s->surface, attribute, value);
Mathias Agopian518ec112011-05-13 16:21:08 -07001066 }
1067 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1068}
1069
1070EGLBoolean eglBindTexImage(
1071 EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1072{
1073 clearError();
1074
Jesse Hallb29e5e82012-04-04 16:53:42 -07001075 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001076 if (!dp) return EGL_FALSE;
1077
Jesse Hallb29e5e82012-04-04 16:53:42 -07001078 SurfaceRef _s(dp.get(), surface);
Mathias Agopian5b287a62011-05-16 18:58:55 -07001079 if (!_s.get())
1080 return setError(EGL_BAD_SURFACE, EGL_FALSE);
Mathias Agopian518ec112011-05-13 16:21:08 -07001081
Mathias Agopian518ec112011-05-13 16:21:08 -07001082 egl_surface_t const * const s = get_surface(surface);
1083 if (s->cnx->egl.eglBindTexImage) {
1084 return s->cnx->egl.eglBindTexImage(
Mathias Agopianada798b2012-02-13 17:09:30 -08001085 dp->disp.dpy, s->surface, buffer);
Mathias Agopian518ec112011-05-13 16:21:08 -07001086 }
1087 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1088}
1089
1090EGLBoolean eglReleaseTexImage(
1091 EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1092{
1093 clearError();
1094
Jesse Hallb29e5e82012-04-04 16:53:42 -07001095 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001096 if (!dp) return EGL_FALSE;
1097
Jesse Hallb29e5e82012-04-04 16:53:42 -07001098 SurfaceRef _s(dp.get(), surface);
Mathias Agopian5b287a62011-05-16 18:58:55 -07001099 if (!_s.get())
1100 return setError(EGL_BAD_SURFACE, EGL_FALSE);
Mathias Agopian518ec112011-05-13 16:21:08 -07001101
Mathias Agopian518ec112011-05-13 16:21:08 -07001102 egl_surface_t const * const s = get_surface(surface);
1103 if (s->cnx->egl.eglReleaseTexImage) {
1104 return s->cnx->egl.eglReleaseTexImage(
Mathias Agopianada798b2012-02-13 17:09:30 -08001105 dp->disp.dpy, s->surface, buffer);
Mathias Agopian518ec112011-05-13 16:21:08 -07001106 }
1107 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1108}
1109
1110EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)
1111{
1112 clearError();
1113
Jesse Hallb29e5e82012-04-04 16:53:42 -07001114 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001115 if (!dp) return EGL_FALSE;
1116
1117 EGLBoolean res = EGL_TRUE;
Mathias Agopianada798b2012-02-13 17:09:30 -08001118 egl_connection_t* const cnx = &gEGLImpl;
1119 if (cnx->dso && cnx->egl.eglSwapInterval) {
1120 res = cnx->egl.eglSwapInterval(dp->disp.dpy, interval);
Mathias Agopian518ec112011-05-13 16:21:08 -07001121 }
Mathias Agopianada798b2012-02-13 17:09:30 -08001122
Mathias Agopian518ec112011-05-13 16:21:08 -07001123 return res;
1124}
1125
1126
1127// ----------------------------------------------------------------------------
1128// EGL 1.2
1129// ----------------------------------------------------------------------------
1130
1131EGLBoolean eglWaitClient(void)
1132{
1133 clearError();
1134
Mathias Agopianada798b2012-02-13 17:09:30 -08001135 egl_connection_t* const cnx = &gEGLImpl;
1136 if (!cnx->dso)
1137 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1138
1139 EGLBoolean res;
1140 if (cnx->egl.eglWaitClient) {
1141 res = cnx->egl.eglWaitClient();
1142 } else {
1143 res = cnx->egl.eglWaitGL();
Mathias Agopian518ec112011-05-13 16:21:08 -07001144 }
1145 return res;
1146}
1147
1148EGLBoolean eglBindAPI(EGLenum api)
1149{
1150 clearError();
1151
1152 if (egl_init_drivers() == EGL_FALSE) {
1153 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1154 }
1155
1156 // bind this API on all EGLs
1157 EGLBoolean res = EGL_TRUE;
Mathias Agopianada798b2012-02-13 17:09:30 -08001158 egl_connection_t* const cnx = &gEGLImpl;
1159 if (cnx->dso && cnx->egl.eglBindAPI) {
1160 res = cnx->egl.eglBindAPI(api);
Mathias Agopian518ec112011-05-13 16:21:08 -07001161 }
1162 return res;
1163}
1164
1165EGLenum eglQueryAPI(void)
1166{
1167 clearError();
1168
1169 if (egl_init_drivers() == EGL_FALSE) {
1170 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1171 }
1172
Mathias Agopianada798b2012-02-13 17:09:30 -08001173 egl_connection_t* const cnx = &gEGLImpl;
1174 if (cnx->dso && cnx->egl.eglQueryAPI) {
1175 return cnx->egl.eglQueryAPI();
Mathias Agopian518ec112011-05-13 16:21:08 -07001176 }
Mathias Agopianada798b2012-02-13 17:09:30 -08001177
Mathias Agopian518ec112011-05-13 16:21:08 -07001178 // or, it can only be OpenGL ES
1179 return EGL_OPENGL_ES_API;
1180}
1181
1182EGLBoolean eglReleaseThread(void)
1183{
1184 clearError();
1185
1186 // If there is context bound to the thread, release it
Mathias Agopianfb87e542012-01-30 18:20:52 -08001187 egl_display_t::loseCurrent(get_context(getContext()));
Mathias Agopian518ec112011-05-13 16:21:08 -07001188
Mathias Agopianada798b2012-02-13 17:09:30 -08001189 egl_connection_t* const cnx = &gEGLImpl;
1190 if (cnx->dso && cnx->egl.eglReleaseThread) {
1191 cnx->egl.eglReleaseThread();
Mathias Agopian518ec112011-05-13 16:21:08 -07001192 }
Mathias Agopianada798b2012-02-13 17:09:30 -08001193
Mathias Agopian518ec112011-05-13 16:21:08 -07001194 egl_tls_t::clearTLS();
Siva Velusamy0469dd62011-11-30 15:05:37 -08001195#if EGL_TRACE
Siva Velusamya73a9772012-12-18 14:56:55 -08001196 if (getEGLDebugLevel() > 0)
Siva Velusamy0469dd62011-11-30 15:05:37 -08001197 GLTrace_eglReleaseThread();
1198#endif
Mathias Agopian518ec112011-05-13 16:21:08 -07001199 return EGL_TRUE;
1200}
1201
1202EGLSurface eglCreatePbufferFromClientBuffer(
1203 EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
1204 EGLConfig config, const EGLint *attrib_list)
1205{
1206 clearError();
1207
Jesse Hallb29e5e82012-04-04 16:53:42 -07001208 egl_connection_t* cnx = NULL;
1209 const egl_display_ptr dp = validate_display_connection(dpy, cnx);
1210 if (!dp) return EGL_FALSE;
Mathias Agopian518ec112011-05-13 16:21:08 -07001211 if (cnx->egl.eglCreatePbufferFromClientBuffer) {
1212 return cnx->egl.eglCreatePbufferFromClientBuffer(
Mathias Agopian7773c432012-02-13 20:06:08 -08001213 dp->disp.dpy, buftype, buffer, config, attrib_list);
Mathias Agopian518ec112011-05-13 16:21:08 -07001214 }
1215 return setError(EGL_BAD_CONFIG, EGL_NO_SURFACE);
1216}
1217
1218// ----------------------------------------------------------------------------
1219// EGL_EGLEXT_VERSION 3
1220// ----------------------------------------------------------------------------
1221
1222EGLBoolean eglLockSurfaceKHR(EGLDisplay dpy, EGLSurface surface,
1223 const EGLint *attrib_list)
1224{
1225 clearError();
1226
Jesse Hallb29e5e82012-04-04 16:53:42 -07001227 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001228 if (!dp) return EGL_FALSE;
1229
Jesse Hallb29e5e82012-04-04 16:53:42 -07001230 SurfaceRef _s(dp.get(), surface);
Mathias Agopian5b287a62011-05-16 18:58:55 -07001231 if (!_s.get())
1232 return setError(EGL_BAD_SURFACE, EGL_FALSE);
Mathias Agopian518ec112011-05-13 16:21:08 -07001233
1234 egl_surface_t const * const s = get_surface(surface);
Mathias Agopian518ec112011-05-13 16:21:08 -07001235 if (s->cnx->egl.eglLockSurfaceKHR) {
1236 return s->cnx->egl.eglLockSurfaceKHR(
Mathias Agopianada798b2012-02-13 17:09:30 -08001237 dp->disp.dpy, s->surface, attrib_list);
Mathias Agopian518ec112011-05-13 16:21:08 -07001238 }
1239 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1240}
1241
1242EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface)
1243{
1244 clearError();
1245
Jesse Hallb29e5e82012-04-04 16:53:42 -07001246 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001247 if (!dp) return EGL_FALSE;
1248
Jesse Hallb29e5e82012-04-04 16:53:42 -07001249 SurfaceRef _s(dp.get(), surface);
Mathias Agopian5b287a62011-05-16 18:58:55 -07001250 if (!_s.get())
1251 return setError(EGL_BAD_SURFACE, EGL_FALSE);
Mathias Agopian518ec112011-05-13 16:21:08 -07001252
1253 egl_surface_t const * const s = get_surface(surface);
Mathias Agopian518ec112011-05-13 16:21:08 -07001254 if (s->cnx->egl.eglUnlockSurfaceKHR) {
Mathias Agopianada798b2012-02-13 17:09:30 -08001255 return s->cnx->egl.eglUnlockSurfaceKHR(dp->disp.dpy, s->surface);
Mathias Agopian518ec112011-05-13 16:21:08 -07001256 }
1257 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1258}
1259
1260EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
1261 EGLClientBuffer buffer, const EGLint *attrib_list)
1262{
1263 clearError();
1264
Jesse Hallb29e5e82012-04-04 16:53:42 -07001265 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001266 if (!dp) return EGL_NO_IMAGE_KHR;
1267
Jesse Hallb29e5e82012-04-04 16:53:42 -07001268 ContextRef _c(dp.get(), ctx);
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001269 egl_context_t * const c = _c.get();
Mathias Agopian518ec112011-05-13 16:21:08 -07001270
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001271 EGLImageKHR result = EGL_NO_IMAGE_KHR;
1272 egl_connection_t* const cnx = &gEGLImpl;
1273 if (cnx->dso && cnx->egl.eglCreateImageKHR) {
1274 result = cnx->egl.eglCreateImageKHR(
1275 dp->disp.dpy,
1276 c ? c->context : EGL_NO_CONTEXT,
1277 target, buffer, attrib_list);
Mathias Agopian518ec112011-05-13 16:21:08 -07001278 }
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001279 return result;
Mathias Agopian518ec112011-05-13 16:21:08 -07001280}
1281
1282EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img)
1283{
1284 clearError();
1285
Jesse Hallb29e5e82012-04-04 16:53:42 -07001286 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001287 if (!dp) return EGL_FALSE;
1288
Steven Holte646a5c52012-06-04 20:02:11 -07001289 EGLBoolean result = EGL_FALSE;
Mathias Agopianada798b2012-02-13 17:09:30 -08001290 egl_connection_t* const cnx = &gEGLImpl;
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001291 if (cnx->dso && cnx->egl.eglDestroyImageKHR) {
Steven Holte646a5c52012-06-04 20:02:11 -07001292 result = cnx->egl.eglDestroyImageKHR(dp->disp.dpy, img);
Mathias Agopian518ec112011-05-13 16:21:08 -07001293 }
Steven Holte646a5c52012-06-04 20:02:11 -07001294 return result;
Mathias Agopian518ec112011-05-13 16:21:08 -07001295}
1296
1297// ----------------------------------------------------------------------------
1298// EGL_EGLEXT_VERSION 5
1299// ----------------------------------------------------------------------------
1300
1301
1302EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
1303{
1304 clearError();
1305
Jesse Hallb29e5e82012-04-04 16:53:42 -07001306 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001307 if (!dp) return EGL_NO_SYNC_KHR;
1308
Mathias Agopian518ec112011-05-13 16:21:08 -07001309 EGLSyncKHR result = EGL_NO_SYNC_KHR;
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001310 egl_connection_t* const cnx = &gEGLImpl;
1311 if (cnx->dso && cnx->egl.eglCreateSyncKHR) {
1312 result = cnx->egl.eglCreateSyncKHR(dp->disp.dpy, type, attrib_list);
Mathias Agopian518ec112011-05-13 16:21:08 -07001313 }
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001314 return result;
Mathias Agopian518ec112011-05-13 16:21:08 -07001315}
1316
1317EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
1318{
1319 clearError();
1320
Jesse Hallb29e5e82012-04-04 16:53:42 -07001321 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001322 if (!dp) return EGL_FALSE;
1323
Mathias Agopian518ec112011-05-13 16:21:08 -07001324 EGLBoolean result = EGL_FALSE;
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001325 egl_connection_t* const cnx = &gEGLImpl;
1326 if (cnx->dso && cnx->egl.eglDestroySyncKHR) {
1327 result = cnx->egl.eglDestroySyncKHR(dp->disp.dpy, sync);
Mathias Agopian518ec112011-05-13 16:21:08 -07001328 }
1329 return result;
1330}
1331
Mathias Agopiane9b3dfb2013-03-27 14:30:19 -07001332EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) {
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.eglSignalSyncKHR) {
1341 result = cnx->egl.eglSignalSyncKHR(
1342 dp->disp.dpy, sync, mode);
1343 }
1344 return result;
1345}
1346
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001347EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync,
1348 EGLint flags, EGLTimeKHR timeout)
Mathias Agopian518ec112011-05-13 16:21:08 -07001349{
1350 clearError();
1351
Jesse Hallb29e5e82012-04-04 16:53:42 -07001352 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001353 if (!dp) return EGL_FALSE;
1354
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001355 EGLBoolean result = EGL_FALSE;
1356 egl_connection_t* const cnx = &gEGLImpl;
1357 if (cnx->dso && cnx->egl.eglClientWaitSyncKHR) {
1358 result = cnx->egl.eglClientWaitSyncKHR(
1359 dp->disp.dpy, sync, flags, timeout);
Mathias Agopian518ec112011-05-13 16:21:08 -07001360 }
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001361 return result;
Mathias Agopian518ec112011-05-13 16:21:08 -07001362}
1363
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001364EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync,
1365 EGLint attribute, EGLint *value)
Mathias Agopian518ec112011-05-13 16:21:08 -07001366{
1367 clearError();
1368
Jesse Hallb29e5e82012-04-04 16:53:42 -07001369 const egl_display_ptr dp = validate_display(dpy);
Mathias Agopian518ec112011-05-13 16:21:08 -07001370 if (!dp) return EGL_FALSE;
1371
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001372 EGLBoolean result = EGL_FALSE;
1373 egl_connection_t* const cnx = &gEGLImpl;
1374 if (cnx->dso && cnx->egl.eglGetSyncAttribKHR) {
1375 result = cnx->egl.eglGetSyncAttribKHR(
1376 dp->disp.dpy, sync, attribute, value);
Mathias Agopian518ec112011-05-13 16:21:08 -07001377 }
Mathias Agopian7c0441a2012-02-14 17:14:36 -08001378 return result;
Mathias Agopian518ec112011-05-13 16:21:08 -07001379}
1380
1381// ----------------------------------------------------------------------------
Mathias Agopian2bb71682013-03-27 17:32:41 -07001382// EGL_EGLEXT_VERSION 15
1383// ----------------------------------------------------------------------------
1384
1385EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) {
1386 clearError();
1387 const egl_display_ptr dp = validate_display(dpy);
1388 if (!dp) return EGL_FALSE;
1389 EGLint result = EGL_FALSE;
1390 egl_connection_t* const cnx = &gEGLImpl;
1391 if (cnx->dso && cnx->egl.eglWaitSyncKHR) {
1392 result = cnx->egl.eglWaitSyncKHR(dp->disp.dpy, sync, flags);
1393 }
1394 return result;
1395}
1396
1397// ----------------------------------------------------------------------------
Mathias Agopian518ec112011-05-13 16:21:08 -07001398// ANDROID extensions
1399// ----------------------------------------------------------------------------
1400
Jamie Gennis331841b2012-09-06 14:52:00 -07001401EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync)
1402{
1403 clearError();
1404
1405 const egl_display_ptr dp = validate_display(dpy);
1406 if (!dp) return EGL_NO_NATIVE_FENCE_FD_ANDROID;
1407
1408 EGLint result = EGL_NO_NATIVE_FENCE_FD_ANDROID;
1409 egl_connection_t* const cnx = &gEGLImpl;
1410 if (cnx->dso && cnx->egl.eglDupNativeFenceFDANDROID) {
1411 result = cnx->egl.eglDupNativeFenceFDANDROID(dp->disp.dpy, sync);
1412 }
1413 return result;
1414}
Jonas Yang1c3d72a2011-08-26 20:04:39 +08001415
Andy McFadden72841452013-03-01 16:25:32 -08001416EGLBoolean eglPresentationTimeANDROID(EGLDisplay dpy, EGLSurface surface,
1417 EGLnsecsANDROID time)
1418{
1419 clearError();
1420
1421 const egl_display_ptr dp = validate_display(dpy);
1422 if (!dp) {
1423 return EGL_FALSE;
1424 }
1425
1426 SurfaceRef _s(dp.get(), surface);
1427 if (!_s.get()) {
1428 setError(EGL_BAD_SURFACE, EGL_FALSE);
1429 return EGL_FALSE;
1430 }
1431
1432 egl_surface_t const * const s = get_surface(surface);
1433 native_window_set_buffers_timestamp(s->win.get(), time);
1434
1435 return EGL_TRUE;
1436}
1437
Jonas Yang1c3d72a2011-08-26 20:04:39 +08001438// ----------------------------------------------------------------------------
1439// NVIDIA extensions
1440// ----------------------------------------------------------------------------
1441EGLuint64NV eglGetSystemTimeFrequencyNV()
1442{
1443 clearError();
1444
1445 if (egl_init_drivers() == EGL_FALSE) {
1446 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1447 }
1448
1449 EGLuint64NV ret = 0;
Mathias Agopianada798b2012-02-13 17:09:30 -08001450 egl_connection_t* const cnx = &gEGLImpl;
Jonas Yang1c3d72a2011-08-26 20:04:39 +08001451
Mathias Agopianada798b2012-02-13 17:09:30 -08001452 if (cnx->dso && cnx->egl.eglGetSystemTimeFrequencyNV) {
1453 return cnx->egl.eglGetSystemTimeFrequencyNV();
Jonas Yang1c3d72a2011-08-26 20:04:39 +08001454 }
1455
Mathias Agopian0e8bbee2011-10-05 19:15:05 -07001456 return setErrorQuiet(EGL_BAD_DISPLAY, 0);
Jonas Yang1c3d72a2011-08-26 20:04:39 +08001457}
1458
1459EGLuint64NV eglGetSystemTimeNV()
1460{
1461 clearError();
1462
1463 if (egl_init_drivers() == EGL_FALSE) {
1464 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1465 }
1466
1467 EGLuint64NV ret = 0;
Mathias Agopianada798b2012-02-13 17:09:30 -08001468 egl_connection_t* const cnx = &gEGLImpl;
Jonas Yang1c3d72a2011-08-26 20:04:39 +08001469
Mathias Agopianada798b2012-02-13 17:09:30 -08001470 if (cnx->dso && cnx->egl.eglGetSystemTimeNV) {
1471 return cnx->egl.eglGetSystemTimeNV();
Jonas Yang1c3d72a2011-08-26 20:04:39 +08001472 }
1473
Mathias Agopian0e8bbee2011-10-05 19:15:05 -07001474 return setErrorQuiet(EGL_BAD_DISPLAY, 0);
Jonas Yang1c3d72a2011-08-26 20:04:39 +08001475}