Skip to content
Permalink
b8a7f8621a
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Go to file
 
 
Cannot retrieve contributors at this time
357 lines (316 sloc) 8.87 KB
/* Cairo - a vector graphics library with display and print output
*
* Copyright © 2009 Chris Wilson
*
* 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., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, 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 Chris Wilson.
*/
#include "cairo-boilerplate-private.h"
#include <cairo-vg.h>
/* XXX Not sure how to handle library specific context initialization */
//#define USE_SHIVA
//#define USE_AMANITH
#if CAIRO_HAS_GLX_FUNCTIONS
#include <X11/Xlib.h>
#include <GL/glx.h>
typedef struct _vg_closure {
Display *dpy;
int screen;
Window win;
GLXContext ctx;
cairo_surface_t *surface;
} vg_closure_glx_t;
static void
_cairo_boilerplate_vg_cleanup_glx (void *closure)
{
vg_closure_glx_t *vgc = closure;
#ifdef USE_AMANITH
vgDestroyContextAM ();
#endif
#ifdef USE_SHIVA
vgDestroyContextSH ();
#endif
glXDestroyContext (vgc->dpy, vgc->ctx);
XDestroyWindow (vgc->dpy, vgc->win);
XCloseDisplay (vgc->dpy);
free (vgc);
}
static cairo_surface_t *
_cairo_boilerplate_vg_create_surface_glx (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)
{
int rgba_attribs[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_ALPHA_SIZE, 1,
GLX_DOUBLEBUFFER,
None
};
int rgb_attribs[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER,
None
};
XVisualInfo *vi;
Display *dpy;
Colormap cmap;
XSetWindowAttributes swa;
cairo_surface_t *surface;
cairo_vg_context_t *context;
vg_closure_glx_t *vgc;
vgc = malloc (sizeof (vg_closure_glx_t));
*closure = vgc;
if (width == 0)
width = 1;
if (height == 0)
height = 1;
dpy = XOpenDisplay (NULL);
vgc->dpy = dpy;
if (vgc->dpy == NULL) {
fprintf (stderr, "Failed to open display: %s\n", XDisplayName(0));
free (vgc);
return NULL;
}
if (content == CAIRO_CONTENT_COLOR)
vi = glXChooseVisual (dpy, DefaultScreen (dpy), rgb_attribs);
else
vi = glXChooseVisual (dpy, DefaultScreen (dpy), rgba_attribs);
if (vi == NULL) {
fprintf (stderr, "Failed to create RGB, double-buffered visual\n");
XCloseDisplay (dpy);
free (vgc);
return NULL;
}
vgc->ctx = glXCreateContext (dpy, vi, NULL, True);
cmap = XCreateColormap (dpy,
RootWindow (dpy, vi->screen),
vi->visual,
AllocNone);
swa.colormap = cmap;
swa.border_pixel = 0;
vgc->win = XCreateWindow (dpy, RootWindow (dpy, vi->screen),
-1, -1, 1, 1, 0,
vi->depth,
InputOutput,
vi->visual,
CWBorderPixel | CWColormap, &swa);
XFreeColormap (dpy, cmap);
XFree (vi);
XMapWindow (dpy, vgc->win);
/* we need an active context to initialise VG */
glXMakeContextCurrent (dpy, vgc->win, vgc->win, vgc->ctx);
#ifdef USE_AMANITH
vgInitContextAM (width, height, VG_FALSE, VG_TRUE);
#endif
#ifdef USE_SHIVA
vgCreateContextSH (width, height);
#endif
context = cairo_vg_context_create_for_glx (dpy, vgc->ctx);
vgc->surface = cairo_vg_surface_create (context, content, width, height);
cairo_vg_context_destroy (context);
surface = vgc->surface;
if (cairo_surface_status (surface))
_cairo_boilerplate_vg_cleanup_glx (vgc);
return surface;
}
#endif
#if CAIRO_HAS_EGL_FUNCTIONS
typedef struct _vg_closure_egl {
EGLDisplay *dpy;
EGLContext *ctx;
EGLSurface *dummy;
} vg_closure_egl_t;
static void
_cairo_boilerplate_vg_cleanup_egl (void *closure)
{
vg_closure_egl_t *vgc = closure;
#ifdef USE_AMANITH
vgDestroyContextAM ();
#endif
#ifdef USE_SHIVA
vgDestroyContextSH ();
#endif
eglDestroyContext (vgc->dpy, vgc->ctx);
eglDestroySurface (vgc->dpy, vgc->dummy);
eglTerminate (vgc->dpy);
free (vgc);
}
static cairo_surface_t *
_cairo_boilerplate_vg_create_surface_egl (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)
{
int rgba_attribs[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,
None
};
int rgb_attribs[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_PRE_BIT,
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,
None
};
int dummy_attribs[] = {
EGL_WIDTH, 8, EGL_HEIGHT, 8,
EGL_NONE
};
EGLDisplay *dpy;
int major, minor;
EGLConfig config;
int num_configs;
EGLContext *egl_context;
EGLSurface *dummy;
cairo_vg_context_t *context;
cairo_surface_t *surface;
vg_closure_egl_t *vgc;
dpy = eglGetDisplay (EGL_DEFAULT_DISPLAY);
if (! eglInitialize (dpy, &major, &minor))
return NULL;
eglBindAPI (EGL_OPENVG_API);
if (! eglChooseConfig (dpy,
content == CAIRO_CONTENT_COLOR_ALPHA ?
rgba_attribs : rgb_attribs,
&config, 1, &num_configs) ||
num_configs != 1)
{
return NULL;
}
egl_context = eglCreateContext (dpy, config, NULL, NULL);
if (egl_context == NULL)
return NULL;
/* Create a dummy surface in order to enable a context to initialise VG */
dummy = eglCreatePbufferSurface (dpy, config, dummy_attribs);
if (dummy == NULL)
return NULL;
if (! eglMakeCurrent (dpy, dummy, dummy, egl_context))
return NULL;
#ifdef USE_AMANITH
vgInitContextAM (width, height, VG_FALSE, VG_TRUE);
#endif
#ifdef USE_SHIVA
vgCreateContextSH (width, height);
#endif
vgc = xmalloc (sizeof (vg_closure_egl_t));
vgc->dpy = dpy;
vgc->ctx = egl_context;
vgc->dummy = dummy;
*closure = vgc;
context = cairo_vg_context_create_for_egl (vgc->dpy, vgc->ctx);
surface = cairo_vg_surface_create (context, content, width, height);
cairo_vg_context_destroy (context);
if (cairo_surface_status (surface))
_cairo_boilerplate_vg_cleanup_egl (vgc);
return surface;
}
#endif
static void
_cairo_boilerplate_vg_synchronize (void *closure)
{
vgFinish ();
}
static const cairo_boilerplate_target_t targets[] = {
#if CAIRO_HAS_GLX_FUNCTIONS
{
"vg-glx", "vg", NULL, NULL,
CAIRO_SURFACE_TYPE_VG, CAIRO_CONTENT_COLOR_ALPHA, 1,
"cairo_vg_context_create_for_glx",
_cairo_boilerplate_vg_create_surface_glx,
NULL, NULL,
_cairo_boilerplate_get_image_surface,
cairo_surface_write_to_png,
_cairo_boilerplate_vg_cleanup_glx,
_cairo_boilerplate_vg_synchronize,
TRUE, FALSE, FALSE
},
{
"vg-glx", "vg", NULL, NULL,
CAIRO_SURFACE_TYPE_VG, CAIRO_CONTENT_COLOR, 1,
"cairo_vg_context_create_for_glx",
_cairo_boilerplate_vg_create_surface_glx,
NULL, NULL,
_cairo_boilerplate_get_image_surface,
cairo_surface_write_to_png,
_cairo_boilerplate_vg_cleanup_glx,
_cairo_boilerplate_vg_synchronize,
FALSE, FALSE, FALSE
},
#endif
#if CAIRO_HAS_EGL_FUNCTIONS
{
"vg-egl", "vg", NULL, NULL,
CAIRO_SURFACE_TYPE_VG, CAIRO_CONTENT_COLOR_ALPHA, 1,
"cairo_vg_context_create_for_egl",
_cairo_boilerplate_vg_create_surface_egl,
NULL, NULL,
_cairo_boilerplate_get_image_surface,
cairo_surface_write_to_png,
_cairo_boilerplate_vg_cleanup_egl,
_cairo_boilerplate_vg_synchronize,
TRUE, FALSE, FALSE
},
{
"vg-egl", "vg", NULL, NULL,
CAIRO_SURFACE_TYPE_VG, CAIRO_CONTENT_COLOR, 1,
"cairo_vg_context_create_for_egl",
_cairo_boilerplate_vg_create_surface_egl,
NULL, NULL,
_cairo_boilerplate_get_image_surface,
cairo_surface_write_to_png,
_cairo_boilerplate_vg_cleanup_egl,
_cairo_boilerplate_vg_synchronize,
FALSE, FALSE, FALSE
},
#endif
};
CAIRO_BOILERPLATE (vg, targets)