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 #include <ctype.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <errno.h>
21 #include <dlfcn.h>
22
23 #include <sys/ioctl.h>
24
25 #if HAVE_ANDROID_OS
26 #include <linux/android_pmem.h>
27 #endif
28
29 #include <EGL/egl.h>
30 #include <EGL/eglext.h>
31 #include <GLES/gl.h>
32 #include <GLES/glext.h>
33
34 #include <cutils/log.h>
35 #include <cutils/atomic.h>
36 #include <cutils/properties.h>
37 #include <cutils/memory.h>
38
39 #include <utils/SortedVector.h>
40 #include <utils/KeyedVector.h>
41 #include <utils/String8.h>
42
43 #include <ui/egl/android_natives.h>
44
45 #include "hooks.h"
46 #include "egl_impl.h"
47 #include "Loader.h"
48
49 #define setError(_e, _r) setErrorEtc(__FUNCTION__, __LINE__, _e, _r)
50
51 // ----------------------------------------------------------------------------
52 namespace android {
53 // ----------------------------------------------------------------------------
54
55 #define VERSION_MAJOR 1
56 #define VERSION_MINOR 4
57 static char const * const gVendorString = "Android";
58 static char const * const gVersionString = "1.4 Android META-EGL";
59 static char const * const gClientApiString = "OpenGL ES";
60 static char const * const gExtensionString =
61 "EGL_KHR_image "
62 "EGL_KHR_image_base "
63 "EGL_KHR_image_pixmap "
64 "EGL_ANDROID_image_native_buffer "
65 "EGL_ANDROID_swap_rectangle "
66 ;
67
68 // ----------------------------------------------------------------------------
69
70 class egl_object_t {
71 static SortedVector<egl_object_t*> sObjects;
72 static Mutex sLock;
73
74 volatile int32_t terminated;
75 mutable volatile int32_t count;
76
77 public:
egl_object_t()78 egl_object_t() : terminated(0), count(1) {
79 Mutex::Autolock _l(sLock);
80 sObjects.add(this);
81 }
82
isAlive() const83 inline bool isAlive() const { return !terminated; }
84
85 private:
get()86 bool get() {
87 Mutex::Autolock _l(sLock);
88 if (egl_object_t::sObjects.indexOf(this) >= 0) {
89 android_atomic_inc(&count);
90 return true;
91 }
92 return false;
93 }
94
put()95 bool put() {
96 Mutex::Autolock _l(sLock);
97 if (android_atomic_dec(&count) == 1) {
98 sObjects.remove(this);
99 return true;
100 }
101 return false;
102 }
103
104 public:
105 template <typename N, typename T>
106 struct LocalRef {
107 N* ref;
LocalRefandroid::egl_object_t::LocalRef108 LocalRef(T o) : ref(0) {
109 N* native = reinterpret_cast<N*>(o);
110 if (o && native->get()) {
111 ref = native;
112 }
113 }
~LocalRefandroid::egl_object_t::LocalRef114 ~LocalRef() {
115 if (ref && ref->put()) {
116 delete ref;
117 }
118 }
getandroid::egl_object_t::LocalRef119 inline N* get() {
120 return ref;
121 }
acquireandroid::egl_object_t::LocalRef122 void acquire() const {
123 if (ref) {
124 android_atomic_inc(&ref->count);
125 }
126 }
releaseandroid::egl_object_t::LocalRef127 void release() const {
128 if (ref) {
129 int32_t c = android_atomic_dec(&ref->count);
130 // ref->count cannot be 1 prior atomic_dec because we have
131 // a reference, and if we have one, it means there was
132 // already one before us.
133 LOGE_IF(c==1, "refcount is now 0 in release()");
134 }
135 }
terminateandroid::egl_object_t::LocalRef136 void terminate() {
137 if (ref) {
138 ref->terminated = 1;
139 release();
140 }
141 }
142 };
143 };
144
145 SortedVector<egl_object_t*> egl_object_t::sObjects;
146 Mutex egl_object_t::sLock;
147
148
149 struct egl_config_t {
egl_config_tandroid::egl_config_t150 egl_config_t() {}
egl_config_tandroid::egl_config_t151 egl_config_t(int impl, EGLConfig config)
152 : impl(impl), config(config), configId(0), implConfigId(0) { }
153 int impl; // the implementation this config is for
154 EGLConfig config; // the implementation's EGLConfig
155 EGLint configId; // our CONFIG_ID
156 EGLint implConfigId; // the implementation's CONFIG_ID
operator <android::egl_config_t157 inline bool operator < (const egl_config_t& rhs) const {
158 if (impl < rhs.impl) return true;
159 if (impl > rhs.impl) return false;
160 return config < rhs.config;
161 }
162 };
163
164 struct egl_display_t {
165 enum { NOT_INITIALIZED, INITIALIZED, TERMINATED };
166
167 struct strings_t {
168 char const * vendor;
169 char const * version;
170 char const * clientApi;
171 char const * extensions;
172 };
173
174 struct DisplayImpl {
DisplayImplandroid::egl_display_t::DisplayImpl175 DisplayImpl() : dpy(EGL_NO_DISPLAY), config(0),
176 state(NOT_INITIALIZED), numConfigs(0) { }
177 EGLDisplay dpy;
178 EGLConfig* config;
179 EGLint state;
180 EGLint numConfigs;
181 strings_t queryString;
182 };
183
184 uint32_t magic;
185 DisplayImpl disp[IMPL_NUM_IMPLEMENTATIONS];
186 EGLint numTotalConfigs;
187 egl_config_t* configs;
188 uint32_t refs;
189 Mutex lock;
190
egl_display_tandroid::egl_display_t191 egl_display_t() : magic('_dpy'), numTotalConfigs(0), configs(0) { }
~egl_display_tandroid::egl_display_t192 ~egl_display_t() { magic = 0; }
isValidandroid::egl_display_t193 inline bool isValid() const { return magic == '_dpy'; }
isAliveandroid::egl_display_t194 inline bool isAlive() const { return isValid(); }
195 };
196
197 struct egl_surface_t : public egl_object_t
198 {
199 typedef egl_object_t::LocalRef<egl_surface_t, EGLSurface> Ref;
200
egl_surface_tandroid::egl_surface_t201 egl_surface_t(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win,
202 EGLSurface surface, int impl, egl_connection_t const* cnx)
203 : dpy(dpy), surface(surface), config(config), win(win), impl(impl), cnx(cnx) {
204 }
~egl_surface_tandroid::egl_surface_t205 ~egl_surface_t() {
206 }
207 EGLDisplay dpy;
208 EGLSurface surface;
209 EGLConfig config;
210 sp<ANativeWindow> win;
211 int impl;
212 egl_connection_t const* cnx;
213 };
214
215 struct egl_context_t : public egl_object_t
216 {
217 typedef egl_object_t::LocalRef<egl_context_t, EGLContext> Ref;
218
egl_context_tandroid::egl_context_t219 egl_context_t(EGLDisplay dpy, EGLContext context, EGLConfig config,
220 int impl, egl_connection_t const* cnx, int version)
221 : dpy(dpy), context(context), config(config), read(0), draw(0), impl(impl),
222 cnx(cnx), version(version)
223 {
224 }
225 EGLDisplay dpy;
226 EGLContext context;
227 EGLConfig config;
228 EGLSurface read;
229 EGLSurface draw;
230 int impl;
231 egl_connection_t const* cnx;
232 int version;
233 };
234
235 struct egl_image_t : public egl_object_t
236 {
237 typedef egl_object_t::LocalRef<egl_image_t, EGLImageKHR> Ref;
238
egl_image_tandroid::egl_image_t239 egl_image_t(EGLDisplay dpy, EGLContext context)
240 : dpy(dpy), context(context)
241 {
242 memset(images, 0, sizeof(images));
243 }
244 EGLDisplay dpy;
245 EGLContext context;
246 EGLImageKHR images[IMPL_NUM_IMPLEMENTATIONS];
247 };
248
249 typedef egl_surface_t::Ref SurfaceRef;
250 typedef egl_context_t::Ref ContextRef;
251 typedef egl_image_t::Ref ImageRef;
252
253 struct tls_t
254 {
tls_tandroid::tls_t255 tls_t() : error(EGL_SUCCESS), ctx(0), logCallWithNoContext(EGL_TRUE) { }
256 EGLint error;
257 EGLContext ctx;
258 EGLBoolean logCallWithNoContext;
259 };
260
261
262 // ----------------------------------------------------------------------------
263
264 static egl_connection_t gEGLImpl[IMPL_NUM_IMPLEMENTATIONS];
265 static egl_display_t gDisplay[NUM_DISPLAYS];
266 static pthread_mutex_t gThreadLocalStorageKeyMutex = PTHREAD_MUTEX_INITIALIZER;
267 static pthread_key_t gEGLThreadLocalStorageKey = -1;
268
269 // ----------------------------------------------------------------------------
270
271 EGLAPI gl_hooks_t gHooks[2][IMPL_NUM_IMPLEMENTATIONS];
272 EGLAPI gl_hooks_t gHooksNoContext;
273 EGLAPI pthread_key_t gGLWrapperKey = -1;
274
275 // ----------------------------------------------------------------------------
276
277 static __attribute__((noinline))
egl_strerror(EGLint err)278 const char *egl_strerror(EGLint err)
279 {
280 switch (err){
281 case EGL_SUCCESS: return "EGL_SUCCESS";
282 case EGL_NOT_INITIALIZED: return "EGL_NOT_INITIALIZED";
283 case EGL_BAD_ACCESS: return "EGL_BAD_ACCESS";
284 case EGL_BAD_ALLOC: return "EGL_BAD_ALLOC";
285 case EGL_BAD_ATTRIBUTE: return "EGL_BAD_ATTRIBUTE";
286 case EGL_BAD_CONFIG: return "EGL_BAD_CONFIG";
287 case EGL_BAD_CONTEXT: return "EGL_BAD_CONTEXT";
288 case EGL_BAD_CURRENT_SURFACE: return "EGL_BAD_CURRENT_SURFACE";
289 case EGL_BAD_DISPLAY: return "EGL_BAD_DISPLAY";
290 case EGL_BAD_MATCH: return "EGL_BAD_MATCH";
291 case EGL_BAD_NATIVE_PIXMAP: return "EGL_BAD_NATIVE_PIXMAP";
292 case EGL_BAD_NATIVE_WINDOW: return "EGL_BAD_NATIVE_WINDOW";
293 case EGL_BAD_PARAMETER: return "EGL_BAD_PARAMETER";
294 case EGL_BAD_SURFACE: return "EGL_BAD_SURFACE";
295 case EGL_CONTEXT_LOST: return "EGL_CONTEXT_LOST";
296 default: return "UNKNOWN";
297 }
298 }
299
300 static __attribute__((noinline))
clearTLS()301 void clearTLS() {
302 if (gEGLThreadLocalStorageKey != -1) {
303 tls_t* tls = (tls_t*)pthread_getspecific(gEGLThreadLocalStorageKey);
304 if (tls) {
305 delete tls;
306 pthread_setspecific(gEGLThreadLocalStorageKey, 0);
307 }
308 }
309 }
310
getTLS()311 static tls_t* getTLS()
312 {
313 tls_t* tls = (tls_t*)pthread_getspecific(gEGLThreadLocalStorageKey);
314 if (tls == 0) {
315 tls = new tls_t;
316 pthread_setspecific(gEGLThreadLocalStorageKey, tls);
317 }
318 return tls;
319 }
320
321 template<typename T>
322 static __attribute__((noinline))
setErrorEtc(const char * caller,int line,EGLint error,T returnValue)323 T setErrorEtc(const char* caller, int line, EGLint error, T returnValue) {
324 if (gEGLThreadLocalStorageKey == -1) {
325 pthread_mutex_lock(&gThreadLocalStorageKeyMutex);
326 if (gEGLThreadLocalStorageKey == -1)
327 pthread_key_create(&gEGLThreadLocalStorageKey, NULL);
328 pthread_mutex_unlock(&gThreadLocalStorageKeyMutex);
329 }
330 tls_t* tls = getTLS();
331 if (tls->error != error) {
332 LOGE("%s:%d error %x (%s)", caller, line, error, egl_strerror(error));
333 tls->error = error;
334 }
335 return returnValue;
336 }
337
338 static __attribute__((noinline))
getError()339 GLint getError() {
340 if (gEGLThreadLocalStorageKey == -1)
341 return EGL_SUCCESS;
342 tls_t* tls = (tls_t*)pthread_getspecific(gEGLThreadLocalStorageKey);
343 if (!tls) return EGL_SUCCESS;
344 GLint error = tls->error;
345 tls->error = EGL_SUCCESS;
346 return error;
347 }
348
349 static __attribute__((noinline))
setContext(EGLContext ctx)350 void setContext(EGLContext ctx) {
351 if (gEGLThreadLocalStorageKey == -1) {
352 pthread_mutex_lock(&gThreadLocalStorageKeyMutex);
353 if (gEGLThreadLocalStorageKey == -1)
354 pthread_key_create(&gEGLThreadLocalStorageKey, NULL);
355 pthread_mutex_unlock(&gThreadLocalStorageKeyMutex);
356 }
357 tls_t* tls = getTLS();
358 tls->ctx = ctx;
359 }
360
361 static __attribute__((noinline))
getContext()362 EGLContext getContext() {
363 if (gEGLThreadLocalStorageKey == -1)
364 return EGL_NO_CONTEXT;
365 tls_t* tls = (tls_t*)pthread_getspecific(gEGLThreadLocalStorageKey);
366 if (!tls) return EGL_NO_CONTEXT;
367 return tls->ctx;
368 }
369
370 /*****************************************************************************/
371
372 template<typename T>
373 static __attribute__((noinline))
binarySearch(T const sortedArray[],int first,int last,T key)374 int binarySearch(
375 T const sortedArray[], int first, int last, T key)
376 {
377 while (first <= last) {
378 int mid = (first + last) / 2;
379 if (sortedArray[mid] < key) {
380 first = mid + 1;
381 } else if (key < sortedArray[mid]) {
382 last = mid - 1;
383 } else {
384 return mid;
385 }
386 }
387 return -1;
388 }
389
cmp_configs(const void * a,const void * b)390 static int cmp_configs(const void* a, const void *b)
391 {
392 const egl_config_t& c0 = *(egl_config_t const *)a;
393 const egl_config_t& c1 = *(egl_config_t const *)b;
394 return c0<c1 ? -1 : (c1<c0 ? 1 : 0);
395 }
396
397 struct extention_map_t {
398 const char* name;
399 __eglMustCastToProperFunctionPointerType address;
400 };
401
402 static const extention_map_t gExtentionMap[] = {
403 { "eglLockSurfaceKHR",
404 (__eglMustCastToProperFunctionPointerType)&eglLockSurfaceKHR },
405 { "eglUnlockSurfaceKHR",
406 (__eglMustCastToProperFunctionPointerType)&eglUnlockSurfaceKHR },
407 { "eglCreateImageKHR",
408 (__eglMustCastToProperFunctionPointerType)&eglCreateImageKHR },
409 { "eglDestroyImageKHR",
410 (__eglMustCastToProperFunctionPointerType)&eglDestroyImageKHR },
411 { "eglSetSwapRectangleANDROID",
412 (__eglMustCastToProperFunctionPointerType)&eglSetSwapRectangleANDROID },
413 { "glEGLImageTargetTexture2DOES",
414 (__eglMustCastToProperFunctionPointerType)NULL },
415 { "glEGLImageTargetRenderbufferStorageOES",
416 (__eglMustCastToProperFunctionPointerType)NULL },
417 };
418
419 extern const __eglMustCastToProperFunctionPointerType gExtensionForwarders[MAX_NUMBER_OF_GL_EXTENSIONS];
420
421 // accesses protected by gInitDriverMutex
422 static DefaultKeyedVector<String8, __eglMustCastToProperFunctionPointerType> gGLExtentionMap;
423 static int gGLExtentionSlot = 0;
424
findProcAddress(const char * name,const extention_map_t * map,size_t n)425 static void(*findProcAddress(const char* name,
426 const extention_map_t* map, size_t n))()
427 {
428 for (uint32_t i=0 ; i<n ; i++) {
429 if (!strcmp(name, map[i].name)) {
430 return map[i].address;
431 }
432 }
433 return NULL;
434 }
435
436 // ----------------------------------------------------------------------------
437
gl_no_context()438 static int gl_no_context() {
439 tls_t* tls = getTLS();
440 if (tls->logCallWithNoContext == EGL_TRUE) {
441 tls->logCallWithNoContext = EGL_FALSE;
442 LOGE("call to OpenGL ES API with no current context "
443 "(logged once per thread)");
444 }
445 return 0;
446 }
447
early_egl_init(void)448 static void early_egl_init(void)
449 {
450 #if !USE_FAST_TLS_KEY
451 pthread_key_create(&gGLWrapperKey, NULL);
452 #endif
453 uint32_t addr = (uint32_t)((void*)gl_no_context);
454 android_memset32(
455 (uint32_t*)(void*)&gHooksNoContext,
456 addr,
457 sizeof(gHooksNoContext));
458
459 setGlThreadSpecific(&gHooksNoContext);
460 }
461
462 static pthread_once_t once_control = PTHREAD_ONCE_INIT;
463 static int sEarlyInitState = pthread_once(&once_control, &early_egl_init);
464
465
466 static inline
get_display(EGLDisplay dpy)467 egl_display_t* get_display(EGLDisplay dpy)
468 {
469 uintptr_t index = uintptr_t(dpy)-1U;
470 return (index >= NUM_DISPLAYS) ? NULL : &gDisplay[index];
471 }
472
473 template<typename NATIVE, typename EGL>
egl_to_native_cast(EGL arg)474 static inline NATIVE* egl_to_native_cast(EGL arg) {
475 return reinterpret_cast<NATIVE*>(arg);
476 }
477
478 static inline
get_surface(EGLSurface surface)479 egl_surface_t* get_surface(EGLSurface surface) {
480 return egl_to_native_cast<egl_surface_t>(surface);
481 }
482
483 static inline
get_context(EGLContext context)484 egl_context_t* get_context(EGLContext context) {
485 return egl_to_native_cast<egl_context_t>(context);
486 }
487
488 static inline
get_image(EGLImageKHR image)489 egl_image_t* get_image(EGLImageKHR image) {
490 return egl_to_native_cast<egl_image_t>(image);
491 }
492
validate_display_config(EGLDisplay dpy,EGLConfig config,egl_display_t const * & dp)493 static egl_connection_t* validate_display_config(
494 EGLDisplay dpy, EGLConfig config,
495 egl_display_t const*& dp)
496 {
497 dp = get_display(dpy);
498 if (!dp) return setError(EGL_BAD_DISPLAY, (egl_connection_t*)NULL);
499
500 if (intptr_t(config) >= dp->numTotalConfigs) {
501 return setError(EGL_BAD_CONFIG, (egl_connection_t*)NULL);
502 }
503 egl_connection_t* const cnx = &gEGLImpl[dp->configs[intptr_t(config)].impl];
504 if (cnx->dso == 0) {
505 return setError(EGL_BAD_CONFIG, (egl_connection_t*)NULL);
506 }
507 return cnx;
508 }
509
validate_display_context(EGLDisplay dpy,EGLContext ctx)510 static EGLBoolean validate_display_context(EGLDisplay dpy, EGLContext ctx)
511 {
512 if ((uintptr_t(dpy)-1U) >= NUM_DISPLAYS)
513 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
514 if (!get_display(dpy)->isAlive())
515 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
516 if (!get_context(ctx)->isAlive())
517 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
518 return EGL_TRUE;
519 }
520
validate_display_surface(EGLDisplay dpy,EGLSurface surface)521 static EGLBoolean validate_display_surface(EGLDisplay dpy, EGLSurface surface)
522 {
523 if ((uintptr_t(dpy)-1U) >= NUM_DISPLAYS)
524 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
525 if (!get_display(dpy)->isAlive())
526 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
527 if (!get_surface(surface)->isAlive())
528 return setError(EGL_BAD_SURFACE, EGL_FALSE);
529 return EGL_TRUE;
530 }
531
egl_get_image_for_current_context(EGLImageKHR image)532 EGLImageKHR egl_get_image_for_current_context(EGLImageKHR image)
533 {
534 ImageRef _i(image);
535 if (!_i.get()) return EGL_NO_IMAGE_KHR;
536
537 EGLContext context = getContext();
538 if (context == EGL_NO_CONTEXT || image == EGL_NO_IMAGE_KHR)
539 return EGL_NO_IMAGE_KHR;
540
541 egl_context_t const * const c = get_context(context);
542 if (!c->isAlive())
543 return EGL_NO_IMAGE_KHR;
544
545 egl_image_t const * const i = get_image(image);
546 return i->images[c->impl];
547 }
548
549 // ----------------------------------------------------------------------------
550
551 // this mutex protects:
552 // d->disp[]
553 // egl_init_drivers_locked()
554 //
555 static pthread_mutex_t gInitDriverMutex = PTHREAD_MUTEX_INITIALIZER;
556
egl_init_drivers_locked()557 EGLBoolean egl_init_drivers_locked()
558 {
559 if (sEarlyInitState) {
560 // initialized by static ctor. should be set here.
561 return EGL_FALSE;
562 }
563
564 // get our driver loader
565 Loader& loader(Loader::getInstance());
566
567 // dynamically load all our EGL implementations for all displays
568 // and retrieve the corresponding EGLDisplay
569 // if that fails, don't use this driver.
570 // TODO: currently we only deal with EGL_DEFAULT_DISPLAY
571 egl_connection_t* cnx;
572 egl_display_t* d = &gDisplay[0];
573
574 cnx = &gEGLImpl[IMPL_SOFTWARE];
575 if (cnx->dso == 0) {
576 cnx->hooks[GLESv1_INDEX] = &gHooks[GLESv1_INDEX][IMPL_SOFTWARE];
577 cnx->hooks[GLESv2_INDEX] = &gHooks[GLESv2_INDEX][IMPL_SOFTWARE];
578 cnx->dso = loader.open(EGL_DEFAULT_DISPLAY, 0, cnx);
579 if (cnx->dso) {
580 EGLDisplay dpy = cnx->egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);
581 LOGE_IF(dpy==EGL_NO_DISPLAY, "No EGLDisplay for software EGL!");
582 d->disp[IMPL_SOFTWARE].dpy = dpy;
583 if (dpy == EGL_NO_DISPLAY) {
584 loader.close(cnx->dso);
585 cnx->dso = NULL;
586 }
587 }
588 }
589
590 cnx = &gEGLImpl[IMPL_HARDWARE];
591 if (cnx->dso == 0) {
592 char value[PROPERTY_VALUE_MAX];
593 property_get("debug.egl.hw", value, "1");
594 if (atoi(value) != 0) {
595 cnx->hooks[GLESv1_INDEX] = &gHooks[GLESv1_INDEX][IMPL_HARDWARE];
596 cnx->hooks[GLESv2_INDEX] = &gHooks[GLESv2_INDEX][IMPL_HARDWARE];
597 cnx->dso = loader.open(EGL_DEFAULT_DISPLAY, 1, cnx);
598 if (cnx->dso) {
599 EGLDisplay dpy = cnx->egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);
600 LOGE_IF(dpy==EGL_NO_DISPLAY, "No EGLDisplay for hardware EGL!");
601 d->disp[IMPL_HARDWARE].dpy = dpy;
602 if (dpy == EGL_NO_DISPLAY) {
603 loader.close(cnx->dso);
604 cnx->dso = NULL;
605 }
606 }
607 } else {
608 LOGD("3D hardware acceleration is disabled");
609 }
610 }
611
612 if (!gEGLImpl[IMPL_SOFTWARE].dso && !gEGLImpl[IMPL_HARDWARE].dso) {
613 return EGL_FALSE;
614 }
615
616 return EGL_TRUE;
617 }
618
egl_init_drivers()619 EGLBoolean egl_init_drivers()
620 {
621 EGLBoolean res;
622 pthread_mutex_lock(&gInitDriverMutex);
623 res = egl_init_drivers_locked();
624 pthread_mutex_unlock(&gInitDriverMutex);
625 return res;
626 }
627
628 // ----------------------------------------------------------------------------
629 }; // namespace android
630 // ----------------------------------------------------------------------------
631
632 using namespace android;
633
eglGetDisplay(NativeDisplayType display)634 EGLDisplay eglGetDisplay(NativeDisplayType display)
635 {
636 uint32_t index = uint32_t(display);
637 if (index >= NUM_DISPLAYS) {
638 return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);
639 }
640
641 if (egl_init_drivers() == EGL_FALSE) {
642 return setError(EGL_BAD_PARAMETER, EGL_NO_DISPLAY);
643 }
644
645 EGLDisplay dpy = EGLDisplay(uintptr_t(display) + 1LU);
646 return dpy;
647 }
648
649 // ----------------------------------------------------------------------------
650 // Initialization
651 // ----------------------------------------------------------------------------
652
eglInitialize(EGLDisplay dpy,EGLint * major,EGLint * minor)653 EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
654 {
655 egl_display_t * const dp = get_display(dpy);
656 if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
657
658 Mutex::Autolock _l(dp->lock);
659
660 if (dp->refs > 0) {
661 if (major != NULL) *major = VERSION_MAJOR;
662 if (minor != NULL) *minor = VERSION_MINOR;
663 dp->refs++;
664 return EGL_TRUE;
665 }
666
667 setGlThreadSpecific(&gHooksNoContext);
668
669 // initialize each EGL and
670 // build our own extension string first, based on the extension we know
671 // and the extension supported by our client implementation
672 for (int i=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
673 egl_connection_t* const cnx = &gEGLImpl[i];
674 cnx->major = -1;
675 cnx->minor = -1;
676 if (!cnx->dso)
677 continue;
678
679 #if defined(ADRENO130)
680 #warning "Adreno-130 eglInitialize() workaround"
681 /*
682 * The ADRENO 130 driver returns a different EGLDisplay each time
683 * eglGetDisplay() is called, but also makes the EGLDisplay invalid
684 * after eglTerminate() has been called, so that eglInitialize()
685 * cannot be called again. Therefore, we need to make sure to call
686 * eglGetDisplay() before calling eglInitialize();
687 */
688 if (i == IMPL_HARDWARE) {
689 dp->disp[i].dpy =
690 cnx->egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);
691 }
692 #endif
693
694
695 EGLDisplay idpy = dp->disp[i].dpy;
696 if (cnx->egl.eglInitialize(idpy, &cnx->major, &cnx->minor)) {
697 //LOGD("initialized %d dpy=%p, ver=%d.%d, cnx=%p",
698 // i, idpy, cnx->major, cnx->minor, cnx);
699
700 // display is now initialized
701 dp->disp[i].state = egl_display_t::INITIALIZED;
702
703 // get the query-strings for this display for each implementation
704 dp->disp[i].queryString.vendor =
705 cnx->egl.eglQueryString(idpy, EGL_VENDOR);
706 dp->disp[i].queryString.version =
707 cnx->egl.eglQueryString(idpy, EGL_VERSION);
708 dp->disp[i].queryString.extensions =
709 cnx->egl.eglQueryString(idpy, EGL_EXTENSIONS);
710 dp->disp[i].queryString.clientApi =
711 cnx->egl.eglQueryString(idpy, EGL_CLIENT_APIS);
712
713 } else {
714 LOGW("%d: eglInitialize(%p) failed (%s)", i, idpy,
715 egl_strerror(cnx->egl.eglGetError()));
716 }
717 }
718
719 EGLBoolean res = EGL_FALSE;
720 for (int i=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
721 egl_connection_t* const cnx = &gEGLImpl[i];
722 if (cnx->dso && cnx->major>=0 && cnx->minor>=0) {
723 EGLint n;
724 if (cnx->egl.eglGetConfigs(dp->disp[i].dpy, 0, 0, &n)) {
725 dp->disp[i].config = (EGLConfig*)malloc(sizeof(EGLConfig)*n);
726 if (dp->disp[i].config) {
727 if (cnx->egl.eglGetConfigs(
728 dp->disp[i].dpy, dp->disp[i].config, n,
729 &dp->disp[i].numConfigs))
730 {
731 dp->numTotalConfigs += n;
732 res = EGL_TRUE;
733 }
734 }
735 }
736 }
737 }
738
739 if (res == EGL_TRUE) {
740 dp->configs = new egl_config_t[ dp->numTotalConfigs ];
741 for (int i=0, k=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
742 egl_connection_t* const cnx = &gEGLImpl[i];
743 if (cnx->dso && cnx->major>=0 && cnx->minor>=0) {
744 for (int j=0 ; j<dp->disp[i].numConfigs ; j++) {
745 dp->configs[k].impl = i;
746 dp->configs[k].config = dp->disp[i].config[j];
747 dp->configs[k].configId = k + 1; // CONFIG_ID start at 1
748 // store the implementation's CONFIG_ID
749 cnx->egl.eglGetConfigAttrib(
750 dp->disp[i].dpy,
751 dp->disp[i].config[j],
752 EGL_CONFIG_ID,
753 &dp->configs[k].implConfigId);
754 k++;
755 }
756 }
757 }
758
759 // sort our configurations so we can do binary-searches
760 qsort( dp->configs,
761 dp->numTotalConfigs,
762 sizeof(egl_config_t), cmp_configs);
763
764 dp->refs++;
765 if (major != NULL) *major = VERSION_MAJOR;
766 if (minor != NULL) *minor = VERSION_MINOR;
767 return EGL_TRUE;
768 }
769 return setError(EGL_NOT_INITIALIZED, EGL_FALSE);
770 }
771
eglTerminate(EGLDisplay dpy)772 EGLBoolean eglTerminate(EGLDisplay dpy)
773 {
774 // NOTE: don't unload the drivers b/c some APIs can be called
775 // after eglTerminate() has been called. eglTerminate() only
776 // terminates an EGLDisplay, not a EGL itself.
777
778 egl_display_t* const dp = get_display(dpy);
779 if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
780
781 Mutex::Autolock _l(dp->lock);
782
783 if (dp->refs == 0) {
784 return setError(EGL_NOT_INITIALIZED, EGL_FALSE);
785 }
786
787 // this is specific to Android, display termination is ref-counted.
788 if (dp->refs > 1) {
789 dp->refs--;
790 return EGL_TRUE;
791 }
792
793 EGLBoolean res = EGL_FALSE;
794 for (int i=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
795 egl_connection_t* const cnx = &gEGLImpl[i];
796 if (cnx->dso && dp->disp[i].state == egl_display_t::INITIALIZED) {
797 if (cnx->egl.eglTerminate(dp->disp[i].dpy) == EGL_FALSE) {
798 LOGW("%d: eglTerminate(%p) failed (%s)", i, dp->disp[i].dpy,
799 egl_strerror(cnx->egl.eglGetError()));
800 }
801 // REVISIT: it's unclear what to do if eglTerminate() fails
802 free(dp->disp[i].config);
803
804 dp->disp[i].numConfigs = 0;
805 dp->disp[i].config = 0;
806 dp->disp[i].state = egl_display_t::TERMINATED;
807
808 res = EGL_TRUE;
809 }
810 }
811
812 // TODO: all egl_object_t should be marked for termination
813
814 dp->refs--;
815 dp->numTotalConfigs = 0;
816 delete [] dp->configs;
817
818 return res;
819 }
820
821 // ----------------------------------------------------------------------------
822 // configuration
823 // ----------------------------------------------------------------------------
824
eglGetConfigs(EGLDisplay dpy,EGLConfig * configs,EGLint config_size,EGLint * num_config)825 EGLBoolean eglGetConfigs( EGLDisplay dpy,
826 EGLConfig *configs,
827 EGLint config_size, EGLint *num_config)
828 {
829 egl_display_t const * const dp = get_display(dpy);
830 if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
831
832 GLint numConfigs = dp->numTotalConfigs;
833 if (!configs) {
834 *num_config = numConfigs;
835 return EGL_TRUE;
836 }
837
838 GLint n = 0;
839 for (intptr_t i=0 ; i<dp->numTotalConfigs && config_size ; i++) {
840 *configs++ = EGLConfig(i);
841 config_size--;
842 n++;
843 }
844
845 *num_config = n;
846 return EGL_TRUE;
847 }
848
eglChooseConfig(EGLDisplay dpy,const EGLint * attrib_list,EGLConfig * configs,EGLint config_size,EGLint * num_config)849 EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list,
850 EGLConfig *configs, EGLint config_size,
851 EGLint *num_config)
852 {
853 egl_display_t const * const dp = get_display(dpy);
854 if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
855
856 if (num_config==0) {
857 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
858 }
859
860 EGLint n;
861 EGLBoolean res = EGL_FALSE;
862 *num_config = 0;
863
864
865 // It is unfortunate, but we need to remap the EGL_CONFIG_IDs,
866 // to do this, we have to go through the attrib_list array once
867 // to figure out both its size and if it contains an EGL_CONFIG_ID
868 // key. If so, the full array is copied and patched.
869 // NOTE: we assume that there can be only one occurrence
870 // of EGL_CONFIG_ID.
871
872 EGLint patch_index = -1;
873 GLint attr;
874 size_t size = 0;
875 if (attrib_list) {
876 while ((attr=attrib_list[size]) != EGL_NONE) {
877 if (attr == EGL_CONFIG_ID)
878 patch_index = size;
879 size += 2;
880 }
881 }
882 if (patch_index >= 0) {
883 size += 2; // we need copy the sentinel as well
884 EGLint* new_list = (EGLint*)malloc(size*sizeof(EGLint));
885 if (new_list == 0)
886 return setError(EGL_BAD_ALLOC, EGL_FALSE);
887 memcpy(new_list, attrib_list, size*sizeof(EGLint));
888
889 // patch the requested EGL_CONFIG_ID
890 bool found = false;
891 EGLConfig ourConfig(0);
892 EGLint& configId(new_list[patch_index+1]);
893 for (intptr_t i=0 ; i<dp->numTotalConfigs ; i++) {
894 if (dp->configs[i].configId == configId) {
895 ourConfig = EGLConfig(i);
896 configId = dp->configs[i].implConfigId;
897 found = true;
898 break;
899 }
900 }
901
902 egl_connection_t* const cnx = &gEGLImpl[dp->configs[intptr_t(ourConfig)].impl];
903 if (found && cnx->dso) {
904 // and switch to the new list
905 attrib_list = const_cast<const EGLint *>(new_list);
906
907 // At this point, the only configuration that can match is
908 // dp->configs[i][index], however, we don't know if it would be
909 // rejected because of the other attributes, so we do have to call
910 // cnx->egl.eglChooseConfig() -- but we don't have to loop
911 // through all the EGLimpl[].
912 // We also know we can only get a single config back, and we know
913 // which one.
914
915 res = cnx->egl.eglChooseConfig(
916 dp->disp[ dp->configs[intptr_t(ourConfig)].impl ].dpy,
917 attrib_list, configs, config_size, &n);
918 if (res && n>0) {
919 // n has to be 0 or 1, by construction, and we already know
920 // which config it will return (since there can be only one).
921 if (configs) {
922 configs[0] = ourConfig;
923 }
924 *num_config = 1;
925 }
926 }
927
928 free(const_cast<EGLint *>(attrib_list));
929 return res;
930 }
931
932
933 for (int i=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
934 egl_connection_t* const cnx = &gEGLImpl[i];
935 if (cnx->dso) {
936 if (cnx->egl.eglChooseConfig(
937 dp->disp[i].dpy, attrib_list, configs, config_size, &n)) {
938 if (configs) {
939 // now we need to convert these client EGLConfig to our
940 // internal EGLConfig format.
941 // This is done in O(n Log(n)) time.
942 for (int j=0 ; j<n ; j++) {
943 egl_config_t key(i, configs[j]);
944 intptr_t index = binarySearch<egl_config_t>(
945 dp->configs, 0, dp->numTotalConfigs, key);
946 if (index >= 0) {
947 configs[j] = EGLConfig(index);
948 } else {
949 return setError(EGL_BAD_CONFIG, EGL_FALSE);
950 }
951 }
952 configs += n;
953 config_size -= n;
954 }
955 *num_config += n;
956 res = EGL_TRUE;
957 }
958 }
959 }
960 return res;
961 }
962
eglGetConfigAttrib(EGLDisplay dpy,EGLConfig config,EGLint attribute,EGLint * value)963 EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
964 EGLint attribute, EGLint *value)
965 {
966 egl_display_t const* dp = 0;
967 egl_connection_t* cnx = validate_display_config(dpy, config, dp);
968 if (!cnx) return EGL_FALSE;
969
970 if (attribute == EGL_CONFIG_ID) {
971 *value = dp->configs[intptr_t(config)].configId;
972 return EGL_TRUE;
973 }
974 return cnx->egl.eglGetConfigAttrib(
975 dp->disp[ dp->configs[intptr_t(config)].impl ].dpy,
976 dp->configs[intptr_t(config)].config, attribute, value);
977 }
978
979 // ----------------------------------------------------------------------------
980 // surfaces
981 // ----------------------------------------------------------------------------
982
eglCreateWindowSurface(EGLDisplay dpy,EGLConfig config,NativeWindowType window,const EGLint * attrib_list)983 EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config,
984 NativeWindowType window,
985 const EGLint *attrib_list)
986 {
987 egl_display_t const* dp = 0;
988 egl_connection_t* cnx = validate_display_config(dpy, config, dp);
989 if (cnx) {
990 EGLDisplay iDpy = dp->disp[ dp->configs[intptr_t(config)].impl ].dpy;
991 EGLConfig iConfig = dp->configs[intptr_t(config)].config;
992 EGLint format;
993
994 // set the native window's buffers format to match this config
995 if (cnx->egl.eglGetConfigAttrib(iDpy,
996 iConfig, EGL_NATIVE_VISUAL_ID, &format)) {
997 if (format != 0) {
998 native_window_set_buffers_geometry(window, 0, 0, format);
999 }
1000 }
1001
1002 EGLSurface surface = cnx->egl.eglCreateWindowSurface(
1003 iDpy, iConfig, window, attrib_list);
1004 if (surface != EGL_NO_SURFACE) {
1005 egl_surface_t* s = new egl_surface_t(dpy, config, window, surface,
1006 dp->configs[intptr_t(config)].impl, cnx);
1007 return s;
1008 }
1009 }
1010 return EGL_NO_SURFACE;
1011 }
1012
eglCreatePixmapSurface(EGLDisplay dpy,EGLConfig config,NativePixmapType pixmap,const EGLint * attrib_list)1013 EGLSurface eglCreatePixmapSurface( EGLDisplay dpy, EGLConfig config,
1014 NativePixmapType pixmap,
1015 const EGLint *attrib_list)
1016 {
1017 egl_display_t const* dp = 0;
1018 egl_connection_t* cnx = validate_display_config(dpy, config, dp);
1019 if (cnx) {
1020 EGLSurface surface = cnx->egl.eglCreatePixmapSurface(
1021 dp->disp[ dp->configs[intptr_t(config)].impl ].dpy,
1022 dp->configs[intptr_t(config)].config, pixmap, attrib_list);
1023 if (surface != EGL_NO_SURFACE) {
1024 egl_surface_t* s = new egl_surface_t(dpy, config, NULL, surface,
1025 dp->configs[intptr_t(config)].impl, cnx);
1026 return s;
1027 }
1028 }
1029 return EGL_NO_SURFACE;
1030 }
1031
eglCreatePbufferSurface(EGLDisplay dpy,EGLConfig config,const EGLint * attrib_list)1032 EGLSurface eglCreatePbufferSurface( EGLDisplay dpy, EGLConfig config,
1033 const EGLint *attrib_list)
1034 {
1035 egl_display_t const* dp = 0;
1036 egl_connection_t* cnx = validate_display_config(dpy, config, dp);
1037 if (cnx) {
1038 EGLSurface surface = cnx->egl.eglCreatePbufferSurface(
1039 dp->disp[ dp->configs[intptr_t(config)].impl ].dpy,
1040 dp->configs[intptr_t(config)].config, attrib_list);
1041 if (surface != EGL_NO_SURFACE) {
1042 egl_surface_t* s = new egl_surface_t(dpy, config, NULL, surface,
1043 dp->configs[intptr_t(config)].impl, cnx);
1044 return s;
1045 }
1046 }
1047 return EGL_NO_SURFACE;
1048 }
1049
eglDestroySurface(EGLDisplay dpy,EGLSurface surface)1050 EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
1051 {
1052 SurfaceRef _s(surface);
1053 if (!_s.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
1054
1055 if (!validate_display_surface(dpy, surface))
1056 return EGL_FALSE;
1057 egl_display_t const * const dp = get_display(dpy);
1058
1059 egl_surface_t * const s = get_surface(surface);
1060 EGLBoolean result = s->cnx->egl.eglDestroySurface(
1061 dp->disp[s->impl].dpy, s->surface);
1062 if (result == EGL_TRUE) {
1063 if (s->win != NULL) {
1064 native_window_set_buffers_geometry(s->win.get(), 0, 0, 0);
1065 }
1066 _s.terminate();
1067 }
1068 return result;
1069 }
1070
eglQuerySurface(EGLDisplay dpy,EGLSurface surface,EGLint attribute,EGLint * value)1071 EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface surface,
1072 EGLint attribute, EGLint *value)
1073 {
1074 SurfaceRef _s(surface);
1075 if (!_s.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
1076
1077 if (!validate_display_surface(dpy, surface))
1078 return EGL_FALSE;
1079 egl_display_t const * const dp = get_display(dpy);
1080 egl_surface_t const * const s = get_surface(surface);
1081
1082 EGLBoolean result(EGL_TRUE);
1083 if (attribute == EGL_CONFIG_ID) {
1084 // We need to remap EGL_CONFIG_IDs
1085 *value = dp->configs[intptr_t(s->config)].configId;
1086 } else {
1087 result = s->cnx->egl.eglQuerySurface(
1088 dp->disp[s->impl].dpy, s->surface, attribute, value);
1089 }
1090
1091 return result;
1092 }
1093
1094 // ----------------------------------------------------------------------------
1095 // Contexts
1096 // ----------------------------------------------------------------------------
1097
eglCreateContext(EGLDisplay dpy,EGLConfig config,EGLContext share_list,const EGLint * attrib_list)1098 EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,
1099 EGLContext share_list, const EGLint *attrib_list)
1100 {
1101 egl_display_t const* dp = 0;
1102 egl_connection_t* cnx = validate_display_config(dpy, config, dp);
1103 if (cnx) {
1104 if (share_list != EGL_NO_CONTEXT) {
1105 egl_context_t* const c = get_context(share_list);
1106 share_list = c->context;
1107 }
1108 EGLContext context = cnx->egl.eglCreateContext(
1109 dp->disp[ dp->configs[intptr_t(config)].impl ].dpy,
1110 dp->configs[intptr_t(config)].config,
1111 share_list, attrib_list);
1112 if (context != EGL_NO_CONTEXT) {
1113 // figure out if it's a GLESv1 or GLESv2
1114 int version = 0;
1115 if (attrib_list) {
1116 while (*attrib_list != EGL_NONE) {
1117 GLint attr = *attrib_list++;
1118 GLint value = *attrib_list++;
1119 if (attr == EGL_CONTEXT_CLIENT_VERSION) {
1120 if (value == 1) {
1121 version = GLESv1_INDEX;
1122 } else if (value == 2) {
1123 version = GLESv2_INDEX;
1124 }
1125 }
1126 };
1127 }
1128 egl_context_t* c = new egl_context_t(dpy, context, config,
1129 dp->configs[intptr_t(config)].impl, cnx, version);
1130 return c;
1131 }
1132 }
1133 return EGL_NO_CONTEXT;
1134 }
1135
eglDestroyContext(EGLDisplay dpy,EGLContext ctx)1136 EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
1137 {
1138 ContextRef _c(ctx);
1139 if (!_c.get()) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1140
1141 if (!validate_display_context(dpy, ctx))
1142 return EGL_FALSE;
1143 egl_display_t const * const dp = get_display(dpy);
1144 egl_context_t * const c = get_context(ctx);
1145 EGLBoolean result = c->cnx->egl.eglDestroyContext(
1146 dp->disp[c->impl].dpy, c->context);
1147 if (result == EGL_TRUE) {
1148 _c.terminate();
1149 }
1150 return result;
1151 }
1152
loseCurrent(egl_context_t * cur_c)1153 static void loseCurrent(egl_context_t * cur_c)
1154 {
1155 if (cur_c) {
1156 egl_surface_t * cur_r = get_surface(cur_c->read);
1157 egl_surface_t * cur_d = get_surface(cur_c->draw);
1158
1159 // by construction, these are either 0 or valid (possibly terminated)
1160 // it should be impossible for these to be invalid
1161 ContextRef _cur_c(cur_c);
1162 SurfaceRef _cur_r(cur_r);
1163 SurfaceRef _cur_d(cur_d);
1164
1165 cur_c->read = NULL;
1166 cur_c->draw = NULL;
1167
1168 _cur_c.release();
1169 _cur_r.release();
1170 _cur_d.release();
1171 }
1172 }
1173
eglMakeCurrent(EGLDisplay dpy,EGLSurface draw,EGLSurface read,EGLContext ctx)1174 EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw,
1175 EGLSurface read, EGLContext ctx)
1176 {
1177 // get a reference to the object passed in
1178 ContextRef _c(ctx);
1179 SurfaceRef _d(draw);
1180 SurfaceRef _r(read);
1181
1182 // validate the display and the context (if not EGL_NO_CONTEXT)
1183 egl_display_t const * const dp = get_display(dpy);
1184 if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1185 if ((ctx != EGL_NO_CONTEXT) && (!validate_display_context(dpy, ctx))) {
1186 // EGL_NO_CONTEXT is valid
1187 return EGL_FALSE;
1188 }
1189
1190 // these are the underlying implementation's object
1191 EGLContext impl_ctx = EGL_NO_CONTEXT;
1192 EGLSurface impl_draw = EGL_NO_SURFACE;
1193 EGLSurface impl_read = EGL_NO_SURFACE;
1194
1195 // these are our objects structs passed in
1196 egl_context_t * c = NULL;
1197 egl_surface_t const * d = NULL;
1198 egl_surface_t const * r = NULL;
1199
1200 // these are the current objects structs
1201 egl_context_t * cur_c = get_context(getContext());
1202
1203 if (ctx != EGL_NO_CONTEXT) {
1204 c = get_context(ctx);
1205 impl_ctx = c->context;
1206 } else {
1207 // no context given, use the implementation of the current context
1208 if (cur_c == NULL) {
1209 // no current context
1210 if (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE) {
1211 // calling eglMakeCurrent( ..., !=0, !=0, EGL_NO_CONTEXT);
1212 return setError(EGL_BAD_MATCH, EGL_FALSE);
1213 }
1214 // not an error, there is just no current context.
1215 return EGL_TRUE;
1216 }
1217 }
1218
1219 // retrieve the underlying implementation's draw EGLSurface
1220 if (draw != EGL_NO_SURFACE) {
1221 d = get_surface(draw);
1222 // make sure the EGLContext and EGLSurface passed in are for
1223 // the same driver
1224 if (c && d->impl != c->impl)
1225 return setError(EGL_BAD_MATCH, EGL_FALSE);
1226 impl_draw = d->surface;
1227 }
1228
1229 // retrieve the underlying implementation's read EGLSurface
1230 if (read != EGL_NO_SURFACE) {
1231 r = get_surface(read);
1232 // make sure the EGLContext and EGLSurface passed in are for
1233 // the same driver
1234 if (c && r->impl != c->impl)
1235 return setError(EGL_BAD_MATCH, EGL_FALSE);
1236 impl_read = r->surface;
1237 }
1238
1239 EGLBoolean result;
1240
1241 if (c) {
1242 result = c->cnx->egl.eglMakeCurrent(
1243 dp->disp[c->impl].dpy, impl_draw, impl_read, impl_ctx);
1244 } else {
1245 result = cur_c->cnx->egl.eglMakeCurrent(
1246 dp->disp[cur_c->impl].dpy, impl_draw, impl_read, impl_ctx);
1247 }
1248
1249 if (result == EGL_TRUE) {
1250
1251 loseCurrent(cur_c);
1252
1253 if (ctx != EGL_NO_CONTEXT) {
1254 setGlThreadSpecific(c->cnx->hooks[c->version]);
1255 setContext(ctx);
1256 _c.acquire();
1257 _r.acquire();
1258 _d.acquire();
1259 c->read = read;
1260 c->draw = draw;
1261 } else {
1262 setGlThreadSpecific(&gHooksNoContext);
1263 setContext(EGL_NO_CONTEXT);
1264 }
1265 }
1266 return result;
1267 }
1268
1269
eglQueryContext(EGLDisplay dpy,EGLContext ctx,EGLint attribute,EGLint * value)1270 EGLBoolean eglQueryContext( EGLDisplay dpy, EGLContext ctx,
1271 EGLint attribute, EGLint *value)
1272 {
1273 ContextRef _c(ctx);
1274 if (!_c.get()) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1275
1276 if (!validate_display_context(dpy, ctx))
1277 return EGL_FALSE;
1278
1279 egl_display_t const * const dp = get_display(dpy);
1280 egl_context_t * const c = get_context(ctx);
1281
1282 EGLBoolean result(EGL_TRUE);
1283 if (attribute == EGL_CONFIG_ID) {
1284 *value = dp->configs[intptr_t(c->config)].configId;
1285 } else {
1286 // We need to remap EGL_CONFIG_IDs
1287 result = c->cnx->egl.eglQueryContext(
1288 dp->disp[c->impl].dpy, c->context, attribute, value);
1289 }
1290
1291 return result;
1292 }
1293
eglGetCurrentContext(void)1294 EGLContext eglGetCurrentContext(void)
1295 {
1296 // could be called before eglInitialize(), but we wouldn't have a context
1297 // then, and this function would correctly return EGL_NO_CONTEXT.
1298
1299 EGLContext ctx = getContext();
1300 return ctx;
1301 }
1302
eglGetCurrentSurface(EGLint readdraw)1303 EGLSurface eglGetCurrentSurface(EGLint readdraw)
1304 {
1305 // could be called before eglInitialize(), but we wouldn't have a context
1306 // then, and this function would correctly return EGL_NO_SURFACE.
1307
1308 EGLContext ctx = getContext();
1309 if (ctx) {
1310 egl_context_t const * const c = get_context(ctx);
1311 if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
1312 switch (readdraw) {
1313 case EGL_READ: return c->read;
1314 case EGL_DRAW: return c->draw;
1315 default: return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
1316 }
1317 }
1318 return EGL_NO_SURFACE;
1319 }
1320
eglGetCurrentDisplay(void)1321 EGLDisplay eglGetCurrentDisplay(void)
1322 {
1323 // could be called before eglInitialize(), but we wouldn't have a context
1324 // then, and this function would correctly return EGL_NO_DISPLAY.
1325
1326 EGLContext ctx = getContext();
1327 if (ctx) {
1328 egl_context_t const * const c = get_context(ctx);
1329 if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE);
1330 return c->dpy;
1331 }
1332 return EGL_NO_DISPLAY;
1333 }
1334
eglWaitGL(void)1335 EGLBoolean eglWaitGL(void)
1336 {
1337 // could be called before eglInitialize(), but we wouldn't have a context
1338 // then, and this function would return GL_TRUE, which isn't wrong.
1339
1340 EGLBoolean res = EGL_TRUE;
1341 EGLContext ctx = getContext();
1342 if (ctx) {
1343 egl_context_t const * const c = get_context(ctx);
1344 if (!c) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1345 if (uint32_t(c->impl)>=2)
1346 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1347 egl_connection_t* const cnx = &gEGLImpl[c->impl];
1348 if (!cnx->dso)
1349 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1350 res = cnx->egl.eglWaitGL();
1351 }
1352 return res;
1353 }
1354
eglWaitNative(EGLint engine)1355 EGLBoolean eglWaitNative(EGLint engine)
1356 {
1357 // could be called before eglInitialize(), but we wouldn't have a context
1358 // then, and this function would return GL_TRUE, which isn't wrong.
1359
1360 EGLBoolean res = EGL_TRUE;
1361 EGLContext ctx = getContext();
1362 if (ctx) {
1363 egl_context_t const * const c = get_context(ctx);
1364 if (!c) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1365 if (uint32_t(c->impl)>=2)
1366 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1367 egl_connection_t* const cnx = &gEGLImpl[c->impl];
1368 if (!cnx->dso)
1369 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1370 res = cnx->egl.eglWaitNative(engine);
1371 }
1372 return res;
1373 }
1374
eglGetError(void)1375 EGLint eglGetError(void)
1376 {
1377 EGLint result = EGL_SUCCESS;
1378 EGLint err;
1379 for (int i=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
1380 err = EGL_SUCCESS;
1381 egl_connection_t* const cnx = &gEGLImpl[i];
1382 if (cnx->dso)
1383 err = cnx->egl.eglGetError();
1384 if (err!=EGL_SUCCESS && result==EGL_SUCCESS)
1385 result = err;
1386 }
1387 err = getError();
1388 if (result == EGL_SUCCESS)
1389 result = err;
1390 return result;
1391 }
1392
eglGetProcAddress(const char * procname)1393 __eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname)
1394 {
1395 // eglGetProcAddress() could be the very first function called
1396 // in which case we must make sure we've initialized ourselves, this
1397 // happens the first time egl_get_display() is called.
1398
1399 if (egl_init_drivers() == EGL_FALSE) {
1400 setError(EGL_BAD_PARAMETER, NULL);
1401 return NULL;
1402 }
1403
1404 __eglMustCastToProperFunctionPointerType addr;
1405 addr = findProcAddress(procname, gExtentionMap, NELEM(gExtentionMap));
1406 if (addr) return addr;
1407
1408 // this protects accesses to gGLExtentionMap and gGLExtentionSlot
1409 pthread_mutex_lock(&gInitDriverMutex);
1410
1411 /*
1412 * Since eglGetProcAddress() is not associated to anything, it needs
1413 * to return a function pointer that "works" regardless of what
1414 * the current context is.
1415 *
1416 * For this reason, we return a "forwarder", a small stub that takes
1417 * care of calling the function associated with the context
1418 * currently bound.
1419 *
1420 * We first look for extensions we've already resolved, if we're seeing
1421 * this extension for the first time, we go through all our
1422 * implementations and call eglGetProcAddress() and record the
1423 * result in the appropriate implementation hooks and return the
1424 * address of the forwarder corresponding to that hook set.
1425 *
1426 */
1427
1428 const String8 name(procname);
1429 addr = gGLExtentionMap.valueFor(name);
1430 const int slot = gGLExtentionSlot;
1431
1432 LOGE_IF(slot >= MAX_NUMBER_OF_GL_EXTENSIONS,
1433 "no more slots for eglGetProcAddress(\"%s\")",
1434 procname);
1435
1436 if (!addr && (slot < MAX_NUMBER_OF_GL_EXTENSIONS)) {
1437 bool found = false;
1438 for (int i=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
1439 egl_connection_t* const cnx = &gEGLImpl[i];
1440 if (cnx->dso && cnx->egl.eglGetProcAddress) {
1441 found = true;
1442 // Extensions are independent of the bound context
1443 cnx->hooks[GLESv1_INDEX]->ext.extensions[slot] =
1444 cnx->hooks[GLESv2_INDEX]->ext.extensions[slot] =
1445 cnx->egl.eglGetProcAddress(procname);
1446 }
1447 }
1448 if (found) {
1449 addr = gExtensionForwarders[slot];
1450 gGLExtentionMap.add(name, addr);
1451 gGLExtentionSlot++;
1452 }
1453 }
1454
1455 pthread_mutex_unlock(&gInitDriverMutex);
1456 return addr;
1457 }
1458
eglSwapBuffers(EGLDisplay dpy,EGLSurface draw)1459 EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw)
1460 {
1461 SurfaceRef _s(draw);
1462 if (!_s.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
1463
1464 if (!validate_display_surface(dpy, draw))
1465 return EGL_FALSE;
1466 egl_display_t const * const dp = get_display(dpy);
1467 egl_surface_t const * const s = get_surface(draw);
1468 return s->cnx->egl.eglSwapBuffers(dp->disp[s->impl].dpy, s->surface);
1469 }
1470
eglCopyBuffers(EGLDisplay dpy,EGLSurface surface,NativePixmapType target)1471 EGLBoolean eglCopyBuffers( EGLDisplay dpy, EGLSurface surface,
1472 NativePixmapType target)
1473 {
1474 SurfaceRef _s(surface);
1475 if (!_s.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
1476
1477 if (!validate_display_surface(dpy, surface))
1478 return EGL_FALSE;
1479 egl_display_t const * const dp = get_display(dpy);
1480 egl_surface_t const * const s = get_surface(surface);
1481 return s->cnx->egl.eglCopyBuffers(
1482 dp->disp[s->impl].dpy, s->surface, target);
1483 }
1484
eglQueryString(EGLDisplay dpy,EGLint name)1485 const char* eglQueryString(EGLDisplay dpy, EGLint name)
1486 {
1487 egl_display_t const * const dp = get_display(dpy);
1488 switch (name) {
1489 case EGL_VENDOR:
1490 return gVendorString;
1491 case EGL_VERSION:
1492 return gVersionString;
1493 case EGL_EXTENSIONS:
1494 return gExtensionString;
1495 case EGL_CLIENT_APIS:
1496 return gClientApiString;
1497 }
1498 return setError(EGL_BAD_PARAMETER, (const char *)0);
1499 }
1500
1501
1502 // ----------------------------------------------------------------------------
1503 // EGL 1.1
1504 // ----------------------------------------------------------------------------
1505
eglSurfaceAttrib(EGLDisplay dpy,EGLSurface surface,EGLint attribute,EGLint value)1506 EGLBoolean eglSurfaceAttrib(
1507 EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
1508 {
1509 SurfaceRef _s(surface);
1510 if (!_s.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
1511
1512 if (!validate_display_surface(dpy, surface))
1513 return EGL_FALSE;
1514 egl_display_t const * const dp = get_display(dpy);
1515 egl_surface_t const * const s = get_surface(surface);
1516 if (s->cnx->egl.eglSurfaceAttrib) {
1517 return s->cnx->egl.eglSurfaceAttrib(
1518 dp->disp[s->impl].dpy, s->surface, attribute, value);
1519 }
1520 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1521 }
1522
eglBindTexImage(EGLDisplay dpy,EGLSurface surface,EGLint buffer)1523 EGLBoolean eglBindTexImage(
1524 EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1525 {
1526 SurfaceRef _s(surface);
1527 if (!_s.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
1528
1529 if (!validate_display_surface(dpy, surface))
1530 return EGL_FALSE;
1531 egl_display_t const * const dp = get_display(dpy);
1532 egl_surface_t const * const s = get_surface(surface);
1533 if (s->cnx->egl.eglBindTexImage) {
1534 return s->cnx->egl.eglBindTexImage(
1535 dp->disp[s->impl].dpy, s->surface, buffer);
1536 }
1537 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1538 }
1539
eglReleaseTexImage(EGLDisplay dpy,EGLSurface surface,EGLint buffer)1540 EGLBoolean eglReleaseTexImage(
1541 EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1542 {
1543 SurfaceRef _s(surface);
1544 if (!_s.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
1545
1546 if (!validate_display_surface(dpy, surface))
1547 return EGL_FALSE;
1548 egl_display_t const * const dp = get_display(dpy);
1549 egl_surface_t const * const s = get_surface(surface);
1550 if (s->cnx->egl.eglReleaseTexImage) {
1551 return s->cnx->egl.eglReleaseTexImage(
1552 dp->disp[s->impl].dpy, s->surface, buffer);
1553 }
1554 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1555 }
1556
eglSwapInterval(EGLDisplay dpy,EGLint interval)1557 EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)
1558 {
1559 egl_display_t * const dp = get_display(dpy);
1560 if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1561
1562 EGLBoolean res = EGL_TRUE;
1563 for (int i=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
1564 egl_connection_t* const cnx = &gEGLImpl[i];
1565 if (cnx->dso) {
1566 if (cnx->egl.eglSwapInterval) {
1567 if (cnx->egl.eglSwapInterval(
1568 dp->disp[i].dpy, interval) == EGL_FALSE) {
1569 res = EGL_FALSE;
1570 }
1571 }
1572 }
1573 }
1574 return res;
1575 }
1576
1577
1578 // ----------------------------------------------------------------------------
1579 // EGL 1.2
1580 // ----------------------------------------------------------------------------
1581
eglWaitClient(void)1582 EGLBoolean eglWaitClient(void)
1583 {
1584 // could be called before eglInitialize(), but we wouldn't have a context
1585 // then, and this function would return GL_TRUE, which isn't wrong.
1586 EGLBoolean res = EGL_TRUE;
1587 EGLContext ctx = getContext();
1588 if (ctx) {
1589 egl_context_t const * const c = get_context(ctx);
1590 if (!c) return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1591 if (uint32_t(c->impl)>=2)
1592 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1593 egl_connection_t* const cnx = &gEGLImpl[c->impl];
1594 if (!cnx->dso)
1595 return setError(EGL_BAD_CONTEXT, EGL_FALSE);
1596 if (cnx->egl.eglWaitClient) {
1597 res = cnx->egl.eglWaitClient();
1598 } else {
1599 res = cnx->egl.eglWaitGL();
1600 }
1601 }
1602 return res;
1603 }
1604
eglBindAPI(EGLenum api)1605 EGLBoolean eglBindAPI(EGLenum api)
1606 {
1607 if (egl_init_drivers() == EGL_FALSE) {
1608 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1609 }
1610
1611 // bind this API on all EGLs
1612 EGLBoolean res = EGL_TRUE;
1613 for (int i=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
1614 egl_connection_t* const cnx = &gEGLImpl[i];
1615 if (cnx->dso) {
1616 if (cnx->egl.eglBindAPI) {
1617 if (cnx->egl.eglBindAPI(api) == EGL_FALSE) {
1618 res = EGL_FALSE;
1619 }
1620 }
1621 }
1622 }
1623 return res;
1624 }
1625
eglQueryAPI(void)1626 EGLenum eglQueryAPI(void)
1627 {
1628 if (egl_init_drivers() == EGL_FALSE) {
1629 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1630 }
1631
1632 for (int i=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
1633 egl_connection_t* const cnx = &gEGLImpl[i];
1634 if (cnx->dso) {
1635 if (cnx->egl.eglQueryAPI) {
1636 // the first one we find is okay, because they all
1637 // should be the same
1638 return cnx->egl.eglQueryAPI();
1639 }
1640 }
1641 }
1642 // or, it can only be OpenGL ES
1643 return EGL_OPENGL_ES_API;
1644 }
1645
eglReleaseThread(void)1646 EGLBoolean eglReleaseThread(void)
1647 {
1648 // If there is context bound to the thread, release it
1649 loseCurrent(get_context(getContext()));
1650
1651 for (int i=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
1652 egl_connection_t* const cnx = &gEGLImpl[i];
1653 if (cnx->dso) {
1654 if (cnx->egl.eglReleaseThread) {
1655 cnx->egl.eglReleaseThread();
1656 }
1657 }
1658 }
1659 clearTLS();
1660 return EGL_TRUE;
1661 }
1662
eglCreatePbufferFromClientBuffer(EGLDisplay dpy,EGLenum buftype,EGLClientBuffer buffer,EGLConfig config,const EGLint * attrib_list)1663 EGLSurface eglCreatePbufferFromClientBuffer(
1664 EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
1665 EGLConfig config, const EGLint *attrib_list)
1666 {
1667 egl_display_t const* dp = 0;
1668 egl_connection_t* cnx = validate_display_config(dpy, config, dp);
1669 if (!cnx) return EGL_FALSE;
1670 if (cnx->egl.eglCreatePbufferFromClientBuffer) {
1671 return cnx->egl.eglCreatePbufferFromClientBuffer(
1672 dp->disp[ dp->configs[intptr_t(config)].impl ].dpy,
1673 buftype, buffer,
1674 dp->configs[intptr_t(config)].config, attrib_list);
1675 }
1676 return setError(EGL_BAD_CONFIG, EGL_NO_SURFACE);
1677 }
1678
1679 // ----------------------------------------------------------------------------
1680 // EGL_EGLEXT_VERSION 3
1681 // ----------------------------------------------------------------------------
1682
eglLockSurfaceKHR(EGLDisplay dpy,EGLSurface surface,const EGLint * attrib_list)1683 EGLBoolean eglLockSurfaceKHR(EGLDisplay dpy, EGLSurface surface,
1684 const EGLint *attrib_list)
1685 {
1686 SurfaceRef _s(surface);
1687 if (!_s.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
1688
1689 if (!validate_display_surface(dpy, surface))
1690 return EGL_FALSE;
1691
1692 egl_display_t const * const dp = get_display(dpy);
1693 egl_surface_t const * const s = get_surface(surface);
1694
1695 if (s->cnx->egl.eglLockSurfaceKHR) {
1696 return s->cnx->egl.eglLockSurfaceKHR(
1697 dp->disp[s->impl].dpy, s->surface, attrib_list);
1698 }
1699 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1700 }
1701
eglUnlockSurfaceKHR(EGLDisplay dpy,EGLSurface surface)1702 EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface)
1703 {
1704 SurfaceRef _s(surface);
1705 if (!_s.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
1706
1707 if (!validate_display_surface(dpy, surface))
1708 return EGL_FALSE;
1709
1710 egl_display_t const * const dp = get_display(dpy);
1711 egl_surface_t const * const s = get_surface(surface);
1712
1713 if (s->cnx->egl.eglUnlockSurfaceKHR) {
1714 return s->cnx->egl.eglUnlockSurfaceKHR(
1715 dp->disp[s->impl].dpy, s->surface);
1716 }
1717 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1718 }
1719
eglCreateImageKHR(EGLDisplay dpy,EGLContext ctx,EGLenum target,EGLClientBuffer buffer,const EGLint * attrib_list)1720 EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
1721 EGLClientBuffer buffer, const EGLint *attrib_list)
1722 {
1723 if (ctx != EGL_NO_CONTEXT) {
1724 ContextRef _c(ctx);
1725 if (!_c.get()) return setError(EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
1726 if (!validate_display_context(dpy, ctx))
1727 return EGL_NO_IMAGE_KHR;
1728 egl_display_t const * const dp = get_display(dpy);
1729 egl_context_t * const c = get_context(ctx);
1730 // since we have an EGLContext, we know which implementation to use
1731 EGLImageKHR image = c->cnx->egl.eglCreateImageKHR(
1732 dp->disp[c->impl].dpy, c->context, target, buffer, attrib_list);
1733 if (image == EGL_NO_IMAGE_KHR)
1734 return image;
1735
1736 egl_image_t* result = new egl_image_t(dpy, ctx);
1737 result->images[c->impl] = image;
1738 return (EGLImageKHR)result;
1739 } else {
1740 // EGL_NO_CONTEXT is a valid parameter
1741 egl_display_t const * const dp = get_display(dpy);
1742 if (dp == 0) {
1743 return setError(EGL_BAD_DISPLAY, EGL_NO_IMAGE_KHR);
1744 }
1745
1746 /* Since we don't have a way to know which implementation to call,
1747 * we're calling all of them. If at least one of the implementation
1748 * succeeded, this is a success.
1749 */
1750
1751 EGLint currentError = eglGetError();
1752
1753 EGLImageKHR implImages[IMPL_NUM_IMPLEMENTATIONS];
1754 bool success = false;
1755 for (int i=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
1756 egl_connection_t* const cnx = &gEGLImpl[i];
1757 implImages[i] = EGL_NO_IMAGE_KHR;
1758 if (cnx->dso) {
1759 if (cnx->egl.eglCreateImageKHR) {
1760 implImages[i] = cnx->egl.eglCreateImageKHR(
1761 dp->disp[i].dpy, ctx, target, buffer, attrib_list);
1762 if (implImages[i] != EGL_NO_IMAGE_KHR) {
1763 success = true;
1764 }
1765 }
1766 }
1767 }
1768
1769 if (!success) {
1770 // failure, if there was an error when we entered this function,
1771 // the error flag must not be updated.
1772 // Otherwise, the error is whatever happened in the implementation
1773 // that faulted.
1774 if (currentError != EGL_SUCCESS) {
1775 setError(currentError, EGL_NO_IMAGE_KHR);
1776 }
1777 return EGL_NO_IMAGE_KHR;
1778 } else {
1779 // In case of success, we need to clear all error flags
1780 // (especially those caused by the implementation that didn't
1781 // succeed). TODO: we could avoid this if we knew this was
1782 // a "full" success (all implementation succeeded).
1783 eglGetError();
1784 }
1785
1786 egl_image_t* result = new egl_image_t(dpy, ctx);
1787 memcpy(result->images, implImages, sizeof(implImages));
1788 return (EGLImageKHR)result;
1789 }
1790 }
1791
eglDestroyImageKHR(EGLDisplay dpy,EGLImageKHR img)1792 EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img)
1793 {
1794 egl_display_t const * const dp = get_display(dpy);
1795 if (dp == 0) {
1796 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1797 }
1798
1799 ImageRef _i(img);
1800 if (!_i.get()) return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1801
1802 egl_image_t* image = get_image(img);
1803 bool success = false;
1804 for (int i=0 ; i<IMPL_NUM_IMPLEMENTATIONS ; i++) {
1805 egl_connection_t* const cnx = &gEGLImpl[i];
1806 if (image->images[i] != EGL_NO_IMAGE_KHR) {
1807 if (cnx->dso) {
1808 if (cnx->egl.eglDestroyImageKHR) {
1809 if (cnx->egl.eglDestroyImageKHR(
1810 dp->disp[i].dpy, image->images[i])) {
1811 success = true;
1812 }
1813 }
1814 }
1815 }
1816 }
1817 if (!success)
1818 return EGL_FALSE;
1819
1820 _i.terminate();
1821
1822 return EGL_TRUE;
1823 }
1824
1825
1826 // ----------------------------------------------------------------------------
1827 // ANDROID extensions
1828 // ----------------------------------------------------------------------------
1829
eglSetSwapRectangleANDROID(EGLDisplay dpy,EGLSurface draw,EGLint left,EGLint top,EGLint width,EGLint height)1830 EGLBoolean eglSetSwapRectangleANDROID(EGLDisplay dpy, EGLSurface draw,
1831 EGLint left, EGLint top, EGLint width, EGLint height)
1832 {
1833 SurfaceRef _s(draw);
1834 if (!_s.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE);
1835
1836 if (!validate_display_surface(dpy, draw))
1837 return EGL_FALSE;
1838 egl_display_t const * const dp = get_display(dpy);
1839 egl_surface_t const * const s = get_surface(draw);
1840 if (s->cnx->egl.eglSetSwapRectangleANDROID) {
1841 return s->cnx->egl.eglSetSwapRectangleANDROID(
1842 dp->disp[s->impl].dpy, s->surface, left, top, width, height);
1843 }
1844 return setError(EGL_BAD_DISPLAY, NULL);
1845 }
1846