1 /*
2 **
3 ** Copyright 2007 The Android Open Source Project
4 **
5 ** Licensed under the Apache License Version 2.0(the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing software
12 ** distributed under the License is distributed on an "AS IS" BASIS
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 #include <assert.h>
19 #include <errno.h>
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <unistd.h>
24 #include <fcntl.h>
25 #include <sys/ioctl.h>
26 #include <sys/types.h>
27 #include <sys/mman.h>
28
29 #include <cutils/log.h>
30 #include <cutils/atomic.h>
31
32 #include <utils/threads.h>
33 #include <ui/ANativeObjectBase.h>
34 #include <ui/Fence.h>
35
36 #include <EGL/egl.h>
37 #include <EGL/eglext.h>
38 #include <GLES/gl.h>
39 #include <GLES/glext.h>
40
41 #include <pixelflinger/format.h>
42 #include <pixelflinger/pixelflinger.h>
43
44 #include "context.h"
45 #include "state.h"
46 #include "texture.h"
47 #include "matrix.h"
48
49 #undef NELEM
50 #define NELEM(x) (sizeof(x)/sizeof(*(x)))
51
52 // ----------------------------------------------------------------------------
53
54 EGLBoolean EGLAPI eglSetSwapRectangleANDROID(EGLDisplay dpy, EGLSurface draw,
55 EGLint left, EGLint top, EGLint width, EGLint height);
56
57 // ----------------------------------------------------------------------------
58 namespace android {
59
60 // ----------------------------------------------------------------------------
61
62 const unsigned int NUM_DISPLAYS = 1;
63
64 static pthread_mutex_t gInitMutex = PTHREAD_MUTEX_INITIALIZER;
65 static pthread_mutex_t gErrorKeyMutex = PTHREAD_MUTEX_INITIALIZER;
66 static pthread_key_t gEGLErrorKey = -1;
67 #ifndef HAVE_ANDROID_OS
68 namespace gl {
69 pthread_key_t gGLKey = -1;
70 }; // namespace gl
71 #endif
72
73 template<typename T>
setError(GLint error,T returnValue)74 static T setError(GLint error, T returnValue) {
75 if (ggl_unlikely(gEGLErrorKey == -1)) {
76 pthread_mutex_lock(&gErrorKeyMutex);
77 if (gEGLErrorKey == -1)
78 pthread_key_create(&gEGLErrorKey, NULL);
79 pthread_mutex_unlock(&gErrorKeyMutex);
80 }
81 pthread_setspecific(gEGLErrorKey, (void*)error);
82 return returnValue;
83 }
84
getError()85 static GLint getError() {
86 if (ggl_unlikely(gEGLErrorKey == -1))
87 return EGL_SUCCESS;
88 GLint error = (GLint)pthread_getspecific(gEGLErrorKey);
89 if (error == 0) {
90 // The TLS key has been created by another thread, but the value for
91 // this thread has not been initialized.
92 return EGL_SUCCESS;
93 }
94 pthread_setspecific(gEGLErrorKey, (void*)EGL_SUCCESS);
95 return error;
96 }
97
98 // ----------------------------------------------------------------------------
99
100 struct egl_display_t
101 {
egl_display_tandroid::egl_display_t102 egl_display_t() : type(0), initialized(0) { }
103
104 static egl_display_t& get_display(EGLDisplay dpy);
105
is_validandroid::egl_display_t106 static EGLBoolean is_valid(EGLDisplay dpy) {
107 return ((uintptr_t(dpy)-1U) >= NUM_DISPLAYS) ? EGL_FALSE : EGL_TRUE;
108 }
109
110 NativeDisplayType type;
111 volatile int32_t initialized;
112 };
113
114 static egl_display_t gDisplays[NUM_DISPLAYS];
115
get_display(EGLDisplay dpy)116 egl_display_t& egl_display_t::get_display(EGLDisplay dpy) {
117 return gDisplays[uintptr_t(dpy)-1U];
118 }
119
120 struct egl_context_t {
121 enum {
122 IS_CURRENT = 0x00010000,
123 NEVER_CURRENT = 0x00020000
124 };
125 uint32_t flags;
126 EGLDisplay dpy;
127 EGLConfig config;
128 EGLSurface read;
129 EGLSurface draw;
130
contextandroid::egl_context_t131 static inline egl_context_t* context(EGLContext ctx) {
132 ogles_context_t* const gl = static_cast<ogles_context_t*>(ctx);
133 return static_cast<egl_context_t*>(gl->rasterizer.base);
134 }
135 };
136
137 // ----------------------------------------------------------------------------
138
139 struct egl_surface_t
140 {
141 enum {
142 PAGE_FLIP = 0x00000001,
143 MAGIC = 0x31415265
144 };
145
146 uint32_t magic;
147 EGLDisplay dpy;
148 EGLConfig config;
149 EGLContext ctx;
150
151 egl_surface_t(EGLDisplay dpy, EGLConfig config, int32_t depthFormat);
152 virtual ~egl_surface_t();
153 bool isValid() const;
154 virtual bool initCheck() const = 0;
155
156 virtual EGLBoolean bindDrawSurface(ogles_context_t* gl) = 0;
157 virtual EGLBoolean bindReadSurface(ogles_context_t* gl) = 0;
connectandroid::egl_surface_t158 virtual EGLBoolean connect() { return EGL_TRUE; }
disconnectandroid::egl_surface_t159 virtual void disconnect() {}
160 virtual EGLint getWidth() const = 0;
161 virtual EGLint getHeight() const = 0;
162
163 virtual EGLint getHorizontalResolution() const;
164 virtual EGLint getVerticalResolution() const;
165 virtual EGLint getRefreshRate() const;
166 virtual EGLint getSwapBehavior() const;
167 virtual EGLBoolean swapBuffers();
168 virtual EGLBoolean setSwapRectangle(EGLint l, EGLint t, EGLint w, EGLint h);
169 protected:
170 GGLSurface depth;
171 };
172
egl_surface_t(EGLDisplay dpy,EGLConfig config,int32_t depthFormat)173 egl_surface_t::egl_surface_t(EGLDisplay dpy,
174 EGLConfig config,
175 int32_t depthFormat)
176 : magic(MAGIC), dpy(dpy), config(config), ctx(0)
177 {
178 depth.version = sizeof(GGLSurface);
179 depth.data = 0;
180 depth.format = depthFormat;
181 }
~egl_surface_t()182 egl_surface_t::~egl_surface_t()
183 {
184 magic = 0;
185 free(depth.data);
186 }
isValid() const187 bool egl_surface_t::isValid() const {
188 ALOGE_IF(magic != MAGIC, "invalid EGLSurface (%p)", this);
189 return magic == MAGIC;
190 }
191
swapBuffers()192 EGLBoolean egl_surface_t::swapBuffers() {
193 return EGL_FALSE;
194 }
getHorizontalResolution() const195 EGLint egl_surface_t::getHorizontalResolution() const {
196 return (0 * EGL_DISPLAY_SCALING) * (1.0f / 25.4f);
197 }
getVerticalResolution() const198 EGLint egl_surface_t::getVerticalResolution() const {
199 return (0 * EGL_DISPLAY_SCALING) * (1.0f / 25.4f);
200 }
getRefreshRate() const201 EGLint egl_surface_t::getRefreshRate() const {
202 return (60 * EGL_DISPLAY_SCALING);
203 }
getSwapBehavior() const204 EGLint egl_surface_t::getSwapBehavior() const {
205 return EGL_BUFFER_PRESERVED;
206 }
setSwapRectangle(EGLint l,EGLint t,EGLint w,EGLint h)207 EGLBoolean egl_surface_t::setSwapRectangle(
208 EGLint l, EGLint t, EGLint w, EGLint h)
209 {
210 return EGL_FALSE;
211 }
212
213 // ----------------------------------------------------------------------------
214
215 struct egl_window_surface_v2_t : public egl_surface_t
216 {
217 egl_window_surface_v2_t(
218 EGLDisplay dpy, EGLConfig config,
219 int32_t depthFormat,
220 ANativeWindow* window);
221
222 ~egl_window_surface_v2_t();
223
initCheckandroid::egl_window_surface_v2_t224 virtual bool initCheck() const { return true; } // TODO: report failure if ctor fails
225 virtual EGLBoolean swapBuffers();
226 virtual EGLBoolean bindDrawSurface(ogles_context_t* gl);
227 virtual EGLBoolean bindReadSurface(ogles_context_t* gl);
228 virtual EGLBoolean connect();
229 virtual void disconnect();
getWidthandroid::egl_window_surface_v2_t230 virtual EGLint getWidth() const { return width; }
getHeightandroid::egl_window_surface_v2_t231 virtual EGLint getHeight() const { return height; }
232 virtual EGLint getHorizontalResolution() const;
233 virtual EGLint getVerticalResolution() const;
234 virtual EGLint getRefreshRate() const;
235 virtual EGLint getSwapBehavior() const;
236 virtual EGLBoolean setSwapRectangle(EGLint l, EGLint t, EGLint w, EGLint h);
237
238 private:
239 status_t lock(ANativeWindowBuffer* buf, int usage, void** vaddr);
240 status_t unlock(ANativeWindowBuffer* buf);
241 ANativeWindow* nativeWindow;
242 ANativeWindowBuffer* buffer;
243 ANativeWindowBuffer* previousBuffer;
244 gralloc_module_t const* module;
245 int width;
246 int height;
247 void* bits;
248 GGLFormat const* pixelFormatTable;
249
250 struct Rect {
Rectandroid::egl_window_surface_v2_t::Rect251 inline Rect() { };
Rectandroid::egl_window_surface_v2_t::Rect252 inline Rect(int32_t w, int32_t h)
253 : left(0), top(0), right(w), bottom(h) { }
Rectandroid::egl_window_surface_v2_t::Rect254 inline Rect(int32_t l, int32_t t, int32_t r, int32_t b)
255 : left(l), top(t), right(r), bottom(b) { }
andSelfandroid::egl_window_surface_v2_t::Rect256 Rect& andSelf(const Rect& r) {
257 left = max(left, r.left);
258 top = max(top, r.top);
259 right = min(right, r.right);
260 bottom = min(bottom, r.bottom);
261 return *this;
262 }
isEmptyandroid::egl_window_surface_v2_t::Rect263 bool isEmpty() const {
264 return (left>=right || top>=bottom);
265 }
dumpandroid::egl_window_surface_v2_t::Rect266 void dump(char const* what) {
267 ALOGD("%s { %5d, %5d, w=%5d, h=%5d }",
268 what, left, top, right-left, bottom-top);
269 }
270
271 int32_t left;
272 int32_t top;
273 int32_t right;
274 int32_t bottom;
275 };
276
277 struct Region {
Regionandroid::egl_window_surface_v2_t::Region278 inline Region() : count(0) { }
279 typedef Rect const* const_iterator;
beginandroid::egl_window_surface_v2_t::Region280 const_iterator begin() const { return storage; }
endandroid::egl_window_surface_v2_t::Region281 const_iterator end() const { return storage+count; }
subtractandroid::egl_window_surface_v2_t::Region282 static Region subtract(const Rect& lhs, const Rect& rhs) {
283 Region reg;
284 Rect* storage = reg.storage;
285 if (!lhs.isEmpty()) {
286 if (lhs.top < rhs.top) { // top rect
287 storage->left = lhs.left;
288 storage->top = lhs.top;
289 storage->right = lhs.right;
290 storage->bottom = rhs.top;
291 storage++;
292 }
293 const int32_t top = max(lhs.top, rhs.top);
294 const int32_t bot = min(lhs.bottom, rhs.bottom);
295 if (top < bot) {
296 if (lhs.left < rhs.left) { // left-side rect
297 storage->left = lhs.left;
298 storage->top = top;
299 storage->right = rhs.left;
300 storage->bottom = bot;
301 storage++;
302 }
303 if (lhs.right > rhs.right) { // right-side rect
304 storage->left = rhs.right;
305 storage->top = top;
306 storage->right = lhs.right;
307 storage->bottom = bot;
308 storage++;
309 }
310 }
311 if (lhs.bottom > rhs.bottom) { // bottom rect
312 storage->left = lhs.left;
313 storage->top = rhs.bottom;
314 storage->right = lhs.right;
315 storage->bottom = lhs.bottom;
316 storage++;
317 }
318 reg.count = storage - reg.storage;
319 }
320 return reg;
321 }
isEmptyandroid::egl_window_surface_v2_t::Region322 bool isEmpty() const {
323 return count<=0;
324 }
325 private:
326 Rect storage[4];
327 ssize_t count;
328 };
329
330 void copyBlt(
331 ANativeWindowBuffer* dst, void* dst_vaddr,
332 ANativeWindowBuffer* src, void const* src_vaddr,
333 const Region& clip);
334
335 Rect dirtyRegion;
336 Rect oldDirtyRegion;
337 };
338
egl_window_surface_v2_t(EGLDisplay dpy,EGLConfig config,int32_t depthFormat,ANativeWindow * window)339 egl_window_surface_v2_t::egl_window_surface_v2_t(EGLDisplay dpy,
340 EGLConfig config,
341 int32_t depthFormat,
342 ANativeWindow* window)
343 : egl_surface_t(dpy, config, depthFormat),
344 nativeWindow(window), buffer(0), previousBuffer(0), module(0),
345 bits(NULL)
346 {
347 hw_module_t const* pModule;
348 hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &pModule);
349 module = reinterpret_cast<gralloc_module_t const*>(pModule);
350
351 pixelFormatTable = gglGetPixelFormatTable();
352
353 // keep a reference on the window
354 nativeWindow->common.incRef(&nativeWindow->common);
355 nativeWindow->query(nativeWindow, NATIVE_WINDOW_WIDTH, &width);
356 nativeWindow->query(nativeWindow, NATIVE_WINDOW_HEIGHT, &height);
357 }
358
~egl_window_surface_v2_t()359 egl_window_surface_v2_t::~egl_window_surface_v2_t() {
360 if (buffer) {
361 buffer->common.decRef(&buffer->common);
362 }
363 if (previousBuffer) {
364 previousBuffer->common.decRef(&previousBuffer->common);
365 }
366 nativeWindow->common.decRef(&nativeWindow->common);
367 }
368
connect()369 EGLBoolean egl_window_surface_v2_t::connect()
370 {
371 // we're intending to do software rendering
372 native_window_set_usage(nativeWindow,
373 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
374
375 // dequeue a buffer
376 int fenceFd = -1;
377 if (nativeWindow->dequeueBuffer(nativeWindow, &buffer,
378 &fenceFd) != NO_ERROR) {
379 return setError(EGL_BAD_ALLOC, EGL_FALSE);
380 }
381
382 // wait for the buffer
383 sp<Fence> fence(new Fence(fenceFd));
384 if (fence->wait(Fence::TIMEOUT_NEVER) != NO_ERROR) {
385 nativeWindow->cancelBuffer(nativeWindow, buffer, fenceFd);
386 return setError(EGL_BAD_ALLOC, EGL_FALSE);
387 }
388
389 // allocate a corresponding depth-buffer
390 width = buffer->width;
391 height = buffer->height;
392 if (depth.format) {
393 depth.width = width;
394 depth.height = height;
395 depth.stride = depth.width; // use the width here
396 depth.data = (GGLubyte*)malloc(depth.stride*depth.height*2);
397 if (depth.data == 0) {
398 return setError(EGL_BAD_ALLOC, EGL_FALSE);
399 }
400 }
401
402 // keep a reference on the buffer
403 buffer->common.incRef(&buffer->common);
404
405 // pin the buffer down
406 if (lock(buffer, GRALLOC_USAGE_SW_READ_OFTEN |
407 GRALLOC_USAGE_SW_WRITE_OFTEN, &bits) != NO_ERROR) {
408 ALOGE("connect() failed to lock buffer %p (%ux%u)",
409 buffer, buffer->width, buffer->height);
410 return setError(EGL_BAD_ACCESS, EGL_FALSE);
411 // FIXME: we should make sure we're not accessing the buffer anymore
412 }
413 return EGL_TRUE;
414 }
415
disconnect()416 void egl_window_surface_v2_t::disconnect()
417 {
418 if (buffer && bits) {
419 bits = NULL;
420 unlock(buffer);
421 }
422 // enqueue the last frame
423 nativeWindow->queueBuffer(nativeWindow, buffer, -1);
424 if (buffer) {
425 buffer->common.decRef(&buffer->common);
426 buffer = 0;
427 }
428 if (previousBuffer) {
429 previousBuffer->common.decRef(&previousBuffer->common);
430 previousBuffer = 0;
431 }
432 }
433
lock(ANativeWindowBuffer * buf,int usage,void ** vaddr)434 status_t egl_window_surface_v2_t::lock(
435 ANativeWindowBuffer* buf, int usage, void** vaddr)
436 {
437 int err;
438
439 err = module->lock(module, buf->handle,
440 usage, 0, 0, buf->width, buf->height, vaddr);
441
442 return err;
443 }
444
unlock(ANativeWindowBuffer * buf)445 status_t egl_window_surface_v2_t::unlock(ANativeWindowBuffer* buf)
446 {
447 if (!buf) return BAD_VALUE;
448 int err = NO_ERROR;
449
450 err = module->unlock(module, buf->handle);
451
452 return err;
453 }
454
copyBlt(ANativeWindowBuffer * dst,void * dst_vaddr,ANativeWindowBuffer * src,void const * src_vaddr,const Region & clip)455 void egl_window_surface_v2_t::copyBlt(
456 ANativeWindowBuffer* dst, void* dst_vaddr,
457 ANativeWindowBuffer* src, void const* src_vaddr,
458 const Region& clip)
459 {
460 // NOTE: dst and src must be the same format
461
462 Region::const_iterator cur = clip.begin();
463 Region::const_iterator end = clip.end();
464
465 const size_t bpp = pixelFormatTable[src->format].size;
466 const size_t dbpr = dst->stride * bpp;
467 const size_t sbpr = src->stride * bpp;
468
469 uint8_t const * const src_bits = (uint8_t const *)src_vaddr;
470 uint8_t * const dst_bits = (uint8_t *)dst_vaddr;
471
472 while (cur != end) {
473 const Rect& r(*cur++);
474 ssize_t w = r.right - r.left;
475 ssize_t h = r.bottom - r.top;
476 if (w <= 0 || h<=0) continue;
477 size_t size = w * bpp;
478 uint8_t const * s = src_bits + (r.left + src->stride * r.top) * bpp;
479 uint8_t * d = dst_bits + (r.left + dst->stride * r.top) * bpp;
480 if (dbpr==sbpr && size==sbpr) {
481 size *= h;
482 h = 1;
483 }
484 do {
485 memcpy(d, s, size);
486 d += dbpr;
487 s += sbpr;
488 } while (--h > 0);
489 }
490 }
491
swapBuffers()492 EGLBoolean egl_window_surface_v2_t::swapBuffers()
493 {
494 if (!buffer) {
495 return setError(EGL_BAD_ACCESS, EGL_FALSE);
496 }
497
498 /*
499 * Handle eglSetSwapRectangleANDROID()
500 * We copyback from the front buffer
501 */
502 if (!dirtyRegion.isEmpty()) {
503 dirtyRegion.andSelf(Rect(buffer->width, buffer->height));
504 if (previousBuffer) {
505 // This was const Region copyBack, but that causes an
506 // internal compile error on simulator builds
507 /*const*/ Region copyBack(Region::subtract(oldDirtyRegion, dirtyRegion));
508 if (!copyBack.isEmpty()) {
509 void* prevBits;
510 if (lock(previousBuffer,
511 GRALLOC_USAGE_SW_READ_OFTEN, &prevBits) == NO_ERROR) {
512 // copy from previousBuffer to buffer
513 copyBlt(buffer, bits, previousBuffer, prevBits, copyBack);
514 unlock(previousBuffer);
515 }
516 }
517 }
518 oldDirtyRegion = dirtyRegion;
519 }
520
521 if (previousBuffer) {
522 previousBuffer->common.decRef(&previousBuffer->common);
523 previousBuffer = 0;
524 }
525
526 unlock(buffer);
527 previousBuffer = buffer;
528 nativeWindow->queueBuffer(nativeWindow, buffer, -1);
529 buffer = 0;
530
531 // dequeue a new buffer
532 int fenceFd = -1;
533 if (nativeWindow->dequeueBuffer(nativeWindow, &buffer, &fenceFd) == NO_ERROR) {
534 sp<Fence> fence(new Fence(fenceFd));
535 if (fence->wait(Fence::TIMEOUT_NEVER)) {
536 nativeWindow->cancelBuffer(nativeWindow, buffer, fenceFd);
537 return setError(EGL_BAD_ALLOC, EGL_FALSE);
538 }
539
540 // reallocate the depth-buffer if needed
541 if ((width != buffer->width) || (height != buffer->height)) {
542 // TODO: we probably should reset the swap rect here
543 // if the window size has changed
544 width = buffer->width;
545 height = buffer->height;
546 if (depth.data) {
547 free(depth.data);
548 depth.width = width;
549 depth.height = height;
550 depth.stride = buffer->stride;
551 depth.data = (GGLubyte*)malloc(depth.stride*depth.height*2);
552 if (depth.data == 0) {
553 setError(EGL_BAD_ALLOC, EGL_FALSE);
554 return EGL_FALSE;
555 }
556 }
557 }
558
559 // keep a reference on the buffer
560 buffer->common.incRef(&buffer->common);
561
562 // finally pin the buffer down
563 if (lock(buffer, GRALLOC_USAGE_SW_READ_OFTEN |
564 GRALLOC_USAGE_SW_WRITE_OFTEN, &bits) != NO_ERROR) {
565 ALOGE("eglSwapBuffers() failed to lock buffer %p (%ux%u)",
566 buffer, buffer->width, buffer->height);
567 return setError(EGL_BAD_ACCESS, EGL_FALSE);
568 // FIXME: we should make sure we're not accessing the buffer anymore
569 }
570 } else {
571 return setError(EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
572 }
573
574 return EGL_TRUE;
575 }
576
setSwapRectangle(EGLint l,EGLint t,EGLint w,EGLint h)577 EGLBoolean egl_window_surface_v2_t::setSwapRectangle(
578 EGLint l, EGLint t, EGLint w, EGLint h)
579 {
580 dirtyRegion = Rect(l, t, l+w, t+h);
581 return EGL_TRUE;
582 }
583
bindDrawSurface(ogles_context_t * gl)584 EGLBoolean egl_window_surface_v2_t::bindDrawSurface(ogles_context_t* gl)
585 {
586 GGLSurface buffer;
587 buffer.version = sizeof(GGLSurface);
588 buffer.width = this->buffer->width;
589 buffer.height = this->buffer->height;
590 buffer.stride = this->buffer->stride;
591 buffer.data = (GGLubyte*)bits;
592 buffer.format = this->buffer->format;
593 gl->rasterizer.procs.colorBuffer(gl, &buffer);
594 if (depth.data != gl->rasterizer.state.buffers.depth.data)
595 gl->rasterizer.procs.depthBuffer(gl, &depth);
596
597 return EGL_TRUE;
598 }
bindReadSurface(ogles_context_t * gl)599 EGLBoolean egl_window_surface_v2_t::bindReadSurface(ogles_context_t* gl)
600 {
601 GGLSurface buffer;
602 buffer.version = sizeof(GGLSurface);
603 buffer.width = this->buffer->width;
604 buffer.height = this->buffer->height;
605 buffer.stride = this->buffer->stride;
606 buffer.data = (GGLubyte*)bits; // FIXME: hopefully is is LOCKED!!!
607 buffer.format = this->buffer->format;
608 gl->rasterizer.procs.readBuffer(gl, &buffer);
609 return EGL_TRUE;
610 }
getHorizontalResolution() const611 EGLint egl_window_surface_v2_t::getHorizontalResolution() const {
612 return (nativeWindow->xdpi * EGL_DISPLAY_SCALING) * (1.0f / 25.4f);
613 }
getVerticalResolution() const614 EGLint egl_window_surface_v2_t::getVerticalResolution() const {
615 return (nativeWindow->ydpi * EGL_DISPLAY_SCALING) * (1.0f / 25.4f);
616 }
getRefreshRate() const617 EGLint egl_window_surface_v2_t::getRefreshRate() const {
618 return (60 * EGL_DISPLAY_SCALING); // FIXME
619 }
getSwapBehavior() const620 EGLint egl_window_surface_v2_t::getSwapBehavior() const
621 {
622 /*
623 * EGL_BUFFER_PRESERVED means that eglSwapBuffers() completely preserves
624 * the content of the swapped buffer.
625 *
626 * EGL_BUFFER_DESTROYED means that the content of the buffer is lost.
627 *
628 * However when ANDROID_swap_retcangle is supported, EGL_BUFFER_DESTROYED
629 * only applies to the area specified by eglSetSwapRectangleANDROID(), that
630 * is, everything outside of this area is preserved.
631 *
632 * This implementation of EGL assumes the later case.
633 *
634 */
635
636 return EGL_BUFFER_DESTROYED;
637 }
638
639 // ----------------------------------------------------------------------------
640
641 struct egl_pixmap_surface_t : public egl_surface_t
642 {
643 egl_pixmap_surface_t(
644 EGLDisplay dpy, EGLConfig config,
645 int32_t depthFormat,
646 egl_native_pixmap_t const * pixmap);
647
~egl_pixmap_surface_tandroid::egl_pixmap_surface_t648 virtual ~egl_pixmap_surface_t() { }
649
initCheckandroid::egl_pixmap_surface_t650 virtual bool initCheck() const { return !depth.format || depth.data!=0; }
651 virtual EGLBoolean bindDrawSurface(ogles_context_t* gl);
652 virtual EGLBoolean bindReadSurface(ogles_context_t* gl);
getWidthandroid::egl_pixmap_surface_t653 virtual EGLint getWidth() const { return nativePixmap.width; }
getHeightandroid::egl_pixmap_surface_t654 virtual EGLint getHeight() const { return nativePixmap.height; }
655 private:
656 egl_native_pixmap_t nativePixmap;
657 };
658
egl_pixmap_surface_t(EGLDisplay dpy,EGLConfig config,int32_t depthFormat,egl_native_pixmap_t const * pixmap)659 egl_pixmap_surface_t::egl_pixmap_surface_t(EGLDisplay dpy,
660 EGLConfig config,
661 int32_t depthFormat,
662 egl_native_pixmap_t const * pixmap)
663 : egl_surface_t(dpy, config, depthFormat), nativePixmap(*pixmap)
664 {
665 if (depthFormat) {
666 depth.width = pixmap->width;
667 depth.height = pixmap->height;
668 depth.stride = depth.width; // use the width here
669 depth.data = (GGLubyte*)malloc(depth.stride*depth.height*2);
670 if (depth.data == 0) {
671 setError(EGL_BAD_ALLOC, EGL_NO_SURFACE);
672 }
673 }
674 }
bindDrawSurface(ogles_context_t * gl)675 EGLBoolean egl_pixmap_surface_t::bindDrawSurface(ogles_context_t* gl)
676 {
677 GGLSurface buffer;
678 buffer.version = sizeof(GGLSurface);
679 buffer.width = nativePixmap.width;
680 buffer.height = nativePixmap.height;
681 buffer.stride = nativePixmap.stride;
682 buffer.data = nativePixmap.data;
683 buffer.format = nativePixmap.format;
684
685 gl->rasterizer.procs.colorBuffer(gl, &buffer);
686 if (depth.data != gl->rasterizer.state.buffers.depth.data)
687 gl->rasterizer.procs.depthBuffer(gl, &depth);
688 return EGL_TRUE;
689 }
bindReadSurface(ogles_context_t * gl)690 EGLBoolean egl_pixmap_surface_t::bindReadSurface(ogles_context_t* gl)
691 {
692 GGLSurface buffer;
693 buffer.version = sizeof(GGLSurface);
694 buffer.width = nativePixmap.width;
695 buffer.height = nativePixmap.height;
696 buffer.stride = nativePixmap.stride;
697 buffer.data = nativePixmap.data;
698 buffer.format = nativePixmap.format;
699 gl->rasterizer.procs.readBuffer(gl, &buffer);
700 return EGL_TRUE;
701 }
702
703 // ----------------------------------------------------------------------------
704
705 struct egl_pbuffer_surface_t : public egl_surface_t
706 {
707 egl_pbuffer_surface_t(
708 EGLDisplay dpy, EGLConfig config, int32_t depthFormat,
709 int32_t w, int32_t h, int32_t f);
710
711 virtual ~egl_pbuffer_surface_t();
712
initCheckandroid::egl_pbuffer_surface_t713 virtual bool initCheck() const { return pbuffer.data != 0; }
714 virtual EGLBoolean bindDrawSurface(ogles_context_t* gl);
715 virtual EGLBoolean bindReadSurface(ogles_context_t* gl);
getWidthandroid::egl_pbuffer_surface_t716 virtual EGLint getWidth() const { return pbuffer.width; }
getHeightandroid::egl_pbuffer_surface_t717 virtual EGLint getHeight() const { return pbuffer.height; }
718 private:
719 GGLSurface pbuffer;
720 };
721
egl_pbuffer_surface_t(EGLDisplay dpy,EGLConfig config,int32_t depthFormat,int32_t w,int32_t h,int32_t f)722 egl_pbuffer_surface_t::egl_pbuffer_surface_t(EGLDisplay dpy,
723 EGLConfig config, int32_t depthFormat,
724 int32_t w, int32_t h, int32_t f)
725 : egl_surface_t(dpy, config, depthFormat)
726 {
727 size_t size = w*h;
728 switch (f) {
729 case GGL_PIXEL_FORMAT_A_8: size *= 1; break;
730 case GGL_PIXEL_FORMAT_RGB_565: size *= 2; break;
731 case GGL_PIXEL_FORMAT_RGBA_8888: size *= 4; break;
732 case GGL_PIXEL_FORMAT_RGBX_8888: size *= 4; break;
733 default:
734 ALOGE("incompatible pixel format for pbuffer (format=%d)", f);
735 pbuffer.data = 0;
736 break;
737 }
738 pbuffer.version = sizeof(GGLSurface);
739 pbuffer.width = w;
740 pbuffer.height = h;
741 pbuffer.stride = w;
742 pbuffer.data = (GGLubyte*)malloc(size);
743 pbuffer.format = f;
744
745 if (depthFormat) {
746 depth.width = pbuffer.width;
747 depth.height = pbuffer.height;
748 depth.stride = depth.width; // use the width here
749 depth.data = (GGLubyte*)malloc(depth.stride*depth.height*2);
750 if (depth.data == 0) {
751 setError(EGL_BAD_ALLOC, EGL_NO_SURFACE);
752 return;
753 }
754 }
755 }
~egl_pbuffer_surface_t()756 egl_pbuffer_surface_t::~egl_pbuffer_surface_t() {
757 free(pbuffer.data);
758 }
bindDrawSurface(ogles_context_t * gl)759 EGLBoolean egl_pbuffer_surface_t::bindDrawSurface(ogles_context_t* gl)
760 {
761 gl->rasterizer.procs.colorBuffer(gl, &pbuffer);
762 if (depth.data != gl->rasterizer.state.buffers.depth.data)
763 gl->rasterizer.procs.depthBuffer(gl, &depth);
764 return EGL_TRUE;
765 }
bindReadSurface(ogles_context_t * gl)766 EGLBoolean egl_pbuffer_surface_t::bindReadSurface(ogles_context_t* gl)
767 {
768 gl->rasterizer.procs.readBuffer(gl, &pbuffer);
769 return EGL_TRUE;
770 }
771
772 // ----------------------------------------------------------------------------
773
774 struct config_pair_t {
775 GLint key;
776 GLint value;
777 };
778
779 struct configs_t {
780 const config_pair_t* array;
781 int size;
782 };
783
784 struct config_management_t {
785 GLint key;
786 bool (*match)(GLint reqValue, GLint confValue);
atLeastandroid::config_management_t787 static bool atLeast(GLint reqValue, GLint confValue) {
788 return (reqValue == EGL_DONT_CARE) || (confValue >= reqValue);
789 }
exactandroid::config_management_t790 static bool exact(GLint reqValue, GLint confValue) {
791 return (reqValue == EGL_DONT_CARE) || (confValue == reqValue);
792 }
maskandroid::config_management_t793 static bool mask(GLint reqValue, GLint confValue) {
794 return (confValue & reqValue) == reqValue;
795 }
ignoreandroid::config_management_t796 static bool ignore(GLint reqValue, GLint confValue) {
797 return true;
798 }
799 };
800
801 // ----------------------------------------------------------------------------
802
803 #define VERSION_MAJOR 1
804 #define VERSION_MINOR 2
805 static char const * const gVendorString = "Google Inc.";
806 static char const * const gVersionString = "1.2 Android Driver 1.2.0";
807 static char const * const gClientApiString = "OpenGL_ES";
808 static char const * const gExtensionsString =
809 "EGL_KHR_fence_sync "
810 "EGL_KHR_image_base "
811 // "KHR_image_pixmap "
812 "EGL_ANDROID_image_native_buffer "
813 "EGL_ANDROID_swap_rectangle "
814 ;
815
816 // ----------------------------------------------------------------------------
817
818 struct extention_map_t {
819 const char * const name;
820 __eglMustCastToProperFunctionPointerType address;
821 };
822
823 static const extention_map_t gExtentionMap[] = {
824 { "glDrawTexsOES",
825 (__eglMustCastToProperFunctionPointerType)&glDrawTexsOES },
826 { "glDrawTexiOES",
827 (__eglMustCastToProperFunctionPointerType)&glDrawTexiOES },
828 { "glDrawTexfOES",
829 (__eglMustCastToProperFunctionPointerType)&glDrawTexfOES },
830 { "glDrawTexxOES",
831 (__eglMustCastToProperFunctionPointerType)&glDrawTexxOES },
832 { "glDrawTexsvOES",
833 (__eglMustCastToProperFunctionPointerType)&glDrawTexsvOES },
834 { "glDrawTexivOES",
835 (__eglMustCastToProperFunctionPointerType)&glDrawTexivOES },
836 { "glDrawTexfvOES",
837 (__eglMustCastToProperFunctionPointerType)&glDrawTexfvOES },
838 { "glDrawTexxvOES",
839 (__eglMustCastToProperFunctionPointerType)&glDrawTexxvOES },
840 { "glQueryMatrixxOES",
841 (__eglMustCastToProperFunctionPointerType)&glQueryMatrixxOES },
842 { "glEGLImageTargetTexture2DOES",
843 (__eglMustCastToProperFunctionPointerType)&glEGLImageTargetTexture2DOES },
844 { "glEGLImageTargetRenderbufferStorageOES",
845 (__eglMustCastToProperFunctionPointerType)&glEGLImageTargetRenderbufferStorageOES },
846 { "glClipPlanef",
847 (__eglMustCastToProperFunctionPointerType)&glClipPlanef },
848 { "glClipPlanex",
849 (__eglMustCastToProperFunctionPointerType)&glClipPlanex },
850 { "glBindBuffer",
851 (__eglMustCastToProperFunctionPointerType)&glBindBuffer },
852 { "glBufferData",
853 (__eglMustCastToProperFunctionPointerType)&glBufferData },
854 { "glBufferSubData",
855 (__eglMustCastToProperFunctionPointerType)&glBufferSubData },
856 { "glDeleteBuffers",
857 (__eglMustCastToProperFunctionPointerType)&glDeleteBuffers },
858 { "glGenBuffers",
859 (__eglMustCastToProperFunctionPointerType)&glGenBuffers },
860 { "eglCreateImageKHR",
861 (__eglMustCastToProperFunctionPointerType)&eglCreateImageKHR },
862 { "eglDestroyImageKHR",
863 (__eglMustCastToProperFunctionPointerType)&eglDestroyImageKHR },
864 { "eglCreateSyncKHR",
865 (__eglMustCastToProperFunctionPointerType)&eglCreateSyncKHR },
866 { "eglDestroySyncKHR",
867 (__eglMustCastToProperFunctionPointerType)&eglDestroySyncKHR },
868 { "eglClientWaitSyncKHR",
869 (__eglMustCastToProperFunctionPointerType)&eglClientWaitSyncKHR },
870 { "eglGetSyncAttribKHR",
871 (__eglMustCastToProperFunctionPointerType)&eglGetSyncAttribKHR },
872 { "eglSetSwapRectangleANDROID",
873 (__eglMustCastToProperFunctionPointerType)&eglSetSwapRectangleANDROID },
874 };
875
876 /*
877 * In the lists below, attributes names MUST be sorted.
878 * Additionally, all configs must be sorted according to
879 * the EGL specification.
880 */
881
882 static config_pair_t const config_base_attribute_list[] = {
883 { EGL_STENCIL_SIZE, 0 },
884 { EGL_CONFIG_CAVEAT, EGL_SLOW_CONFIG },
885 { EGL_LEVEL, 0 },
886 { EGL_MAX_PBUFFER_HEIGHT, GGL_MAX_VIEWPORT_DIMS },
887 { EGL_MAX_PBUFFER_PIXELS,
888 GGL_MAX_VIEWPORT_DIMS*GGL_MAX_VIEWPORT_DIMS },
889 { EGL_MAX_PBUFFER_WIDTH, GGL_MAX_VIEWPORT_DIMS },
890 { EGL_NATIVE_RENDERABLE, EGL_TRUE },
891 { EGL_NATIVE_VISUAL_ID, 0 },
892 { EGL_NATIVE_VISUAL_TYPE, GGL_PIXEL_FORMAT_RGB_565 },
893 { EGL_SAMPLES, 0 },
894 { EGL_SAMPLE_BUFFERS, 0 },
895 { EGL_TRANSPARENT_TYPE, EGL_NONE },
896 { EGL_TRANSPARENT_BLUE_VALUE, 0 },
897 { EGL_TRANSPARENT_GREEN_VALUE, 0 },
898 { EGL_TRANSPARENT_RED_VALUE, 0 },
899 { EGL_BIND_TO_TEXTURE_RGBA, EGL_FALSE },
900 { EGL_BIND_TO_TEXTURE_RGB, EGL_FALSE },
901 { EGL_MIN_SWAP_INTERVAL, 1 },
902 { EGL_MAX_SWAP_INTERVAL, 1 },
903 { EGL_LUMINANCE_SIZE, 0 },
904 { EGL_ALPHA_MASK_SIZE, 0 },
905 { EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER },
906 { EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT },
907 { EGL_CONFORMANT, 0 }
908 };
909
910 // These configs can override the base attribute list
911 // NOTE: when adding a config here, don't forget to update eglCreate*Surface()
912
913 // 565 configs
914 static config_pair_t const config_0_attribute_list[] = {
915 { EGL_BUFFER_SIZE, 16 },
916 { EGL_ALPHA_SIZE, 0 },
917 { EGL_BLUE_SIZE, 5 },
918 { EGL_GREEN_SIZE, 6 },
919 { EGL_RED_SIZE, 5 },
920 { EGL_DEPTH_SIZE, 0 },
921 { EGL_CONFIG_ID, 0 },
922 { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_RGB_565 },
923 { EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT },
924 };
925
926 static config_pair_t const config_1_attribute_list[] = {
927 { EGL_BUFFER_SIZE, 16 },
928 { EGL_ALPHA_SIZE, 0 },
929 { EGL_BLUE_SIZE, 5 },
930 { EGL_GREEN_SIZE, 6 },
931 { EGL_RED_SIZE, 5 },
932 { EGL_DEPTH_SIZE, 16 },
933 { EGL_CONFIG_ID, 1 },
934 { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_RGB_565 },
935 { EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT },
936 };
937
938 // RGB 888 configs
939 static config_pair_t const config_2_attribute_list[] = {
940 { EGL_BUFFER_SIZE, 32 },
941 { EGL_ALPHA_SIZE, 0 },
942 { EGL_BLUE_SIZE, 8 },
943 { EGL_GREEN_SIZE, 8 },
944 { EGL_RED_SIZE, 8 },
945 { EGL_DEPTH_SIZE, 0 },
946 { EGL_CONFIG_ID, 6 },
947 { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_RGBX_8888 },
948 { EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT },
949 };
950
951 static config_pair_t const config_3_attribute_list[] = {
952 { EGL_BUFFER_SIZE, 32 },
953 { EGL_ALPHA_SIZE, 0 },
954 { EGL_BLUE_SIZE, 8 },
955 { EGL_GREEN_SIZE, 8 },
956 { EGL_RED_SIZE, 8 },
957 { EGL_DEPTH_SIZE, 16 },
958 { EGL_CONFIG_ID, 7 },
959 { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_RGBX_8888 },
960 { EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT },
961 };
962
963 // 8888 configs
964 static config_pair_t const config_4_attribute_list[] = {
965 { EGL_BUFFER_SIZE, 32 },
966 { EGL_ALPHA_SIZE, 8 },
967 { EGL_BLUE_SIZE, 8 },
968 { EGL_GREEN_SIZE, 8 },
969 { EGL_RED_SIZE, 8 },
970 { EGL_DEPTH_SIZE, 0 },
971 { EGL_CONFIG_ID, 2 },
972 { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_RGBA_8888 },
973 { EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT },
974 };
975
976 static config_pair_t const config_5_attribute_list[] = {
977 { EGL_BUFFER_SIZE, 32 },
978 { EGL_ALPHA_SIZE, 8 },
979 { EGL_BLUE_SIZE, 8 },
980 { EGL_GREEN_SIZE, 8 },
981 { EGL_RED_SIZE, 8 },
982 { EGL_DEPTH_SIZE, 16 },
983 { EGL_CONFIG_ID, 3 },
984 { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_RGBA_8888 },
985 { EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT },
986 };
987
988 // A8 configs
989 static config_pair_t const config_6_attribute_list[] = {
990 { EGL_BUFFER_SIZE, 8 },
991 { EGL_ALPHA_SIZE, 8 },
992 { EGL_BLUE_SIZE, 0 },
993 { EGL_GREEN_SIZE, 0 },
994 { EGL_RED_SIZE, 0 },
995 { EGL_DEPTH_SIZE, 0 },
996 { EGL_CONFIG_ID, 4 },
997 { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_A_8 },
998 { EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT },
999 };
1000
1001 static config_pair_t const config_7_attribute_list[] = {
1002 { EGL_BUFFER_SIZE, 8 },
1003 { EGL_ALPHA_SIZE, 8 },
1004 { EGL_BLUE_SIZE, 0 },
1005 { EGL_GREEN_SIZE, 0 },
1006 { EGL_RED_SIZE, 0 },
1007 { EGL_DEPTH_SIZE, 16 },
1008 { EGL_CONFIG_ID, 5 },
1009 { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_A_8 },
1010 { EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT },
1011 };
1012
1013 static configs_t const gConfigs[] = {
1014 { config_0_attribute_list, NELEM(config_0_attribute_list) },
1015 { config_1_attribute_list, NELEM(config_1_attribute_list) },
1016 { config_2_attribute_list, NELEM(config_2_attribute_list) },
1017 { config_3_attribute_list, NELEM(config_3_attribute_list) },
1018 { config_4_attribute_list, NELEM(config_4_attribute_list) },
1019 { config_5_attribute_list, NELEM(config_5_attribute_list) },
1020 { config_6_attribute_list, NELEM(config_6_attribute_list) },
1021 { config_7_attribute_list, NELEM(config_7_attribute_list) },
1022 };
1023
1024 static config_management_t const gConfigManagement[] = {
1025 { EGL_BUFFER_SIZE, config_management_t::atLeast },
1026 { EGL_ALPHA_SIZE, config_management_t::atLeast },
1027 { EGL_BLUE_SIZE, config_management_t::atLeast },
1028 { EGL_GREEN_SIZE, config_management_t::atLeast },
1029 { EGL_RED_SIZE, config_management_t::atLeast },
1030 { EGL_DEPTH_SIZE, config_management_t::atLeast },
1031 { EGL_STENCIL_SIZE, config_management_t::atLeast },
1032 { EGL_CONFIG_CAVEAT, config_management_t::exact },
1033 { EGL_CONFIG_ID, config_management_t::exact },
1034 { EGL_LEVEL, config_management_t::exact },
1035 { EGL_MAX_PBUFFER_HEIGHT, config_management_t::ignore },
1036 { EGL_MAX_PBUFFER_PIXELS, config_management_t::ignore },
1037 { EGL_MAX_PBUFFER_WIDTH, config_management_t::ignore },
1038 { EGL_NATIVE_RENDERABLE, config_management_t::exact },
1039 { EGL_NATIVE_VISUAL_ID, config_management_t::ignore },
1040 { EGL_NATIVE_VISUAL_TYPE, config_management_t::exact },
1041 { EGL_SAMPLES, config_management_t::exact },
1042 { EGL_SAMPLE_BUFFERS, config_management_t::exact },
1043 { EGL_SURFACE_TYPE, config_management_t::mask },
1044 { EGL_TRANSPARENT_TYPE, config_management_t::exact },
1045 { EGL_TRANSPARENT_BLUE_VALUE, config_management_t::exact },
1046 { EGL_TRANSPARENT_GREEN_VALUE, config_management_t::exact },
1047 { EGL_TRANSPARENT_RED_VALUE, config_management_t::exact },
1048 { EGL_BIND_TO_TEXTURE_RGBA, config_management_t::exact },
1049 { EGL_BIND_TO_TEXTURE_RGB, config_management_t::exact },
1050 { EGL_MIN_SWAP_INTERVAL, config_management_t::exact },
1051 { EGL_MAX_SWAP_INTERVAL, config_management_t::exact },
1052 { EGL_LUMINANCE_SIZE, config_management_t::atLeast },
1053 { EGL_ALPHA_MASK_SIZE, config_management_t::atLeast },
1054 { EGL_COLOR_BUFFER_TYPE, config_management_t::exact },
1055 { EGL_RENDERABLE_TYPE, config_management_t::mask },
1056 { EGL_CONFORMANT, config_management_t::mask }
1057 };
1058
1059
1060 static config_pair_t const config_defaults[] = {
1061 // attributes that are not specified are simply ignored, if a particular
1062 // one needs not be ignored, it must be specified here, eg:
1063 // { EGL_SURFACE_TYPE, EGL_WINDOW_BIT },
1064 };
1065
1066 // ----------------------------------------------------------------------------
1067
getConfigFormatInfo(EGLint configID,int32_t & pixelFormat,int32_t & depthFormat)1068 static status_t getConfigFormatInfo(EGLint configID,
1069 int32_t& pixelFormat, int32_t& depthFormat)
1070 {
1071 switch(configID) {
1072 case 0:
1073 pixelFormat = GGL_PIXEL_FORMAT_RGB_565;
1074 depthFormat = 0;
1075 break;
1076 case 1:
1077 pixelFormat = GGL_PIXEL_FORMAT_RGB_565;
1078 depthFormat = GGL_PIXEL_FORMAT_Z_16;
1079 break;
1080 case 2:
1081 pixelFormat = GGL_PIXEL_FORMAT_RGBX_8888;
1082 depthFormat = 0;
1083 break;
1084 case 3:
1085 pixelFormat = GGL_PIXEL_FORMAT_RGBX_8888;
1086 depthFormat = GGL_PIXEL_FORMAT_Z_16;
1087 break;
1088 case 4:
1089 pixelFormat = GGL_PIXEL_FORMAT_RGBA_8888;
1090 depthFormat = 0;
1091 break;
1092 case 5:
1093 pixelFormat = GGL_PIXEL_FORMAT_RGBA_8888;
1094 depthFormat = GGL_PIXEL_FORMAT_Z_16;
1095 break;
1096 case 6:
1097 pixelFormat = GGL_PIXEL_FORMAT_A_8;
1098 depthFormat = 0;
1099 break;
1100 case 7:
1101 pixelFormat = GGL_PIXEL_FORMAT_A_8;
1102 depthFormat = GGL_PIXEL_FORMAT_Z_16;
1103 break;
1104 default:
1105 return NAME_NOT_FOUND;
1106 }
1107 return NO_ERROR;
1108 }
1109
1110 // ----------------------------------------------------------------------------
1111
1112 template<typename T>
binarySearch(T const sortedArray[],int first,int last,EGLint key)1113 static int binarySearch(T const sortedArray[], int first, int last, EGLint key)
1114 {
1115 while (first <= last) {
1116 int mid = (first + last) / 2;
1117 if (key > sortedArray[mid].key) {
1118 first = mid + 1;
1119 } else if (key < sortedArray[mid].key) {
1120 last = mid - 1;
1121 } else {
1122 return mid;
1123 }
1124 }
1125 return -1;
1126 }
1127
isAttributeMatching(int i,EGLint attr,EGLint val)1128 static int isAttributeMatching(int i, EGLint attr, EGLint val)
1129 {
1130 // look for the attribute in all of our configs
1131 config_pair_t const* configFound = gConfigs[i].array;
1132 int index = binarySearch<config_pair_t>(
1133 gConfigs[i].array,
1134 0, gConfigs[i].size-1,
1135 attr);
1136 if (index < 0) {
1137 configFound = config_base_attribute_list;
1138 index = binarySearch<config_pair_t>(
1139 config_base_attribute_list,
1140 0, NELEM(config_base_attribute_list)-1,
1141 attr);
1142 }
1143 if (index >= 0) {
1144 // attribute found, check if this config could match
1145 int cfgMgtIndex = binarySearch<config_management_t>(
1146 gConfigManagement,
1147 0, NELEM(gConfigManagement)-1,
1148 attr);
1149 if (cfgMgtIndex >= 0) {
1150 bool match = gConfigManagement[cfgMgtIndex].match(
1151 val, configFound[index].value);
1152 if (match) {
1153 // this config matches
1154 return 1;
1155 }
1156 } else {
1157 // attribute not found. this should NEVER happen.
1158 }
1159 } else {
1160 // error, this attribute doesn't exist
1161 }
1162 return 0;
1163 }
1164
makeCurrent(ogles_context_t * gl)1165 static int makeCurrent(ogles_context_t* gl)
1166 {
1167 ogles_context_t* current = (ogles_context_t*)getGlThreadSpecific();
1168 if (gl) {
1169 egl_context_t* c = egl_context_t::context(gl);
1170 if (c->flags & egl_context_t::IS_CURRENT) {
1171 if (current != gl) {
1172 // it is an error to set a context current, if it's already
1173 // current to another thread
1174 return -1;
1175 }
1176 } else {
1177 if (current) {
1178 // mark the current context as not current, and flush
1179 glFlush();
1180 egl_context_t::context(current)->flags &= ~egl_context_t::IS_CURRENT;
1181 }
1182 }
1183 if (!(c->flags & egl_context_t::IS_CURRENT)) {
1184 // The context is not current, make it current!
1185 setGlThreadSpecific(gl);
1186 c->flags |= egl_context_t::IS_CURRENT;
1187 }
1188 } else {
1189 if (current) {
1190 // mark the current context as not current, and flush
1191 glFlush();
1192 egl_context_t::context(current)->flags &= ~egl_context_t::IS_CURRENT;
1193 }
1194 // this thread has no context attached to it
1195 setGlThreadSpecific(0);
1196 }
1197 return 0;
1198 }
1199
getConfigAttrib(EGLDisplay dpy,EGLConfig config,EGLint attribute,EGLint * value)1200 static EGLBoolean getConfigAttrib(EGLDisplay dpy, EGLConfig config,
1201 EGLint attribute, EGLint *value)
1202 {
1203 size_t numConfigs = NELEM(gConfigs);
1204 int index = (int)config;
1205 if (uint32_t(index) >= numConfigs)
1206 return setError(EGL_BAD_CONFIG, EGL_FALSE);
1207
1208 int attrIndex;
1209 attrIndex = binarySearch<config_pair_t>(
1210 gConfigs[index].array,
1211 0, gConfigs[index].size-1,
1212 attribute);
1213 if (attrIndex>=0) {
1214 *value = gConfigs[index].array[attrIndex].value;
1215 return EGL_TRUE;
1216 }
1217
1218 attrIndex = binarySearch<config_pair_t>(
1219 config_base_attribute_list,
1220 0, NELEM(config_base_attribute_list)-1,
1221 attribute);
1222 if (attrIndex>=0) {
1223 *value = config_base_attribute_list[attrIndex].value;
1224 return EGL_TRUE;
1225 }
1226 return setError(EGL_BAD_ATTRIBUTE, EGL_FALSE);
1227 }
1228
createWindowSurface(EGLDisplay dpy,EGLConfig config,NativeWindowType window,const EGLint * attrib_list)1229 static EGLSurface createWindowSurface(EGLDisplay dpy, EGLConfig config,
1230 NativeWindowType window, const EGLint *attrib_list)
1231 {
1232 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1233 return setError(EGL_BAD_DISPLAY, EGL_NO_SURFACE);
1234 if (window == 0)
1235 return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
1236
1237 EGLint surfaceType;
1238 if (getConfigAttrib(dpy, config, EGL_SURFACE_TYPE, &surfaceType) == EGL_FALSE)
1239 return EGL_FALSE;
1240
1241 if (!(surfaceType & EGL_WINDOW_BIT))
1242 return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
1243
1244 if (static_cast<ANativeWindow*>(window)->common.magic !=
1245 ANDROID_NATIVE_WINDOW_MAGIC) {
1246 return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
1247 }
1248
1249 EGLint configID;
1250 if (getConfigAttrib(dpy, config, EGL_CONFIG_ID, &configID) == EGL_FALSE)
1251 return EGL_FALSE;
1252
1253 int32_t depthFormat;
1254 int32_t pixelFormat;
1255 if (getConfigFormatInfo(configID, pixelFormat, depthFormat) != NO_ERROR) {
1256 return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
1257 }
1258
1259 // FIXME: we don't have access to the pixelFormat here just yet.
1260 // (it's possible that the surface is not fully initialized)
1261 // maybe this should be done after the page-flip
1262 //if (EGLint(info.format) != pixelFormat)
1263 // return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
1264
1265 egl_surface_t* surface;
1266 surface = new egl_window_surface_v2_t(dpy, config, depthFormat,
1267 static_cast<ANativeWindow*>(window));
1268
1269 if (!surface->initCheck()) {
1270 // there was a problem in the ctor, the error
1271 // flag has been set.
1272 delete surface;
1273 surface = 0;
1274 }
1275 return surface;
1276 }
1277
createPixmapSurface(EGLDisplay dpy,EGLConfig config,NativePixmapType pixmap,const EGLint * attrib_list)1278 static EGLSurface createPixmapSurface(EGLDisplay dpy, EGLConfig config,
1279 NativePixmapType pixmap, const EGLint *attrib_list)
1280 {
1281 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1282 return setError(EGL_BAD_DISPLAY, EGL_NO_SURFACE);
1283 if (pixmap == 0)
1284 return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
1285
1286 EGLint surfaceType;
1287 if (getConfigAttrib(dpy, config, EGL_SURFACE_TYPE, &surfaceType) == EGL_FALSE)
1288 return EGL_FALSE;
1289
1290 if (!(surfaceType & EGL_PIXMAP_BIT))
1291 return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
1292
1293 if (static_cast<egl_native_pixmap_t*>(pixmap)->version !=
1294 sizeof(egl_native_pixmap_t)) {
1295 return setError(EGL_BAD_NATIVE_PIXMAP, EGL_NO_SURFACE);
1296 }
1297
1298 EGLint configID;
1299 if (getConfigAttrib(dpy, config, EGL_CONFIG_ID, &configID) == EGL_FALSE)
1300 return EGL_FALSE;
1301
1302 int32_t depthFormat;
1303 int32_t pixelFormat;
1304 if (getConfigFormatInfo(configID, pixelFormat, depthFormat) != NO_ERROR) {
1305 return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
1306 }
1307
1308 if (pixmap->format != pixelFormat)
1309 return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
1310
1311 egl_surface_t* surface =
1312 new egl_pixmap_surface_t(dpy, config, depthFormat,
1313 static_cast<egl_native_pixmap_t*>(pixmap));
1314
1315 if (!surface->initCheck()) {
1316 // there was a problem in the ctor, the error
1317 // flag has been set.
1318 delete surface;
1319 surface = 0;
1320 }
1321 return surface;
1322 }
1323
createPbufferSurface(EGLDisplay dpy,EGLConfig config,const EGLint * attrib_list)1324 static EGLSurface createPbufferSurface(EGLDisplay dpy, EGLConfig config,
1325 const EGLint *attrib_list)
1326 {
1327 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1328 return setError(EGL_BAD_DISPLAY, EGL_NO_SURFACE);
1329
1330 EGLint surfaceType;
1331 if (getConfigAttrib(dpy, config, EGL_SURFACE_TYPE, &surfaceType) == EGL_FALSE)
1332 return EGL_FALSE;
1333
1334 if (!(surfaceType & EGL_PBUFFER_BIT))
1335 return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
1336
1337 EGLint configID;
1338 if (getConfigAttrib(dpy, config, EGL_CONFIG_ID, &configID) == EGL_FALSE)
1339 return EGL_FALSE;
1340
1341 int32_t depthFormat;
1342 int32_t pixelFormat;
1343 if (getConfigFormatInfo(configID, pixelFormat, depthFormat) != NO_ERROR) {
1344 return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
1345 }
1346
1347 int32_t w = 0;
1348 int32_t h = 0;
1349 while (attrib_list[0]) {
1350 if (attrib_list[0] == EGL_WIDTH) w = attrib_list[1];
1351 if (attrib_list[0] == EGL_HEIGHT) h = attrib_list[1];
1352 attrib_list+=2;
1353 }
1354
1355 egl_surface_t* surface =
1356 new egl_pbuffer_surface_t(dpy, config, depthFormat, w, h, pixelFormat);
1357
1358 if (!surface->initCheck()) {
1359 // there was a problem in the ctor, the error
1360 // flag has been set.
1361 delete surface;
1362 surface = 0;
1363 }
1364 return surface;
1365 }
1366
1367 // ----------------------------------------------------------------------------
1368 }; // namespace android
1369 // ----------------------------------------------------------------------------
1370
1371 using namespace android;
1372
1373 // ----------------------------------------------------------------------------
1374 // Initialization
1375 // ----------------------------------------------------------------------------
1376
eglGetDisplay(NativeDisplayType display)1377 EGLDisplay eglGetDisplay(NativeDisplayType display)
1378 {
1379 #ifndef HAVE_ANDROID_OS
1380 // this just needs to be done once
1381 if (gGLKey == -1) {
1382 pthread_mutex_lock(&gInitMutex);
1383 if (gGLKey == -1)
1384 pthread_key_create(&gGLKey, NULL);
1385 pthread_mutex_unlock(&gInitMutex);
1386 }
1387 #endif
1388 if (display == EGL_DEFAULT_DISPLAY) {
1389 EGLDisplay dpy = (EGLDisplay)1;
1390 egl_display_t& d = egl_display_t::get_display(dpy);
1391 d.type = display;
1392 return dpy;
1393 }
1394 return EGL_NO_DISPLAY;
1395 }
1396
eglInitialize(EGLDisplay dpy,EGLint * major,EGLint * minor)1397 EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
1398 {
1399 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1400 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1401
1402 EGLBoolean res = EGL_TRUE;
1403 egl_display_t& d = egl_display_t::get_display(dpy);
1404
1405 if (android_atomic_inc(&d.initialized) == 0) {
1406 // initialize stuff here if needed
1407 //pthread_mutex_lock(&gInitMutex);
1408 //pthread_mutex_unlock(&gInitMutex);
1409 }
1410
1411 if (res == EGL_TRUE) {
1412 if (major != NULL) *major = VERSION_MAJOR;
1413 if (minor != NULL) *minor = VERSION_MINOR;
1414 }
1415 return res;
1416 }
1417
eglTerminate(EGLDisplay dpy)1418 EGLBoolean eglTerminate(EGLDisplay dpy)
1419 {
1420 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1421 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1422
1423 EGLBoolean res = EGL_TRUE;
1424 egl_display_t& d = egl_display_t::get_display(dpy);
1425 if (android_atomic_dec(&d.initialized) == 1) {
1426 // TODO: destroy all resources (surfaces, contexts, etc...)
1427 //pthread_mutex_lock(&gInitMutex);
1428 //pthread_mutex_unlock(&gInitMutex);
1429 }
1430 return res;
1431 }
1432
1433 // ----------------------------------------------------------------------------
1434 // configuration
1435 // ----------------------------------------------------------------------------
1436
eglGetConfigs(EGLDisplay dpy,EGLConfig * configs,EGLint config_size,EGLint * num_config)1437 EGLBoolean eglGetConfigs( EGLDisplay dpy,
1438 EGLConfig *configs,
1439 EGLint config_size, EGLint *num_config)
1440 {
1441 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1442 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1443
1444 GLint numConfigs = NELEM(gConfigs);
1445 if (!configs) {
1446 *num_config = numConfigs;
1447 return EGL_TRUE;
1448 }
1449 GLint i;
1450 for (i=0 ; i<numConfigs && i<config_size ; i++) {
1451 *configs++ = (EGLConfig)i;
1452 }
1453 *num_config = i;
1454 return EGL_TRUE;
1455 }
1456
eglChooseConfig(EGLDisplay dpy,const EGLint * attrib_list,EGLConfig * configs,EGLint config_size,EGLint * num_config)1457 EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list,
1458 EGLConfig *configs, EGLint config_size,
1459 EGLint *num_config)
1460 {
1461 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1462 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1463
1464 if (ggl_unlikely(num_config==0)) {
1465 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1466 }
1467
1468 if (ggl_unlikely(attrib_list==0)) {
1469 /*
1470 * A NULL attrib_list should be treated as though it was an empty
1471 * one (terminated with EGL_NONE) as defined in
1472 * section 3.4.1 "Querying Configurations" in the EGL specification.
1473 */
1474 static const EGLint dummy = EGL_NONE;
1475 attrib_list = &dummy;
1476 }
1477
1478 int numAttributes = 0;
1479 int numConfigs = NELEM(gConfigs);
1480 uint32_t possibleMatch = (1<<numConfigs)-1;
1481 while(possibleMatch && *attrib_list != EGL_NONE) {
1482 numAttributes++;
1483 EGLint attr = *attrib_list++;
1484 EGLint val = *attrib_list++;
1485 for (int i=0 ; possibleMatch && i<numConfigs ; i++) {
1486 if (!(possibleMatch & (1<<i)))
1487 continue;
1488 if (isAttributeMatching(i, attr, val) == 0) {
1489 possibleMatch &= ~(1<<i);
1490 }
1491 }
1492 }
1493
1494 // now, handle the attributes which have a useful default value
1495 for (size_t j=0 ; possibleMatch && j<NELEM(config_defaults) ; j++) {
1496 // see if this attribute was specified, if not, apply its
1497 // default value
1498 if (binarySearch<config_pair_t>(
1499 (config_pair_t const*)attrib_list,
1500 0, numAttributes-1,
1501 config_defaults[j].key) < 0)
1502 {
1503 for (int i=0 ; possibleMatch && i<numConfigs ; i++) {
1504 if (!(possibleMatch & (1<<i)))
1505 continue;
1506 if (isAttributeMatching(i,
1507 config_defaults[j].key,
1508 config_defaults[j].value) == 0)
1509 {
1510 possibleMatch &= ~(1<<i);
1511 }
1512 }
1513 }
1514 }
1515
1516 // return the configurations found
1517 int n=0;
1518 if (possibleMatch) {
1519 if (configs) {
1520 for (int i=0 ; config_size && i<numConfigs ; i++) {
1521 if (possibleMatch & (1<<i)) {
1522 *configs++ = (EGLConfig)i;
1523 config_size--;
1524 n++;
1525 }
1526 }
1527 } else {
1528 for (int i=0 ; i<numConfigs ; i++) {
1529 if (possibleMatch & (1<<i)) {
1530 n++;
1531 }
1532 }
1533 }
1534 }
1535 *num_config = n;
1536 return EGL_TRUE;
1537 }
1538
eglGetConfigAttrib(EGLDisplay dpy,EGLConfig config,EGLint attribute,EGLint * value)1539 EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
1540 EGLint attribute, EGLint *value)
1541 {
1542 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1543 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1544
1545 return getConfigAttrib(dpy, config, attribute, value);
1546 }
1547
1548 // ----------------------------------------------------------------------------
1549 // surfaces
1550 // ----------------------------------------------------------------------------
1551
eglCreateWindowSurface(EGLDisplay dpy,EGLConfig config,NativeWindowType window,const EGLint * attrib_list)1552 EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config,
1553 NativeWindowType window,
1554 const EGLint *attrib_list)
1555 {
1556 return createWindowSurface(dpy, config, window, attrib_list);
1557 }
1558
eglCreatePixmapSurface(EGLDisplay dpy,EGLConfig config,NativePixmapType pixmap,const EGLint * attrib_list)1559 EGLSurface eglCreatePixmapSurface( EGLDisplay dpy, EGLConfig config,
1560 NativePixmapType pixmap,
1561 const EGLint *attrib_list)
1562 {
1563 return createPixmapSurface(dpy, config, pixmap, attrib_list);
1564 }
1565
eglCreatePbufferSurface(EGLDisplay dpy,EGLConfig config,const EGLint * attrib_list)1566 EGLSurface eglCreatePbufferSurface( EGLDisplay dpy, EGLConfig config,
1567 const EGLint *attrib_list)
1568 {
1569 return createPbufferSurface(dpy, config, attrib_list);
1570 }
1571
eglDestroySurface(EGLDisplay dpy,EGLSurface eglSurface)1572 EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface eglSurface)
1573 {
1574 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1575 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1576 if (eglSurface != EGL_NO_SURFACE) {
1577 egl_surface_t* surface( static_cast<egl_surface_t*>(eglSurface) );
1578 if (!surface->isValid())
1579 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1580 if (surface->dpy != dpy)
1581 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1582 if (surface->ctx) {
1583 // FIXME: this surface is current check what the spec says
1584 surface->disconnect();
1585 surface->ctx = 0;
1586 }
1587 delete surface;
1588 }
1589 return EGL_TRUE;
1590 }
1591
eglQuerySurface(EGLDisplay dpy,EGLSurface eglSurface,EGLint attribute,EGLint * value)1592 EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface eglSurface,
1593 EGLint attribute, EGLint *value)
1594 {
1595 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1596 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1597 egl_surface_t* surface = static_cast<egl_surface_t*>(eglSurface);
1598 if (!surface->isValid())
1599 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1600 if (surface->dpy != dpy)
1601 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1602
1603 EGLBoolean ret = EGL_TRUE;
1604 switch (attribute) {
1605 case EGL_CONFIG_ID:
1606 ret = getConfigAttrib(dpy, surface->config, EGL_CONFIG_ID, value);
1607 break;
1608 case EGL_WIDTH:
1609 *value = surface->getWidth();
1610 break;
1611 case EGL_HEIGHT:
1612 *value = surface->getHeight();
1613 break;
1614 case EGL_LARGEST_PBUFFER:
1615 // not modified for a window or pixmap surface
1616 break;
1617 case EGL_TEXTURE_FORMAT:
1618 *value = EGL_NO_TEXTURE;
1619 break;
1620 case EGL_TEXTURE_TARGET:
1621 *value = EGL_NO_TEXTURE;
1622 break;
1623 case EGL_MIPMAP_TEXTURE:
1624 *value = EGL_FALSE;
1625 break;
1626 case EGL_MIPMAP_LEVEL:
1627 *value = 0;
1628 break;
1629 case EGL_RENDER_BUFFER:
1630 // TODO: return the real RENDER_BUFFER here
1631 *value = EGL_BACK_BUFFER;
1632 break;
1633 case EGL_HORIZONTAL_RESOLUTION:
1634 // pixel/mm * EGL_DISPLAY_SCALING
1635 *value = surface->getHorizontalResolution();
1636 break;
1637 case EGL_VERTICAL_RESOLUTION:
1638 // pixel/mm * EGL_DISPLAY_SCALING
1639 *value = surface->getVerticalResolution();
1640 break;
1641 case EGL_PIXEL_ASPECT_RATIO: {
1642 // w/h * EGL_DISPLAY_SCALING
1643 int wr = surface->getHorizontalResolution();
1644 int hr = surface->getVerticalResolution();
1645 *value = (wr * EGL_DISPLAY_SCALING) / hr;
1646 } break;
1647 case EGL_SWAP_BEHAVIOR:
1648 *value = surface->getSwapBehavior();
1649 break;
1650 default:
1651 ret = setError(EGL_BAD_ATTRIBUTE, EGL_FALSE);
1652 }
1653 return ret;
1654 }
1655
eglCreateContext(EGLDisplay dpy,EGLConfig config,EGLContext share_list,const EGLint * attrib_list)1656 EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,
1657 EGLContext share_list, const EGLint *attrib_list)
1658 {
1659 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1660 return setError(EGL_BAD_DISPLAY, EGL_NO_SURFACE);
1661
1662 ogles_context_t* gl = ogles_init(sizeof(egl_context_t));
1663 if (!gl) return setError(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
1664
1665 egl_context_t* c = static_cast<egl_context_t*>(gl->rasterizer.base);
1666 c->flags = egl_context_t::NEVER_CURRENT;
1667 c->dpy = dpy;
1668 c->config = config;
1669 c->read = 0;
1670 c->draw = 0;
1671 return (EGLContext)gl;
1672 }
1673
eglDestroyContext(EGLDisplay dpy,EGLContext ctx)1674 EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
1675 {
1676 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1677 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1678 egl_context_t* c = egl_context_t::context(ctx);
1679 if (c->flags & egl_context_t::IS_CURRENT)
1680 setGlThreadSpecific(0);
1681 ogles_uninit((ogles_context_t*)ctx);
1682 return EGL_TRUE;
1683 }
1684
eglMakeCurrent(EGLDisplay dpy,EGLSurface draw,EGLSurface read,EGLContext ctx)1685 EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw,
1686 EGLSurface read, EGLContext ctx)
1687 {
1688 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1689 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1690 if (draw) {
1691 egl_surface_t* s = (egl_surface_t*)draw;
1692 if (!s->isValid())
1693 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1694 if (s->dpy != dpy)
1695 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1696 // TODO: check that draw is compatible with the context
1697 }
1698 if (read && read!=draw) {
1699 egl_surface_t* s = (egl_surface_t*)read;
1700 if (!s->isValid())
1701 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1702 if (s->dpy != dpy)
1703 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1704 // TODO: check that read is compatible with the context
1705 }
1706
1707 EGLContext current_ctx = EGL_NO_CONTEXT;
1708
1709 if ((read == EGL_NO_SURFACE && draw == EGL_NO_SURFACE) && (ctx != EGL_NO_CONTEXT))
1710 return setError(EGL_BAD_MATCH, EGL_FALSE);
1711
1712 if ((read != EGL_NO_SURFACE || draw != EGL_NO_SURFACE) && (ctx == EGL_NO_CONTEXT))
1713 return setError(EGL_BAD_MATCH, EGL_FALSE);
1714
1715 if (ctx == EGL_NO_CONTEXT) {
1716 // if we're detaching, we need the current context
1717 current_ctx = (EGLContext)getGlThreadSpecific();
1718 } else {
1719 egl_context_t* c = egl_context_t::context(ctx);
1720 egl_surface_t* d = (egl_surface_t*)draw;
1721 egl_surface_t* r = (egl_surface_t*)read;
1722 if ((d && d->ctx && d->ctx != ctx) ||
1723 (r && r->ctx && r->ctx != ctx)) {
1724 // one of the surface is bound to a context in another thread
1725 return setError(EGL_BAD_ACCESS, EGL_FALSE);
1726 }
1727 }
1728
1729 ogles_context_t* gl = (ogles_context_t*)ctx;
1730 if (makeCurrent(gl) == 0) {
1731 if (ctx) {
1732 egl_context_t* c = egl_context_t::context(ctx);
1733 egl_surface_t* d = (egl_surface_t*)draw;
1734 egl_surface_t* r = (egl_surface_t*)read;
1735
1736 if (c->draw) {
1737 egl_surface_t* s = reinterpret_cast<egl_surface_t*>(c->draw);
1738 s->disconnect();
1739 }
1740 if (c->read) {
1741 // FIXME: unlock/disconnect the read surface too
1742 }
1743
1744 c->draw = draw;
1745 c->read = read;
1746
1747 if (c->flags & egl_context_t::NEVER_CURRENT) {
1748 c->flags &= ~egl_context_t::NEVER_CURRENT;
1749 GLint w = 0;
1750 GLint h = 0;
1751 if (draw) {
1752 w = d->getWidth();
1753 h = d->getHeight();
1754 }
1755 ogles_surfaceport(gl, 0, 0);
1756 ogles_viewport(gl, 0, 0, w, h);
1757 ogles_scissor(gl, 0, 0, w, h);
1758 }
1759 if (d) {
1760 if (d->connect() == EGL_FALSE) {
1761 return EGL_FALSE;
1762 }
1763 d->ctx = ctx;
1764 d->bindDrawSurface(gl);
1765 }
1766 if (r) {
1767 // FIXME: lock/connect the read surface too
1768 r->ctx = ctx;
1769 r->bindReadSurface(gl);
1770 }
1771 } else {
1772 // if surfaces were bound to the context bound to this thread
1773 // mark then as unbound.
1774 if (current_ctx) {
1775 egl_context_t* c = egl_context_t::context(current_ctx);
1776 egl_surface_t* d = (egl_surface_t*)c->draw;
1777 egl_surface_t* r = (egl_surface_t*)c->read;
1778 if (d) {
1779 c->draw = 0;
1780 d->ctx = EGL_NO_CONTEXT;
1781 d->disconnect();
1782 }
1783 if (r) {
1784 c->read = 0;
1785 r->ctx = EGL_NO_CONTEXT;
1786 // FIXME: unlock/disconnect the read surface too
1787 }
1788 }
1789 }
1790 return EGL_TRUE;
1791 }
1792 return setError(EGL_BAD_ACCESS, EGL_FALSE);
1793 }
1794
eglGetCurrentContext(void)1795 EGLContext eglGetCurrentContext(void)
1796 {
1797 // eglGetCurrentContext returns the current EGL rendering context,
1798 // as specified by eglMakeCurrent. If no context is current,
1799 // EGL_NO_CONTEXT is returned.
1800 return (EGLContext)getGlThreadSpecific();
1801 }
1802
eglGetCurrentSurface(EGLint readdraw)1803 EGLSurface eglGetCurrentSurface(EGLint readdraw)
1804 {
1805 // eglGetCurrentSurface returns the read or draw surface attached
1806 // to the current EGL rendering context, as specified by eglMakeCurrent.
1807 // If no context is current, EGL_NO_SURFACE is returned.
1808 EGLContext ctx = (EGLContext)getGlThreadSpecific();
1809 if (ctx == EGL_NO_CONTEXT) return EGL_NO_SURFACE;
1810 egl_context_t* c = egl_context_t::context(ctx);
1811 if (readdraw == EGL_READ) {
1812 return c->read;
1813 } else if (readdraw == EGL_DRAW) {
1814 return c->draw;
1815 }
1816 return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
1817 }
1818
eglGetCurrentDisplay(void)1819 EGLDisplay eglGetCurrentDisplay(void)
1820 {
1821 // eglGetCurrentDisplay returns the current EGL display connection
1822 // for the current EGL rendering context, as specified by eglMakeCurrent.
1823 // If no context is current, EGL_NO_DISPLAY is returned.
1824 EGLContext ctx = (EGLContext)getGlThreadSpecific();
1825 if (ctx == EGL_NO_CONTEXT) return EGL_NO_DISPLAY;
1826 egl_context_t* c = egl_context_t::context(ctx);
1827 return c->dpy;
1828 }
1829
eglQueryContext(EGLDisplay dpy,EGLContext ctx,EGLint attribute,EGLint * value)1830 EGLBoolean eglQueryContext( EGLDisplay dpy, EGLContext ctx,
1831 EGLint attribute, EGLint *value)
1832 {
1833 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1834 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1835 egl_context_t* c = egl_context_t::context(ctx);
1836 switch (attribute) {
1837 case EGL_CONFIG_ID:
1838 // Returns the ID of the EGL frame buffer configuration with
1839 // respect to which the context was created
1840 return getConfigAttrib(dpy, c->config, EGL_CONFIG_ID, value);
1841 }
1842 return setError(EGL_BAD_ATTRIBUTE, EGL_FALSE);
1843 }
1844
eglWaitGL(void)1845 EGLBoolean eglWaitGL(void)
1846 {
1847 return EGL_TRUE;
1848 }
1849
eglWaitNative(EGLint engine)1850 EGLBoolean eglWaitNative(EGLint engine)
1851 {
1852 return EGL_TRUE;
1853 }
1854
eglSwapBuffers(EGLDisplay dpy,EGLSurface draw)1855 EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw)
1856 {
1857 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1858 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1859
1860 egl_surface_t* d = static_cast<egl_surface_t*>(draw);
1861 if (!d->isValid())
1862 return setError(EGL_BAD_SURFACE, EGL_FALSE);
1863 if (d->dpy != dpy)
1864 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1865
1866 // post the surface
1867 d->swapBuffers();
1868
1869 // if it's bound to a context, update the buffer
1870 if (d->ctx != EGL_NO_CONTEXT) {
1871 d->bindDrawSurface((ogles_context_t*)d->ctx);
1872 // if this surface is also the read surface of the context
1873 // it is bound to, make sure to update the read buffer as well.
1874 // The EGL spec is a little unclear about this.
1875 egl_context_t* c = egl_context_t::context(d->ctx);
1876 if (c->read == draw) {
1877 d->bindReadSurface((ogles_context_t*)d->ctx);
1878 }
1879 }
1880
1881 return EGL_TRUE;
1882 }
1883
eglCopyBuffers(EGLDisplay dpy,EGLSurface surface,NativePixmapType target)1884 EGLBoolean eglCopyBuffers( EGLDisplay dpy, EGLSurface surface,
1885 NativePixmapType target)
1886 {
1887 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1888 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1889 // TODO: eglCopyBuffers()
1890 return EGL_FALSE;
1891 }
1892
eglGetError(void)1893 EGLint eglGetError(void)
1894 {
1895 return getError();
1896 }
1897
eglQueryString(EGLDisplay dpy,EGLint name)1898 const char* eglQueryString(EGLDisplay dpy, EGLint name)
1899 {
1900 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1901 return setError(EGL_BAD_DISPLAY, (const char*)0);
1902
1903 switch (name) {
1904 case EGL_VENDOR:
1905 return gVendorString;
1906 case EGL_VERSION:
1907 return gVersionString;
1908 case EGL_EXTENSIONS:
1909 return gExtensionsString;
1910 case EGL_CLIENT_APIS:
1911 return gClientApiString;
1912 }
1913 return setError(EGL_BAD_PARAMETER, (const char *)0);
1914 }
1915
1916 // ----------------------------------------------------------------------------
1917 // EGL 1.1
1918 // ----------------------------------------------------------------------------
1919
eglSurfaceAttrib(EGLDisplay dpy,EGLSurface surface,EGLint attribute,EGLint value)1920 EGLBoolean eglSurfaceAttrib(
1921 EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
1922 {
1923 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1924 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1925 // TODO: eglSurfaceAttrib()
1926 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1927 }
1928
eglBindTexImage(EGLDisplay dpy,EGLSurface surface,EGLint buffer)1929 EGLBoolean eglBindTexImage(
1930 EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1931 {
1932 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1933 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1934 // TODO: eglBindTexImage()
1935 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1936 }
1937
eglReleaseTexImage(EGLDisplay dpy,EGLSurface surface,EGLint buffer)1938 EGLBoolean eglReleaseTexImage(
1939 EGLDisplay dpy, EGLSurface surface, EGLint buffer)
1940 {
1941 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1942 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1943 // TODO: eglReleaseTexImage()
1944 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1945 }
1946
eglSwapInterval(EGLDisplay dpy,EGLint interval)1947 EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)
1948 {
1949 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1950 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
1951 // TODO: eglSwapInterval()
1952 return EGL_TRUE;
1953 }
1954
1955 // ----------------------------------------------------------------------------
1956 // EGL 1.2
1957 // ----------------------------------------------------------------------------
1958
eglBindAPI(EGLenum api)1959 EGLBoolean eglBindAPI(EGLenum api)
1960 {
1961 if (api != EGL_OPENGL_ES_API)
1962 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
1963 return EGL_TRUE;
1964 }
1965
eglQueryAPI(void)1966 EGLenum eglQueryAPI(void)
1967 {
1968 return EGL_OPENGL_ES_API;
1969 }
1970
eglWaitClient(void)1971 EGLBoolean eglWaitClient(void)
1972 {
1973 glFinish();
1974 return EGL_TRUE;
1975 }
1976
eglReleaseThread(void)1977 EGLBoolean eglReleaseThread(void)
1978 {
1979 // TODO: eglReleaseThread()
1980 return EGL_TRUE;
1981 }
1982
eglCreatePbufferFromClientBuffer(EGLDisplay dpy,EGLenum buftype,EGLClientBuffer buffer,EGLConfig config,const EGLint * attrib_list)1983 EGLSurface eglCreatePbufferFromClientBuffer(
1984 EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
1985 EGLConfig config, const EGLint *attrib_list)
1986 {
1987 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
1988 return setError(EGL_BAD_DISPLAY, EGL_NO_SURFACE);
1989 // TODO: eglCreatePbufferFromClientBuffer()
1990 return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
1991 }
1992
1993 // ----------------------------------------------------------------------------
1994 // EGL_EGLEXT_VERSION 3
1995 // ----------------------------------------------------------------------------
1996
eglGetProcAddress(const char * procname)1997 void (*eglGetProcAddress (const char *procname))()
1998 {
1999 extention_map_t const * const map = gExtentionMap;
2000 for (uint32_t i=0 ; i<NELEM(gExtentionMap) ; i++) {
2001 if (!strcmp(procname, map[i].name)) {
2002 return map[i].address;
2003 }
2004 }
2005 return NULL;
2006 }
2007
eglLockSurfaceKHR(EGLDisplay dpy,EGLSurface surface,const EGLint * attrib_list)2008 EGLBoolean eglLockSurfaceKHR(EGLDisplay dpy, EGLSurface surface,
2009 const EGLint *attrib_list)
2010 {
2011 EGLBoolean result = EGL_FALSE;
2012 return result;
2013 }
2014
eglUnlockSurfaceKHR(EGLDisplay dpy,EGLSurface surface)2015 EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface)
2016 {
2017 EGLBoolean result = EGL_FALSE;
2018 return result;
2019 }
2020
eglCreateImageKHR(EGLDisplay dpy,EGLContext ctx,EGLenum target,EGLClientBuffer buffer,const EGLint * attrib_list)2021 EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
2022 EGLClientBuffer buffer, const EGLint *attrib_list)
2023 {
2024 if (egl_display_t::is_valid(dpy) == EGL_FALSE) {
2025 return setError(EGL_BAD_DISPLAY, EGL_NO_IMAGE_KHR);
2026 }
2027 if (ctx != EGL_NO_CONTEXT) {
2028 return setError(EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
2029 }
2030 if (target != EGL_NATIVE_BUFFER_ANDROID) {
2031 return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
2032 }
2033
2034 ANativeWindowBuffer* native_buffer = (ANativeWindowBuffer*)buffer;
2035
2036 if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC)
2037 return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
2038
2039 if (native_buffer->common.version != sizeof(ANativeWindowBuffer))
2040 return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
2041
2042 switch (native_buffer->format) {
2043 case HAL_PIXEL_FORMAT_RGBA_8888:
2044 case HAL_PIXEL_FORMAT_RGBX_8888:
2045 case HAL_PIXEL_FORMAT_RGB_888:
2046 case HAL_PIXEL_FORMAT_RGB_565:
2047 case HAL_PIXEL_FORMAT_BGRA_8888:
2048 case HAL_PIXEL_FORMAT_RGBA_5551:
2049 case HAL_PIXEL_FORMAT_RGBA_4444:
2050 break;
2051 default:
2052 return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
2053 }
2054
2055 native_buffer->common.incRef(&native_buffer->common);
2056 return (EGLImageKHR)native_buffer;
2057 }
2058
eglDestroyImageKHR(EGLDisplay dpy,EGLImageKHR img)2059 EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img)
2060 {
2061 if (egl_display_t::is_valid(dpy) == EGL_FALSE) {
2062 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
2063 }
2064
2065 ANativeWindowBuffer* native_buffer = (ANativeWindowBuffer*)img;
2066
2067 if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC)
2068 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
2069
2070 if (native_buffer->common.version != sizeof(ANativeWindowBuffer))
2071 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
2072
2073 native_buffer->common.decRef(&native_buffer->common);
2074
2075 return EGL_TRUE;
2076 }
2077
2078 // ----------------------------------------------------------------------------
2079 // EGL_KHR_fence_sync
2080 // ----------------------------------------------------------------------------
2081
2082 #define FENCE_SYNC_HANDLE ((EGLSyncKHR)0xFE4CE)
2083
eglCreateSyncKHR(EGLDisplay dpy,EGLenum type,const EGLint * attrib_list)2084 EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type,
2085 const EGLint *attrib_list)
2086 {
2087 if (egl_display_t::is_valid(dpy) == EGL_FALSE) {
2088 return setError(EGL_BAD_DISPLAY, EGL_NO_SYNC_KHR);
2089 }
2090
2091 if (type != EGL_SYNC_FENCE_KHR ||
2092 (attrib_list != NULL && attrib_list[0] != EGL_NONE)) {
2093 return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SYNC_KHR);
2094 }
2095
2096 if (eglGetCurrentContext() == EGL_NO_CONTEXT) {
2097 return setError(EGL_BAD_MATCH, EGL_NO_SYNC_KHR);
2098 }
2099
2100 // AGL is synchronous; nothing to do here.
2101
2102 return FENCE_SYNC_HANDLE;
2103 }
2104
eglDestroySyncKHR(EGLDisplay dpy,EGLSyncKHR sync)2105 EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
2106 {
2107 if (sync != FENCE_SYNC_HANDLE) {
2108 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
2109 }
2110
2111 return EGL_TRUE;
2112 }
2113
eglClientWaitSyncKHR(EGLDisplay dpy,EGLSyncKHR sync,EGLint flags,EGLTimeKHR timeout)2114 EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags,
2115 EGLTimeKHR timeout)
2116 {
2117 if (sync != FENCE_SYNC_HANDLE) {
2118 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
2119 }
2120
2121 return EGL_CONDITION_SATISFIED_KHR;
2122 }
2123
eglGetSyncAttribKHR(EGLDisplay dpy,EGLSyncKHR sync,EGLint attribute,EGLint * value)2124 EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync,
2125 EGLint attribute, EGLint *value)
2126 {
2127 if (sync != FENCE_SYNC_HANDLE) {
2128 return setError(EGL_BAD_PARAMETER, EGL_FALSE);
2129 }
2130
2131 switch (attribute) {
2132 case EGL_SYNC_TYPE_KHR:
2133 *value = EGL_SYNC_FENCE_KHR;
2134 return EGL_TRUE;
2135 case EGL_SYNC_STATUS_KHR:
2136 *value = EGL_SIGNALED_KHR;
2137 return EGL_TRUE;
2138 case EGL_SYNC_CONDITION_KHR:
2139 *value = EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR;
2140 return EGL_TRUE;
2141 default:
2142 return setError(EGL_BAD_ATTRIBUTE, EGL_FALSE);
2143 }
2144 }
2145
2146 // ----------------------------------------------------------------------------
2147 // ANDROID extensions
2148 // ----------------------------------------------------------------------------
2149
eglSetSwapRectangleANDROID(EGLDisplay dpy,EGLSurface draw,EGLint left,EGLint top,EGLint width,EGLint height)2150 EGLBoolean eglSetSwapRectangleANDROID(EGLDisplay dpy, EGLSurface draw,
2151 EGLint left, EGLint top, EGLint width, EGLint height)
2152 {
2153 if (egl_display_t::is_valid(dpy) == EGL_FALSE)
2154 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
2155
2156 egl_surface_t* d = static_cast<egl_surface_t*>(draw);
2157 if (!d->isValid())
2158 return setError(EGL_BAD_SURFACE, EGL_FALSE);
2159 if (d->dpy != dpy)
2160 return setError(EGL_BAD_DISPLAY, EGL_FALSE);
2161
2162 // post the surface
2163 d->setSwapRectangle(left, top, width, height);
2164
2165 return EGL_TRUE;
2166 }
2167