gl: Add EGL interface

Enable the EGL backend for GL.

boilerplate/Makefile.win32.features

@@ -199,6 +199,14 @@ enabled_cairo_boilerplate_private += $(cairo_boilerplate_png_private)
 enabled_cairo_boilerplate_sources += $(cairo_boilerplate_png_sources)
 endif
 
+supported_cairo_boilerplate_headers += $(cairo_boilerplate_glew_headers)
+all_cairo_boilerplate_headers += $(cairo_boilerplate_glew_headers)
+all_cairo_boilerplate_private += $(cairo_boilerplate_glew_private)
+all_cairo_boilerplate_sources += $(cairo_boilerplate_glew_sources)
+enabled_cairo_boilerplate_headers += $(cairo_boilerplate_glew_headers)
+enabled_cairo_boilerplate_private += $(cairo_boilerplate_glew_private)
+enabled_cairo_boilerplate_sources += $(cairo_boilerplate_glew_sources)
+
 unsupported_cairo_boilerplate_headers += $(cairo_boilerplate_gl_headers)
 all_cairo_boilerplate_headers += $(cairo_boilerplate_gl_headers)
 all_cairo_boilerplate_private += $(cairo_boilerplate_gl_private)

boilerplate/cairo-boilerplate-gl.c

@@ -237,6 +237,91 @@ _cairo_boilerplate_gl_synchronize (void *closure)
     cairo_gl_surface_glfinish (gltc->surface);
 }
 
+#if CAIRO_HAS_EGL_FUNCTIONS
+typedef struct _egl_target_closure {
+    EGLDisplay dpy;
+    EGLContext ctx;
+
+    cairo_device_t *device;
+    cairo_surface_t *surface;
+} egl_target_closure_t;
+
+static void
+_cairo_boilerplate_egl_cleanup (void *closure)
+{
+    egl_target_closure_t *gltc = closure;
+
+    cairo_device_finish (gltc->device);
+    cairo_device_destroy (gltc->device);
+
+    eglDestroyContext (gltc->dpy, gltc->ctx);
+    eglMakeCurrent (gltc->dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    eglTerminate (gltc->dpy);
+
+    free (gltc);
+}
+
+static cairo_surface_t *
+_cairo_boilerplate_egl_create_surface (const char		 *name,
+				      cairo_content_t		  content,
+				      double			  width,
+				      double			  height,
+				      double			  max_width,
+				      double			  max_height,
+				      cairo_boilerplate_mode_t	  mode,
+				      int			  id,
+				      void			**closure)
+{
+    egl_target_closure_t *gltc;
+    cairo_surface_t *surface;
+    int major, minor;
+    EGLConfig *configs;
+    EGLint numConfigs;
+
+    gltc = xcalloc (1, sizeof (gl_target_closure_t));
+    *closure = gltc;
+
+    gltc->dpy = eglGetDisplay (EGL_DEFAULT_DISPLAY);
+
+    if (! eglInitialize (gltc->dpy, &major, &minor)) {
+	free (gltc);
+	return NULL;
+    }
+
+    eglGetConfigs (gltc->dpy, NULL, 0, &numConfigs);
+    configs = xmalloc(sizeof(*configs) *numConfigs);
+    eglGetConfigs (gltc->dpy, configs, numConfigs, &numConfigs);
+
+    eglBindAPI (EGL_OPENGL_API);
+
+    gltc->ctx = eglCreateContext (gltc->dpy, configs[0], EGL_NO_CONTEXT, NULL);
+    if (gltc->ctx == EGL_NO_CONTEXT) {
+	eglTerminate (gltc->dpy);
+	free (gltc);
+	return NULL;
+    }
+
+    gltc->device = cairo_egl_device_create (gltc->dpy, gltc->ctx);
+
+    gltc->surface = surface = cairo_gl_surface_create (gltc->device,
+						       content,
+					               ceil (width),
+						       ceil (height));
+    if (cairo_surface_status (surface))
+	_cairo_boilerplate_egl_cleanup (gltc);
+
+    return surface;
+}
+
+static void
+_cairo_boilerplate_egl_synchronize (void *closure)
+{
+    egl_target_closure_t *gltc = closure;
+
+    cairo_gl_surface_glfinish (gltc->surface);
+}
+#endif
+
 static const cairo_boilerplate_target_t targets[] = {
     {
 	"gl", "gl", NULL, NULL,
@@ -272,5 +357,18 @@ static const cairo_boilerplate_target_t targets[] = {
 	_cairo_boilerplate_gl_cleanup,
 	_cairo_boilerplate_gl_synchronize
     },
+#if CAIRO_HAS_EGL_FUNCTIONS
+    {
+	"egl", "gl", NULL, NULL,
+	CAIRO_SURFACE_TYPE_GL, CAIRO_CONTENT_COLOR_ALPHA, 1,
+	"cairo_egl_device_create",
+	_cairo_boilerplate_egl_create_surface,
+	NULL, NULL,
+	_cairo_boilerplate_get_image_surface,
+	cairo_surface_write_to_png,
+	_cairo_boilerplate_egl_cleanup,
+	_cairo_boilerplate_egl_synchronize
+    },
+#endif
 };
 CAIRO_BOILERPLATE (gl, targets)

build/Makefile.win32.features-h

@@ -59,6 +59,7 @@ endif
 ifeq ($(CAIRO_HAS_PNG_FUNCTIONS),1)
 	@echo "#define CAIRO_HAS_PNG_FUNCTIONS 1" >> src/cairo-features.h
 endif
+	@echo "#define CAIRO_HAS_GLEW_FUNCTIONS 1" >> src/cairo-features.h
 ifeq ($(CAIRO_HAS_GL_SURFACE),1)
 	@echo "#define CAIRO_HAS_GL_SURFACE 1" >> src/cairo-features.h
 endif

configure.ac

@@ -324,8 +324,9 @@ CAIRO_ENABLE_SURFACE_BACKEND(gl, OpenGL, no, [
 	  fi])
 
   have_glew="no"
-  AC_CHECK_LIB(GLEW, glewInit,
-	       [AC_CHECK_HEADER(GL/glew.h, [have_glew="yes"], [])])
+  # Disable system GLEW since it assumes X and crashes with EGL
+  #AC_CHECK_LIB(GLEW, glewInit,
+  #	       [AC_CHECK_HEADER(GL/glew.h, [have_glew="yes"], [])])
   if test "x$have_glew" = "xyes"; then
     gl_NONPKGCONFIG_LIBS="-lGLEW $gl_NONPKGCONFIG_LIBS"
     use_glew="yes (system library)"
@@ -335,6 +336,7 @@ CAIRO_ENABLE_SURFACE_BACKEND(gl, OpenGL, no, [
     CAIRO_CFLAGS="$CAIRO_CFLAGS -I\$(top_srcdir)/src/glew"
   fi
   need_glx_functions=yes
+  need_egl_functions=yes
 ])
 
 dnl ===========================================================================
@@ -360,27 +362,31 @@ CAIRO_ENABLE_SURFACE_BACKEND(vg, OpenVG, no, [
 
 CAIRO_ENABLE_FUNCTIONS(egl, EGL, auto, [
   if test "x$need_egl_functions" = "xyes"; then
-    AC_CHECK_HEADER(EGL/egl.h,, [use_egl="no (EGL headers not found)"])
-    if test "x$use_egl" = "xyes"; then
-      egl_NONPKGCONFIG_CFLAGS=
-      egl_NONPKGCONFIG_LIBS=
-      save_LIBS="$LIBS"
-      other_egl_LIBS=""
-      # Temporary workaround for missing link from egl13
-      AC_CHECK_LIB(csi, csi_stream_attachresource, other_egl_LIBS="-lcsi")
-      LIBS="$other_egl_LIBS $LIBS"
-      for egl_lib in EGL egl13 egl12 egl11; do
-	if test -z "$egl_NONPKGCONFIG_LIBS"; then
-          AC_CHECK_LIB($egl_lib, eglGetError, egl_NONPKGCONFIG_LIBS="-l$egl_lib")
-	fi
-      done
-      if test -z "$egl_NONPKGCONFIG_LIBS"; then
-        use_egl="no (EGL library not found)"
-      else
-        egl_NONPKGCONFIG_LIBS="$egl_NONPKGCONFIG_LIBS $other_egl_LIBS"
-      fi
-      LIBS="$save_LIBS"
-    fi
+      egl_REQUIRES="egl"
+      PKG_CHECK_MODULES(egl, $egl_REQUIRES, ,
+		    [egl_REQUIRES=""
+		     AC_CHECK_HEADER(EGL/egl.h,, [use_egl="no (EGL headers not found)"])
+		     if test "x$use_egl" = "xyes"; then
+			 egl_NONPKGCONFIG_CFLAGS=
+			 egl_NONPKGCONFIG_LIBS=
+			 save_LIBS="$LIBS"
+			 other_egl_LIBS=""
+			 # Temporary workaround for missing link from egl13
+			 AC_CHECK_LIB(csi, csi_stream_attachresource, other_egl_LIBS="-lcsi")
+			 LIBS="$other_egl_LIBS $LIBS"
+			 for egl_lib in EGL egl13 egl12 egl11; do
+			     if test -z "$egl_NONPKGCONFIG_LIBS"; then
+				 AC_CHECK_LIB($egl_lib, eglGetError, egl_NONPKGCONFIG_LIBS="-l$egl_lib")
+			     fi
+			 done
+			 if test -z "$egl_NONPKGCONFIG_LIBS"; then
+			     use_egl="no (EGL library not found)"
+			 else
+			     egl_NONPKGCONFIG_LIBS="$egl_NONPKGCONFIG_LIBS $other_egl_LIBS"
+			 fi
+			 LIBS="$save_LIBS"
+		     fi
+  	])
   else
       use_egl="no (not required by any backend)"
   fi

src/Makefile.sources

@@ -315,6 +315,7 @@ cairo_gl_headers = cairo-gl.h
 cairo_gl_private = cairo-gl-private.h
 cairo_gl_sources = cairo-gl-surface.c cairo-gl-glyphs.c cairo-gl-shaders.c
 cairo_glx_sources += cairo-glx-context.c
+cairo_egl_sources += cairo-egl-context.c
 
 cairo_directfb_headers = cairo-directfb.h
 cairo_directfb_sources = cairo-directfb-surface.c

src/Makefile.win32.features

@@ -273,6 +273,14 @@ ifeq ($(CAIRO_HAS_PNG_FUNCTIONS),1)
 enabled_cairo_pkgconf += cairo-png.pc
 endif
 
+supported_cairo_headers += $(cairo_glew_headers)
+all_cairo_headers += $(cairo_glew_headers)
+all_cairo_private += $(cairo_glew_private)
+all_cairo_sources += $(cairo_glew_sources)
+enabled_cairo_headers += $(cairo_glew_headers)
+enabled_cairo_private += $(cairo_glew_private)
+enabled_cairo_sources += $(cairo_glew_sources)
+
 unsupported_cairo_headers += $(cairo_gl_headers)
 all_cairo_headers += $(cairo_gl_headers)
 all_cairo_private += $(cairo_gl_private)

src/cairo-egl-context.c

@@ -0,0 +1,168 @@
+/* cairo - a vector graphics library with display and print output
+ *
+ * Copyright © 2009 Eric Anholt
+ * Copyright © 2009 Chris Wilson
+ * Copyright © 2005 Red Hat, Inc
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ *
+ * The Original Code is the cairo graphics library.
+ *
+ * The Initial Developer of the Original Code is Red Hat, Inc.
+ *
+ * Contributor(s):
+ *	Carl Worth <cworth@cworth.org>
+ *	Chris Wilson <chris@chris-wilson.co.uk>
+ */
+
+#include "cairoint.h"
+
+#include "cairo-gl-private.h"
+
+#include "cairo-error-private.h"
+
+typedef struct _cairo_egl_context {
+    cairo_gl_context_t base;
+
+    EGLDisplay display;
+    EGLContext context;
+} cairo_egl_context_t;
+
+typedef struct _cairo_egl_surface {
+    cairo_gl_surface_t base;
+
+    EGLSurface egl;
+} cairo_egl_surface_t;
+
+static void
+_egl_make_current (void *abstract_ctx,
+	           cairo_gl_surface_t *abstract_surface)
+{
+    cairo_egl_context_t *ctx = abstract_ctx;
+    cairo_egl_surface_t *surface = (cairo_egl_surface_t *) abstract_surface;
+
+    eglMakeCurrent(ctx->display, surface->egl, surface->egl, ctx->context);
+}
+
+static void
+_egl_swap_buffers (void *abstract_ctx,
+		   cairo_gl_surface_t *abstract_surface)
+{
+    cairo_egl_context_t *ctx = abstract_ctx;
+    cairo_egl_surface_t *surface = (cairo_egl_surface_t *) abstract_surface;
+
+    eglSwapBuffers (ctx->display, surface->egl);
+}
+
+static void
+_egl_destroy (void *abstract_ctx)
+{
+    cairo_egl_context_t *ctx = abstract_ctx;
+
+    eglMakeCurrent (ctx->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+}
+
+cairo_device_t *
+cairo_egl_device_create (EGLDisplay dpy, EGLContext egl)
+{
+    cairo_egl_context_t *ctx;
+    cairo_status_t status;
+    int attribs[] = {
+	EGL_WIDTH, 1,
+	EGL_HEIGHT, 1,
+	EGL_NONE,
+    };
+    EGLSurface surface;
+    EGLConfig *configs;
+    EGLint numConfigs;
+
+    ctx = calloc (1, sizeof (cairo_egl_context_t));
+    if (unlikely (ctx == NULL))
+	return _cairo_gl_context_create_in_error (CAIRO_STATUS_NO_MEMORY);
+
+    ctx->display = dpy;
+    ctx->context = egl;
+
+    ctx->base.make_current = _egl_make_current;
+    ctx->base.swap_buffers = _egl_swap_buffers;
+    ctx->base.destroy = _egl_destroy;
+
+    /* dummy surface, meh. */
+    eglGetConfigs (dpy, NULL, 0, &numConfigs);
+    configs = malloc (sizeof(*configs) *numConfigs);
+    if (configs == NULL) {
+	free (ctx);
+	return _cairo_gl_context_create_in_error (CAIRO_STATUS_NO_MEMORY);
+    }
+    eglGetConfigs (dpy, configs, numConfigs, &numConfigs);
+    surface = eglCreatePbufferSurface (dpy, configs[0], attribs);
+    free (configs);
+
+    if (surface == NULL) {
+	free (ctx);
+	return _cairo_gl_context_create_in_error (CAIRO_STATUS_NO_MEMORY);
+    }
+
+    if (! eglMakeCurrent (dpy, surface, surface, egl)) {
+	free (ctx);
+	return _cairo_gl_context_create_in_error (CAIRO_STATUS_NO_MEMORY);
+    }
+
+    status = _cairo_gl_context_init (&ctx->base);
+    if (unlikely (status)) {
+	eglDestroySurface (dpy, surface);
+	free (ctx);
+	return _cairo_gl_context_create_in_error (status);
+    }
+
+    eglDestroySurface (dpy, surface);
+    eglMakeCurrent (dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+
+    return &ctx->base.base;
+}
+
+cairo_surface_t *
+cairo_gl_surface_create_for_egl (cairo_device_t	*device,
+				 EGLSurface	 egl,
+				 int		 width,
+				 int		 height)
+{
+    cairo_egl_surface_t *surface;
+
+    if (unlikely (device->status))
+	return _cairo_surface_create_in_error (device->status);
+
+    if (device->backend->type != CAIRO_DEVICE_TYPE_GL)
+	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH));
+
+    surface = calloc (1, sizeof (cairo_egl_surface_t));
+    if (unlikely (surface == NULL))
+	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
+
+    _cairo_gl_surface_init (device, &surface->base,
+			    CAIRO_CONTENT_COLOR_ALPHA, width, height);
+    surface->egl = egl;
+
+    return &surface->base.base;
+}

src/cairo-gl.h

@@ -72,6 +72,20 @@ cairo_gl_surface_create_for_window (cairo_device_t *device,
 				    int width, int height);
 #endif
 
+#if CAIRO_HAS_EGL_FUNCTIONS
+#include <EGL/egl.h>
+
+cairo_public cairo_device_t *
+cairo_egl_device_create (EGLDisplay dpy, EGLContext egl);
+
+cairo_public cairo_surface_t *
+cairo_gl_surface_create_for_egl (cairo_device_t	*device,
+				 EGLSurface	 egl,
+				 int		 width,
+				 int		 height);
+
+#endif
+
 CAIRO_END_DECLS
 
 #else  /* CAIRO_HAS_GL_SURFACE */