summaryrefslogtreecommitdiff
path: root/src/cairo-vg-surface.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/cairo-vg-surface.c')
-rw-r--r--src/cairo-vg-surface.c1853
1 files changed, 1853 insertions, 0 deletions
diff --git a/src/cairo-vg-surface.c b/src/cairo-vg-surface.c
new file mode 100644
index 000000000..6e0d9a0ed
--- /dev/null
+++ b/src/cairo-vg-surface.c
@@ -0,0 +1,1853 @@
+/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */
+/* cairo - a vector graphics library with display and print output
+ *
+ * Copyright © 2008 Opened Hand Ltd.
+ * 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.og/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.
+ *
+ * Contributor(s):
+ * Pierre Tardy <tardyp@gmail.com>
+ * Øyvind Kolås <pippin@gimp.org>
+ * Vladimi Vukicevic <vladimir@mozilla.com> (stubbed out base backend)
+ * Chris Wilson <chris@chris-wilson.co.uk>
+ */
+
+#include "cairoint.h"
+
+#include "cairo-vg.h"
+
+#include "cairo-cache-private.h"
+#include "cairo-default-context-private.h"
+#include "cairo-error-private.h"
+#include "cairo-image-surface-private.h"
+#include "cairo-path-fixed-private.h"
+#include "cairo-recording-surface-inline.h"
+#include "cairo-surface-clipper-private.h"
+
+#include <pixman.h>
+#include <VG/openvg.h>
+
+//#define OPENVG_DEBUG
+
+/*
+ * Work that needs to be done:
+ * - Glyph cache / proper font support
+ *
+ * - First-class paths
+ * Paths are expensive for OpenVG, reuse paths whenever possible.
+ * So add a path cache, and first class paths!
+ */
+
+typedef struct _cairo_vg_surface cairo_vg_surface_t;
+
+/* XXX need GL specific context control. :( */
+struct _cairo_vg_context {
+ cairo_status_t status;
+ cairo_reference_count_t ref_count;
+
+ unsigned long target_id;
+
+ VGPaint paint;
+ cairo_vg_surface_t *source;
+ double alpha;
+
+ cairo_cache_t snapshot_cache;
+
+ void *display;
+ void *context;
+
+ cairo_status_t (*create_target) (cairo_vg_context_t *,
+ cairo_vg_surface_t *);
+ cairo_status_t (*set_target) (cairo_vg_context_t *,
+ cairo_vg_surface_t *);
+ void (*destroy_target) (cairo_vg_context_t *, cairo_vg_surface_t *);
+};
+
+struct _cairo_vg_surface {
+ cairo_surface_t base;
+
+ cairo_vg_context_t *context;
+
+ VGImage image;
+ VGImageFormat format;
+ int width;
+ int height;
+ cairo_bool_t own_image;
+
+ cairo_cache_entry_t snapshot_cache_entry;
+
+ cairo_surface_clipper_t clipper;
+
+ unsigned long target_id;
+};
+
+static const cairo_surface_backend_t cairo_vg_surface_backend;
+
+slim_hidden_proto (cairo_vg_surface_create);
+
+static cairo_surface_t *
+_vg_surface_create_internal (cairo_vg_context_t *context,
+ VGImage image,
+ VGImageFormat format,
+ int width, int height);
+
+static cairo_vg_context_t *
+_vg_context_reference (cairo_vg_context_t *context)
+{
+ assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&context->ref_count));
+
+ _cairo_reference_count_inc (&context->ref_count);
+
+ return context;
+}
+
+static cairo_vg_context_t *
+_vg_context_lock (cairo_vg_context_t *context)
+{
+ /* XXX if we need to add locking, then it has to be recursive */
+ return context;
+}
+
+static cairo_int_status_t
+_vg_context_set_target (cairo_vg_context_t *context,
+ cairo_vg_surface_t *surface)
+{
+ cairo_status_t status;
+
+ if (surface->target_id == 0) {
+ status = context->create_target (context, surface);
+ if (unlikely (status))
+ return status;
+ }
+
+ if (context->target_id == surface->target_id)
+ return CAIRO_STATUS_SUCCESS;
+
+ context->target_id = surface->target_id;
+
+ return context->set_target (context, surface);
+}
+
+static void
+_vg_context_destroy_target (cairo_vg_context_t *context,
+ cairo_vg_surface_t *surface)
+{
+ if (surface->target_id == 0)
+ return;
+
+ if (context->target_id == surface->target_id)
+ context->set_target (context, NULL);
+
+ context->destroy_target (context, surface);
+}
+
+static cairo_bool_t
+_vg_snapshot_cache_can_remove (const void *entry)
+{
+ return TRUE;
+}
+
+static void
+_vg_snapshot_cache_remove (void *cache_entry)
+{
+ cairo_vg_surface_t *surface = cairo_container_of (cache_entry,
+ cairo_vg_surface_t,
+ snapshot_cache_entry);
+ surface->snapshot_cache_entry.hash = 0;
+ cairo_surface_destroy (&surface->base);
+}
+
+static cairo_status_t
+_vg_context_init (cairo_vg_context_t *context)
+{
+ cairo_status_t status;
+
+ context->status = CAIRO_STATUS_SUCCESS;
+ CAIRO_REFERENCE_COUNT_INIT (&context->ref_count, 1);
+
+ status = _cairo_cache_init (&context->snapshot_cache,
+ NULL,
+ _vg_snapshot_cache_can_remove,
+ _vg_snapshot_cache_remove,
+ 16*1024*1024);
+ if (unlikely (status))
+ return status;
+
+ context->target_id = 0;
+ context->source = NULL;
+ context->alpha = 1.0;
+
+ context->paint = vgCreatePaint ();
+ vgLoadIdentity ();
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static void
+_vg_context_destroy (cairo_vg_context_t *context)
+{
+ assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&context->ref_count));
+
+ if (! _cairo_reference_count_dec_and_test (&context->ref_count))
+ return;
+
+ if (context->paint != VG_INVALID_HANDLE)
+ vgDestroyPaint (context->paint);
+
+ _cairo_cache_fini (&context->snapshot_cache);
+ free (context);
+}
+
+static void
+_vg_context_unlock (cairo_vg_context_t *context)
+{
+}
+
+#ifdef OPENVG_DEBUG
+static void check_vg_errors(const char*function,int line)
+{
+ int err = vgGetError();
+ if (err != VG_NO_ERROR){
+ printf("%s+%d:vgError detected: 0x%08x.\n",function, line,err);
+ assert(err == VG_NO_ERROR);
+ }
+
+}
+#define CHECK_VG_ERRORS() check_vg_errors(__FILE__,__LINE__)
+#else
+#define CHECK_VG_ERRORS() do{}while(0)
+#endif //OPENVG_DEBUG
+
+static pixman_format_code_t
+_vg_format_to_pixman (VGImageFormat format,
+ cairo_bool_t *needs_premult_fixup)
+{
+ *needs_premult_fixup = FALSE;
+ switch (format) {
+ /* RGB{A,X} channel ordering */
+ case VG_sRGBX_8888: return PIXMAN_r8g8b8x8;
+ case VG_sRGBA_8888: *needs_premult_fixup = TRUE; return PIXMAN_r8g8b8a8;
+ case VG_sRGBA_8888_PRE: return PIXMAN_r8g8b8a8;
+ case VG_sRGB_565: return PIXMAN_r5g6b5;
+ case VG_sRGBA_5551: return 0;
+ case VG_sRGBA_4444: return 0;
+ case VG_sL_8: return PIXMAN_g8;
+ case VG_lRGBX_8888: return 0;
+ case VG_lRGBA_8888: return 0;
+ case VG_lRGBA_8888_PRE: return 0;
+ case VG_lL_8: return 0;
+ case VG_A_8: return PIXMAN_a8;
+ case VG_BW_1: return PIXMAN_a1;
+ case VG_A_1: return PIXMAN_a1;
+ case VG_A_4: return PIXMAN_a4;
+
+ /* {A,X}RGB channel ordering */
+ case VG_sXRGB_8888: return PIXMAN_x8r8g8b8;
+ case VG_sARGB_8888: *needs_premult_fixup = TRUE; return PIXMAN_a8r8g8b8;
+ case VG_sARGB_8888_PRE: return PIXMAN_a8r8g8b8;
+ case VG_sARGB_1555: return 0;
+ case VG_sARGB_4444: return 0;
+ case VG_lXRGB_8888: return 0;
+ case VG_lARGB_8888: return 0;
+ case VG_lARGB_8888_PRE: return 0;
+
+ /* BGR{A,X} channel ordering */
+ case VG_sBGRX_8888: return PIXMAN_b8g8r8x8;
+ case VG_sBGRA_8888: *needs_premult_fixup = TRUE; return PIXMAN_b8g8r8a8;
+ case VG_sBGRA_8888_PRE: return PIXMAN_b8g8r8a8;
+ case VG_sBGR_565: return PIXMAN_b5g6r5;
+ case VG_sBGRA_5551: return 0;
+ case VG_sBGRA_4444: return 0;
+ case VG_lBGRX_8888: return 0;
+ case VG_lBGRA_8888: return 0;
+ case VG_lBGRA_8888_PRE: return 0;
+
+ /* {A,X}BGR channel ordering */
+ case VG_sXBGR_8888: return PIXMAN_x8b8g8r8;
+ case VG_sABGR_8888: *needs_premult_fixup = TRUE; return PIXMAN_a8b8g8r8;
+ case VG_sABGR_8888_PRE: return PIXMAN_a8b8g8r8;
+ case VG_sABGR_1555: return 0;
+ case VG_sABGR_4444: return 0;
+ case VG_lXBGR_8888: return 0;
+ case VG_lABGR_8888: return 0;
+ case VG_lABGR_8888_PRE: return 0;
+ default: return 0;
+ }
+}
+
+static pixman_format_code_t
+_vg_format_to_content (VGImageFormat format)
+{
+ /* XXX could use more simple bit tests */
+ switch (format) {
+ /* RGB{A,X} channel ordering */
+ case VG_sRGBX_8888: return CAIRO_CONTENT_COLOR;
+ case VG_sRGBA_8888: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sRGBA_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sRGB_565: return CAIRO_CONTENT_COLOR;
+ case VG_sRGBA_5551: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sRGBA_4444: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sL_8: return CAIRO_CONTENT_ALPHA;
+ case VG_lRGBX_8888: return CAIRO_CONTENT_COLOR;
+ case VG_lRGBA_8888: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_lRGBA_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_lL_8: return CAIRO_CONTENT_ALPHA;
+ case VG_A_8: return CAIRO_CONTENT_ALPHA;
+ case VG_A_4: return CAIRO_CONTENT_ALPHA;
+ case VG_A_1: return CAIRO_CONTENT_ALPHA;
+ case VG_BW_1: return CAIRO_CONTENT_ALPHA;
+
+ /* {A,X}RGB channel ordering */
+ case VG_sXRGB_8888: return CAIRO_CONTENT_COLOR;
+ case VG_sARGB_8888: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sARGB_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sARGB_1555: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sARGB_4444: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_lXRGB_8888: return CAIRO_CONTENT_COLOR;
+ case VG_lARGB_8888: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_lARGB_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
+
+ /* BGR{A,X} channel ordering */
+ case VG_sBGRX_8888: return CAIRO_CONTENT_COLOR;
+ case VG_sBGRA_8888: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sBGRA_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sBGR_565: return CAIRO_CONTENT_COLOR;
+ case VG_sBGRA_5551: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sBGRA_4444: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_lBGRX_8888: return CAIRO_CONTENT_COLOR;
+ case VG_lBGRA_8888: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_lBGRA_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
+
+ /* {A,X}BGR channel ordering */
+ case VG_sXBGR_8888: return CAIRO_CONTENT_COLOR;
+ case VG_sABGR_8888: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sABGR_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sABGR_1555: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_sABGR_4444: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_lXBGR_8888: return CAIRO_CONTENT_COLOR;
+ case VG_lABGR_8888: return CAIRO_CONTENT_COLOR_ALPHA;
+ case VG_lABGR_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
+ default: return 0;
+ }
+}
+
+static VGImageFormat
+_vg_format_from_pixman (pixman_format_code_t format)
+{
+ /* XXX _PRE needs fixup */
+ switch ((int) format) {
+ case PIXMAN_r5g6b5: return VG_sRGB_565;
+ case PIXMAN_g8: return VG_sL_8;
+ case PIXMAN_a8: return VG_A_8;
+ case PIXMAN_a1: return VG_BW_1;
+ case PIXMAN_x8r8g8b8: return VG_sXRGB_8888;
+ case PIXMAN_a8r8g8b8: return VG_sARGB_8888; // _PRE
+ case PIXMAN_b8g8r8x8: return VG_sBGRX_8888;
+ case PIXMAN_b8g8r8a8: return VG_sBGRA_8888; // _PRE
+ case PIXMAN_b5g6r5: return VG_sBGR_565;
+ case PIXMAN_x8b8g8r8: return VG_sXBGR_8888;
+ case PIXMAN_a8b8g8r8: return VG_sABGR_8888; // _PRE
+ default: return 0;
+ }
+}
+
+static VGImageFormat
+_vg_format_for_content (cairo_content_t content)
+{
+ switch (content) {
+ case CAIRO_CONTENT_ALPHA: return VG_A_8;
+ case CAIRO_CONTENT_COLOR: return VG_sXRGB_8888;
+ default: ASSERT_NOT_REACHED;
+ case CAIRO_CONTENT_COLOR_ALPHA: return VG_sARGB_8888; // _PRE
+ }
+}
+
+static cairo_surface_t *
+_vg_surface_create_similar (void *abstract_surface,
+ cairo_content_t content,
+ int width,
+ int height)
+{
+ cairo_vg_surface_t *surface = abstract_surface;
+
+ if (width > vgGeti (VG_MAX_IMAGE_WIDTH) ||
+ height > vgGeti (VG_MAX_IMAGE_HEIGHT))
+ {
+ return NULL;
+ }
+
+ return cairo_vg_surface_create (surface->context, content, width, height);
+}
+
+static cairo_status_t
+_vg_surface_clipper_intersect_clip_path (cairo_surface_clipper_t *clipper,
+ cairo_path_fixed_t *path,
+ cairo_fill_rule_t fill_rule,
+ double tolerance,
+ cairo_antialias_t antialias)
+{
+ cairo_vg_surface_t *surface = cairo_container_of (clipper,
+ cairo_vg_surface_t,
+ clipper);
+ cairo_vg_surface_t *mask;
+ cairo_status_t status;
+
+ if (path == NULL) {
+ vgMask (VG_INVALID_HANDLE,
+ VG_FILL_MASK, 0, 0, surface->width, surface->height);
+ vgSeti (VG_MASKING, VG_FALSE);
+ CHECK_VG_ERRORS();
+ return CAIRO_STATUS_SUCCESS;
+ }
+
+ mask = (cairo_vg_surface_t *)
+ _vg_surface_create_similar (surface, CAIRO_CONTENT_ALPHA,
+ surface->width, surface->height);
+ if (unlikely (mask == NULL))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+ if (unlikely (mask->base.status))
+ return mask->base.status;
+
+ status = _cairo_surface_fill (&mask->base,
+ CAIRO_OPERATOR_SOURCE,
+ &_cairo_pattern_white.base,
+ path, fill_rule, tolerance, antialias,
+ NULL);
+ if (status) {
+ cairo_surface_destroy (&mask->base);
+ return status;
+ }
+
+ vgSeti (VG_MASKING, VG_TRUE);
+ vgMask (mask->image, VG_INTERSECT_MASK, 0, 0, mask->width, mask->height);
+
+ cairo_surface_destroy (&mask->base);
+
+ CHECK_VG_ERRORS();
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_bool_t
+_vg_surface_get_extents (void *abstract_surface,
+ cairo_rectangle_int_t *extents)
+{
+ cairo_vg_surface_t *surface = abstract_surface;
+
+ extents->x = 0;
+ extents->y = 0;
+ extents->width = surface->width;
+ extents->height = surface->height;
+
+ return TRUE;
+}
+
+#define MAX_SEG 16 /* max number of knots to upload in a batch */
+
+typedef struct _vg_path {
+ VGPath path;
+ const cairo_matrix_t *ctm_inverse;
+
+ VGubyte gseg[MAX_SEG];
+ VGfloat gdata[MAX_SEG*3*2];
+ int dcount;
+ int scount;
+} vg_path_t;
+
+static cairo_status_t
+_vg_move_to (void *closure,
+ const cairo_point_t *point)
+{
+ vg_path_t *path = closure;
+ double x = _cairo_fixed_to_double (point->x);
+ double y = _cairo_fixed_to_double (point->y);
+
+ if (path->ctm_inverse)
+ cairo_matrix_transform_point (path->ctm_inverse, &x, &y);
+
+ path->gseg[path->scount++] = VG_MOVE_TO;
+ path->gdata[path->dcount++] = x;
+ path->gdata[path->dcount++] = y;
+
+ if (path->scount >= MAX_SEG-1) {
+ vgAppendPathData (path->path, path->scount, path->gseg, path->gdata);
+ path->scount = 0;
+ path->dcount = 0;
+ }
+
+ CHECK_VG_ERRORS();
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_vg_line_to (void *closure,
+ const cairo_point_t *point)
+{
+ vg_path_t *path = closure;
+ double x = _cairo_fixed_to_double (point->x);
+ double y = _cairo_fixed_to_double (point->y);
+
+ if (path->ctm_inverse)
+ cairo_matrix_transform_point (path->ctm_inverse, &x, &y);
+
+ path->gseg[path->scount++] = VG_LINE_TO;
+ path->gdata[path->dcount++] = x;
+ path->gdata[path->dcount++] = y;
+
+ if (path->scount >= MAX_SEG-1) {
+ vgAppendPathData (path->path, path->scount, path->gseg, path->gdata);
+ path->scount = 0;
+ path->dcount = 0;
+ }
+
+ CHECK_VG_ERRORS();
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_vg_curve_to (void *closure,
+ const cairo_point_t *p0,
+ const cairo_point_t *p1,
+ const cairo_point_t *p2)
+{
+ vg_path_t *path = closure;
+ double x0 = _cairo_fixed_to_double (p0->x);
+ double y0 = _cairo_fixed_to_double (p0->y);
+ double x1 = _cairo_fixed_to_double (p1->x);
+ double y1 = _cairo_fixed_to_double (p1->y);
+ double x2 = _cairo_fixed_to_double (p2->x);
+ double y2 = _cairo_fixed_to_double (p2->y);
+
+ if (path->ctm_inverse) {
+ cairo_matrix_transform_point (path->ctm_inverse, &x0, &y0);
+ cairo_matrix_transform_point (path->ctm_inverse, &x1, &y1);
+ cairo_matrix_transform_point (path->ctm_inverse, &x2, &y2);
+ }
+
+ path->gseg[path->scount++] = VG_CUBIC_TO;
+ path->gdata[path->dcount++] = x0;
+ path->gdata[path->dcount++] = y0;
+ path->gdata[path->dcount++] = x1;
+ path->gdata[path->dcount++] = y1;
+ path->gdata[path->dcount++] = x2;
+ path->gdata[path->dcount++] = y2;
+
+ if (path->scount >= MAX_SEG-1) {
+ vgAppendPathData(path->path, path->scount, path->gseg, path->gdata);
+ path->scount = 0;
+ path->dcount = 0;
+ }
+
+ CHECK_VG_ERRORS();
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_vg_close_path (void *closure)
+{
+ vg_path_t *path = closure;
+
+ path->gseg[path->scount++] = VG_CLOSE_PATH;
+
+ if (path->scount >= MAX_SEG-1) {
+ vgAppendPathData (path->path, path->scount, path->gseg, path->gdata);
+ path->scount = 0;
+ path->dcount = 0;
+ }
+
+ CHECK_VG_ERRORS();
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static void
+_vg_path_from_cairo (vg_path_t *vg_path,
+ const cairo_path_fixed_t *path)
+{
+ cairo_status_t status;
+
+ vg_path->scount = 0;
+ vg_path->dcount = 0;
+
+ status = _cairo_path_fixed_interpret (path,
+ _vg_move_to,
+ _vg_line_to,
+ _vg_curve_to,
+ _vg_close_path,
+ vg_path);
+ assert (status == CAIRO_STATUS_SUCCESS);
+
+ vgAppendPathData (vg_path->path,
+ vg_path->scount, vg_path->gseg, vg_path->gdata);
+ CHECK_VG_ERRORS();
+}
+
+static cairo_bool_t
+_vg_is_supported_operator (cairo_operator_t op)
+{
+ switch ((int) op) {
+ case CAIRO_OPERATOR_SOURCE:
+ case CAIRO_OPERATOR_OVER:
+ case CAIRO_OPERATOR_IN:
+ case CAIRO_OPERATOR_DEST_OVER:
+ case CAIRO_OPERATOR_DEST_IN:
+ case CAIRO_OPERATOR_ADD:
+ return TRUE;
+
+ default:
+ return FALSE;
+ }
+}
+
+static VGBlendMode
+_vg_operator (cairo_operator_t op)
+{
+ switch ((int) op) {
+ case CAIRO_OPERATOR_SOURCE:
+ return VG_BLEND_SRC;
+ case CAIRO_OPERATOR_OVER:
+ return VG_BLEND_SRC_OVER;
+ case CAIRO_OPERATOR_IN:
+ return VG_BLEND_SRC_IN;
+ case CAIRO_OPERATOR_DEST_OVER:
+ return VG_BLEND_DST_OVER;
+ case CAIRO_OPERATOR_DEST_IN:
+ return VG_BLEND_DST_IN;
+ case CAIRO_OPERATOR_ADD:
+ return VG_BLEND_ADDITIVE;
+ default:
+ ASSERT_NOT_REACHED;
+ return VG_BLEND_SRC_OVER;
+ }
+}
+
+static VGFillRule
+_vg_fill_rule_from_cairo (cairo_fill_rule_t rule)
+{
+ switch (rule) {
+ case CAIRO_FILL_RULE_EVEN_ODD: return VG_EVEN_ODD;
+ case CAIRO_FILL_RULE_WINDING: return VG_NON_ZERO;
+ }
+
+ ASSERT_NOT_REACHED;
+ return VG_NON_ZERO;
+}
+
+static VGRenderingQuality
+_vg_rendering_quality_from_cairo (cairo_antialias_t aa)
+{
+ switch (aa) {
+ case CAIRO_ANTIALIAS_DEFAULT:
+ case CAIRO_ANTIALIAS_SUBPIXEL:
+ case CAIRO_ANTIALIAS_GOOD:
+ case CAIRO_ANTIALIAS_BEST:
+ return VG_RENDERING_QUALITY_BETTER;
+
+ case CAIRO_ANTIALIAS_GRAY:
+ case CAIRO_ANTIALIAS_FAST:
+ return VG_RENDERING_QUALITY_FASTER;
+
+ case CAIRO_ANTIALIAS_NONE:
+ return VG_RENDERING_QUALITY_NONANTIALIASED;
+ }
+
+ ASSERT_NOT_REACHED;
+ return VG_RENDERING_QUALITY_BETTER;
+}
+
+static VGCapStyle
+_vg_line_cap_from_cairo (cairo_line_cap_t cap)
+{
+ switch (cap) {
+ case CAIRO_LINE_CAP_BUTT: return VG_CAP_BUTT;
+ case CAIRO_LINE_CAP_ROUND: return VG_CAP_ROUND;
+ case CAIRO_LINE_CAP_SQUARE: return VG_CAP_SQUARE;
+ }
+
+ ASSERT_NOT_REACHED;
+ return VG_CAP_BUTT;
+}
+
+static VGJoinStyle
+_vg_line_join_from_cairo (cairo_line_join_t join)
+{
+ switch (join) {
+ case CAIRO_LINE_JOIN_MITER: return VG_JOIN_MITER;
+ case CAIRO_LINE_JOIN_ROUND: return VG_JOIN_ROUND;
+ case CAIRO_LINE_JOIN_BEVEL: return VG_JOIN_BEVEL;
+ }
+
+ ASSERT_NOT_REACHED;
+ return VG_JOIN_MITER;
+}
+
+static void
+_vg_matrix_from_cairo (VGfloat *dst, const cairo_matrix_t *src)
+{
+ dst[0] = /* sx */ src->xx;
+ dst[1] = /* shy */ src->yx;
+ dst[2] = /* w0 */ 0;
+ dst[3] = /* shx */ src->xy;
+ dst[4] = /* sy */ src->yy;
+ dst[5] = /* w1 */ 0;
+ dst[6] = /* tx */ src->x0;
+ dst[7] = /* ty */ src->y0;
+ dst[8] = /* w2 */ 0;
+}
+
+static cairo_status_t
+_vg_setup_gradient_stops (cairo_vg_context_t *context,
+ const cairo_gradient_pattern_t *pattern)
+{
+ VGint numstops = pattern->n_stops;
+ VGfloat *stops, stack_stops[CAIRO_STACK_ARRAY_LENGTH (VGfloat)];
+ int i;
+
+ if (numstops*5 < ARRAY_LENGTH (stack_stops)) {
+ stops = stack_stops;
+ } else {
+ stops = _cairo_malloc_ab (numstops, 5*sizeof (VGfloat));
+ if (unlikely (stops == NULL))
+ return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+ }
+
+ for (i = 0; i < numstops; i++) {
+ stops[i*5 + 0] = pattern->stops[i].offset;
+ stops[i*5 + 1] = pattern->stops[i].color.red;
+ stops[i*5 + 2] = pattern->stops[i].color.green;
+ stops[i*5 + 3] = pattern->stops[i].color.blue;
+ stops[i*5 + 4] = pattern->stops[i].color.alpha * context->alpha;
+ }
+
+ vgSetParameterfv (context->paint,
+ VG_PAINT_COLOR_RAMP_STOPS, numstops * 5, stops);
+
+ if (stops != stack_stops)
+ free (stops);
+
+ CHECK_VG_ERRORS();
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static void
+_vg_set_source_matrix (const cairo_pattern_t *pat)
+{
+ cairo_matrix_t mat;
+ cairo_status_t status;
+ VGfloat vmat[9];
+
+ mat = pat->matrix;
+ status = cairo_matrix_invert (&mat);
+ assert (status == CAIRO_STATUS_SUCCESS);
+
+ _vg_matrix_from_cairo (vmat, &mat);
+
+ vgSeti (VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);
+ vgLoadMatrix (vmat);
+ vgSeti (VG_MATRIX_MODE, VG_MATRIX_STROKE_PAINT_TO_USER);
+ vgLoadMatrix (vmat);
+ vgSeti (VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
+
+ CHECK_VG_ERRORS();
+}
+
+static cairo_status_t
+_vg_setup_linear_source (cairo_vg_context_t *context,
+ const cairo_linear_pattern_t *lpat)
+{
+ VGfloat linear[4];
+
+ linear[0] = lpat->pd1.x;
+ linear[1] = lpat->pd1.y;
+ linear[2] = lpat->pd2.x;
+ linear[3] = lpat->pd2.y;
+
+ vgSetParameteri (context->paint,
+ VG_PAINT_COLOR_RAMP_SPREAD_MODE,
+ VG_COLOR_RAMP_SPREAD_PAD);
+ vgSetParameteri (context->paint,
+ VG_PAINT_TYPE,
+ VG_PAINT_TYPE_LINEAR_GRADIENT);
+ vgSetParameterfv (context->paint,
+ VG_PAINT_LINEAR_GRADIENT, 4, linear);
+
+ _vg_set_source_matrix (&lpat->base.base);
+
+ CHECK_VG_ERRORS();
+ return _vg_setup_gradient_stops (context, &lpat->base);
+
+}
+
+static cairo_status_t
+_vg_setup_radial_source (cairo_vg_context_t *context,
+ const cairo_radial_pattern_t *rpat)
+{
+ VGfloat radial[5];
+
+ radial[0] = rpat->cd1.center.x;
+ radial[1] = rpat->cd1.center.y;
+ radial[2] = rpat->cd2.center.x;
+ radial[3] = rpat->cd2.center.y;
+ radial[4] = rpat->cd2.radius;
+
+ vgSetParameteri (context->paint,
+ VG_PAINT_COLOR_RAMP_SPREAD_MODE, VG_COLOR_RAMP_SPREAD_PAD);
+ vgSetParameteri (context->paint,
+ VG_PAINT_TYPE, VG_PAINT_TYPE_RADIAL_GRADIENT);
+ vgSetParameterfv (context->paint,
+ VG_PAINT_RADIAL_GRADIENT, 5, radial);
+
+ _vg_set_source_matrix (&rpat->base.base);
+
+ /* FIXME: copy/adapt fixes from SVG backend to add inner radius */
+
+ CHECK_VG_ERRORS();
+ return _vg_setup_gradient_stops (context, &rpat->base);
+}
+
+static cairo_status_t
+_vg_setup_solid_source (cairo_vg_context_t *context,
+ const cairo_solid_pattern_t *spat)
+{
+ VGfloat color[] = {
+ spat->color.red,
+ spat->color.green,
+ spat->color.blue,
+ spat->color.alpha * context->alpha
+ };
+
+ vgSetParameteri (context->paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
+ vgSetParameterfv (context->paint, VG_PAINT_COLOR, 4, color);
+
+ CHECK_VG_ERRORS();
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_vg_surface_t *
+_vg_clone_recording_surface (cairo_vg_context_t *context,
+ cairo_surface_t *surface)
+{
+ VGImage vg_image;
+ VGImageFormat format;
+ cairo_status_t status;
+ cairo_rectangle_int_t extents;
+ cairo_vg_surface_t *clone;
+
+ status = _cairo_surface_get_extents (surface, &extents);
+ if (status)
+ return NULL;
+
+ if (extents.width > vgGeti (VG_MAX_IMAGE_WIDTH) ||
+ extents.height > vgGeti (VG_MAX_IMAGE_HEIGHT))
+ {
+ return NULL;
+ }
+
+ format = _vg_format_for_content (surface->content);
+
+ /* NONALIASED, FASTER, BETTER */
+ vg_image = vgCreateImage (format,
+ extents.width, extents.height,
+ VG_IMAGE_QUALITY_FASTER);
+ clone = (cairo_vg_surface_t *)
+ _vg_surface_create_internal (context, vg_image, format,
+ extents.width, extents.height);
+ cairo_surface_set_device_offset (&clone->base, -extents.x, -extents.y);
+
+ status = _cairo_recording_surface_replay (surface, &clone->base);
+ if (unlikely (status)) {
+ cairo_surface_destroy (&clone->base);
+ return (cairo_vg_surface_t *) _cairo_surface_create_in_error (status);
+ }
+
+ return clone;
+}
+
+static cairo_vg_surface_t *
+_vg_clone_image_surface (cairo_vg_context_t *context,
+ cairo_surface_t *surface)
+{
+ cairo_image_surface_t *image;
+ void *image_extra;
+ cairo_status_t status;
+ VGImage vg_image;
+ VGImageFormat format;
+ cairo_rectangle_int_t extents;
+ cairo_vg_surface_t *clone;
+
+ if (surface->backend->acquire_source_image == NULL)
+ return NULL;
+
+ status = _cairo_surface_get_extents (surface, &extents);
+ if (status)
+ return NULL;
+
+ if (extents.width > vgGeti (VG_MAX_IMAGE_WIDTH) ||
+ extents.height > vgGeti (VG_MAX_IMAGE_HEIGHT))
+ {
+ return NULL;
+ }
+
+ status = _cairo_surface_acquire_source_image (surface,
+ &image, &image_extra);
+ if (unlikely (status))
+ return (cairo_vg_surface_t *) _cairo_surface_create_in_error (status);
+
+ format = _vg_format_from_pixman (image->pixman_format);
+ if (format == 0)
+ format = _vg_format_for_content (image->base.content);
+
+ /* NONALIASED, FASTER, BETTER */
+ vg_image = vgCreateImage (format,
+ image->width, image->height,
+ VG_IMAGE_QUALITY_FASTER);
+ clone = (cairo_vg_surface_t *)
+ _vg_surface_create_internal (context, vg_image, format,
+ image->width, image->height);
+ if (unlikely (clone->base.status))
+ return clone;
+
+ vgImageSubData (clone->image,
+ image->data, image->stride,
+ format, 0, 0, image->width, image->height);
+
+ _cairo_surface_release_source_image (surface, image, image_extra);
+
+ return clone;
+}
+
+static void
+_vg_surface_remove_from_cache (cairo_surface_t *abstract_surface)
+{
+ cairo_vg_surface_t *surface = (cairo_vg_surface_t *) abstract_surface;
+
+ if (surface->snapshot_cache_entry.hash) {
+ cairo_vg_context_t *context;
+
+ context = _vg_context_lock (surface->context);
+ _cairo_cache_remove (&context->snapshot_cache,
+ &surface->snapshot_cache_entry);
+ _vg_context_unlock (context);
+
+ surface->snapshot_cache_entry.hash = 0;
+ }
+}
+
+static cairo_status_t
+_vg_setup_surface_source (cairo_vg_context_t *context,
+ const cairo_surface_pattern_t *spat)
+{
+ cairo_surface_t *snapshot;
+ cairo_vg_surface_t *clone;
+ cairo_status_t status;
+
+ snapshot = _cairo_surface_has_snapshot (spat->surface,
+ &cairo_vg_surface_backend);
+ if (snapshot != NULL) {
+ clone = (cairo_vg_surface_t *) cairo_surface_reference (snapshot);
+ goto DONE;
+ }
+
+ if (_cairo_surface_is_recording (spat->surface))
+ clone = _vg_clone_recording_surface (context, spat->surface);
+ else
+ clone = _vg_clone_image_surface (context, spat->surface);
+ if (clone == NULL)
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+ if (unlikely (clone->base.status))
+ return clone->base.status;
+
+ clone->snapshot_cache_entry.hash = clone->base.unique_id;
+ status = _cairo_cache_insert (&context->snapshot_cache,
+ &clone->snapshot_cache_entry);
+ if (unlikely (status)) {
+ clone->snapshot_cache_entry.hash = 0;
+ cairo_surface_destroy (&clone->base);
+ return status;
+ }
+
+ _cairo_surface_attach_snapshot (spat->surface, &clone->base,
+ _vg_surface_remove_from_cache);
+
+DONE:
+ cairo_surface_destroy (&context->source->base);
+ context->source = clone;
+
+ vgSetParameteri (context->paint, VG_PAINT_TYPE, VG_PAINT_TYPE_PATTERN);
+
+ switch (spat->base.extend) {
+ case CAIRO_EXTEND_PAD:
+ vgSetParameteri (context->paint,
+ VG_PAINT_PATTERN_TILING_MODE,
+ VG_TILE_PAD);
+ break;
+
+ case CAIRO_EXTEND_NONE:
+ vgSetParameteri (context->paint,
+ VG_PAINT_PATTERN_TILING_MODE,
+ VG_TILE_FILL);
+ {
+ VGfloat color[] = {0,0,0,0};
+ vgSetfv (VG_TILE_FILL_COLOR, 4, color);
+ }
+ break;
+
+ case CAIRO_EXTEND_REPEAT:
+ vgSetParameteri (context->paint,
+ VG_PAINT_PATTERN_TILING_MODE,
+ VG_TILE_REPEAT);
+ break;
+
+ default:
+ ASSERT_NOT_REACHED;
+ case CAIRO_EXTEND_REFLECT:
+ vgSetParameteri (context->paint,
+ VG_PAINT_PATTERN_TILING_MODE,
+ VG_TILE_REFLECT);
+ break;
+ }
+ vgPaintPattern (context->paint, context->source->image);
+
+ _vg_set_source_matrix (&spat->base);
+
+ CHECK_VG_ERRORS();
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+setup_source (cairo_vg_context_t *context,
+ const cairo_pattern_t *source)
+{
+ switch (source->type) {
+ case CAIRO_PATTERN_TYPE_SOLID:
+ return _vg_setup_solid_source (context,
+ (cairo_solid_pattern_t *) source);
+ case CAIRO_PATTERN_TYPE_LINEAR:
+ return _vg_setup_linear_source (context,
+ (cairo_linear_pattern_t *) source);
+ case CAIRO_PATTERN_TYPE_RADIAL:
+ return _vg_setup_radial_source (context,
+ (cairo_radial_pattern_t *) source);
+ case CAIRO_PATTERN_TYPE_SURFACE:
+ return _vg_setup_surface_source (context,
+ (cairo_surface_pattern_t *) source);
+ default:
+ ASSERT_NOT_REACHED;
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
+}
+
+static cairo_int_status_t
+_vg_surface_stroke (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ const cairo_path_fixed_t *path,
+ const cairo_stroke_style_t *style,
+ const cairo_matrix_t *ctm,
+ const cairo_matrix_t *ctm_inverse,
+ double tolerance,
+ cairo_antialias_t antialias,
+ const cairo_clip_t *clip)
+{
+ cairo_vg_surface_t *surface = abstract_surface;
+ cairo_vg_context_t *context;
+ cairo_status_t status;
+ VGfloat state[9];
+ VGfloat strokeTransform[9];
+ vg_path_t vg_path;
+
+ if (! _vg_is_supported_operator (op))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ context = _vg_context_lock (surface->context);
+ status = _vg_context_set_target (context, surface);
+ if (status) {
+ _vg_context_unlock (context);
+ return status;
+ }
+
+ status = setup_source (context, source);
+ if (status) {
+ _vg_context_unlock (context);
+ return status;
+ }
+
+ status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
+ if (unlikely (status)) {
+ _vg_context_unlock (context);
+ return status;
+ }
+
+ vg_path.path = vgCreatePath (VG_PATH_FORMAT_STANDARD,
+ VG_PATH_DATATYPE_F,
+ 1, 0, 0, 0,
+ VG_PATH_CAPABILITY_ALL);
+
+ vgGetMatrix (state);
+ _vg_matrix_from_cairo (strokeTransform, ctm);
+ vgMultMatrix (strokeTransform);
+
+ vg_path.ctm_inverse = ctm_inverse;
+
+ _vg_path_from_cairo (&vg_path, path);
+
+ /* XXX DASH_PATTERN, DASH_PHASE */
+ vgSetf (VG_STROKE_LINE_WIDTH, style->line_width);
+ vgSetf (VG_STROKE_MITER_LIMIT, style->miter_limit);
+ vgSetf (VG_STROKE_JOIN_STYLE, _vg_line_join_from_cairo (style->line_join));
+ vgSetf (VG_STROKE_CAP_STYLE, _vg_line_cap_from_cairo (style->line_cap));
+
+ vgSeti (VG_BLEND_MODE, _vg_operator (op));
+
+ vgSetPaint (context->paint, VG_STROKE_PATH);
+
+ vgDrawPath (vg_path.path, VG_STROKE_PATH);
+
+ vgDestroyPath (vg_path.path);
+
+ vgLoadMatrix (state);
+
+ CHECK_VG_ERRORS();
+ _vg_context_unlock (context);
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_int_status_t
+_vg_surface_fill (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ const cairo_path_fixed_t *path,
+ cairo_fill_rule_t fill_rule,
+ double tolerance,
+ cairo_antialias_t antialias,
+ const cairo_clip_t *clip)
+{
+ cairo_vg_surface_t *surface = abstract_surface;
+ cairo_vg_context_t *context;
+ cairo_status_t status;
+ vg_path_t vg_path;
+
+ if (op == CAIRO_OPERATOR_DEST)
+ return CAIRO_STATUS_SUCCESS;
+
+ if (! _vg_is_supported_operator (op))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ context = _vg_context_lock (surface->context);
+ status = _vg_context_set_target (context, surface);
+ if (status) {
+ _vg_context_unlock (context);
+ return status;
+ }
+
+ status = setup_source (context, source);
+ if (status) {
+ _vg_context_unlock (context);
+ return status;
+ }
+
+ status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
+ if (unlikely (status)) {
+ _vg_context_unlock (context);
+ return status;
+ }
+
+ vg_path.path = vgCreatePath (VG_PATH_FORMAT_STANDARD,
+ VG_PATH_DATATYPE_F,
+ 1, 0,
+ 0, 0,
+ VG_PATH_CAPABILITY_ALL);
+ vg_path.ctm_inverse = NULL;
+
+ _vg_path_from_cairo (&vg_path, path);
+
+ /* XXX tolerance */
+
+ vgSeti (VG_BLEND_MODE, _vg_operator (op));
+ vgSetf (VG_FILL_RULE, _vg_fill_rule_from_cairo (fill_rule));
+ vgSetf (VG_RENDERING_QUALITY, _vg_rendering_quality_from_cairo (antialias));
+
+ vgSetPaint (context->paint, VG_FILL_PATH);
+
+ vgDrawPath (vg_path.path, VG_FILL_PATH);
+
+ vgDestroyPath (vg_path.path);
+
+ _vg_context_unlock (context);
+
+ CHECK_VG_ERRORS();
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_int_status_t
+_vg_surface_paint (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ const cairo_clip_t *clip)
+{
+ cairo_vg_surface_t *surface = abstract_surface;
+ cairo_vg_context_t *context;
+ cairo_status_t status;
+
+ if (op == CAIRO_OPERATOR_DEST)
+ return CAIRO_STATUS_SUCCESS;
+
+ if (! _vg_is_supported_operator (op))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ context = _vg_context_lock (surface->context);
+ status = _vg_context_set_target (context, surface);
+ if (status) {
+ _vg_context_unlock (context);
+ return status;
+ }
+
+ status = setup_source (context, source);
+ if (status) {
+ _vg_context_unlock (context);
+ return status;
+ }
+
+ status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
+ if (unlikely (status)) {
+ _vg_context_unlock (context);
+ return status;
+ }
+
+ vgSeti (VG_BLEND_MODE, _vg_operator (op));
+ vgSetPaint (context->paint, VG_FILL_PATH);
+
+ { /* creating a rectangular path that should cover the extent */
+ VGubyte segs[] = {
+ VG_MOVE_TO_ABS, VG_LINE_TO_ABS,
+ VG_LINE_TO_ABS, VG_LINE_TO_ABS,
+ VG_CLOSE_PATH
+ };
+ VGfloat data[] = {
+ 0, 0,
+ surface->width, 0,
+ surface->width, surface->height,
+ 0, surface->height
+ };
+ VGPath fullext;
+
+ fullext = vgCreatePath (VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
+ 1,0,0,0, VG_PATH_CAPABILITY_ALL);
+ vgAppendPathData (fullext, sizeof(segs), segs, data);
+
+ vgDrawPath (fullext, VG_FILL_PATH);
+
+ vgDestroyPath (fullext);
+ }
+
+ _vg_context_unlock (context);
+
+ CHECK_VG_ERRORS();
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_int_status_t
+_vg_surface_mask (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ const cairo_pattern_t *mask,
+ const cairo_clip_t *clip)
+{
+ cairo_vg_surface_t *surface = abstract_surface;
+ cairo_status_t status;
+
+ if (! _vg_is_supported_operator (op))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ /* Handle paint-with-alpha to do fades cheaply */
+ if (mask->type == CAIRO_PATTERN_TYPE_SOLID) {
+ cairo_solid_pattern_t *solid = (cairo_solid_pattern_t *) mask;
+ cairo_vg_context_t *context = _vg_context_lock (surface->context);
+ double alpha = context->alpha;
+
+ context->alpha = solid->color.alpha;
+ status = _vg_surface_paint (abstract_surface, op, source, clip);
+ context->alpha = alpha;
+
+ _vg_context_unlock (context);
+
+ return status;
+ }
+
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+}
+
+static void
+_vg_surface_get_font_options (void *abstract_surface,
+ cairo_font_options_t *options)
+{
+ _cairo_font_options_init_default (options);
+
+ cairo_font_options_set_hint_metrics (options, CAIRO_HINT_METRICS_ON);
+ _cairo_font_options_set_round_glyph_positions (options, CAIRO_ROUND_GLYPH_POS_OFF);
+}
+
+static cairo_int_status_t
+_vg_surface_show_glyphs (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ cairo_glyph_t *glyphs,
+ int num_glyphs,
+ cairo_scaled_font_t *scaled_font,
+ const cairo_clip_t *clip)
+{
+ cairo_status_t status = CAIRO_STATUS_SUCCESS;
+ cairo_path_fixed_t path;
+
+ if (num_glyphs <= 0)
+ return CAIRO_STATUS_SUCCESS;
+
+ _cairo_path_fixed_init (&path);
+
+ /* XXX Glyph cache! OpenVG font support in 1.1? */
+
+ status = _cairo_scaled_font_glyph_path (scaled_font,
+ glyphs, num_glyphs,
+ &path);
+ if (unlikely (status))
+ goto BAIL;
+
+ status = _vg_surface_fill (abstract_surface,
+ op, source, &path,
+ CAIRO_FILL_RULE_WINDING,
+ CAIRO_GSTATE_TOLERANCE_DEFAULT,
+ CAIRO_ANTIALIAS_DEFAULT,
+ clip);
+BAIL:
+ _cairo_path_fixed_fini (&path);
+ return status;
+}
+
+static inline int
+multiply_alpha (int alpha, int color)
+{
+ int temp = alpha * color + 0x80;
+ return (temp + (temp >> 8)) >> 8;
+}
+
+static void
+premultiply_argb (uint8_t *data,
+ int width,
+ int height,
+ int stride)
+{
+ int i;
+
+ while (height --) {
+ uint32_t *row = (uint32_t *) data;
+
+ for (i = 0; i < width; i++) {
+ uint32_t p = row[i];
+ uint8_t alpha;
+
+ alpha = p >> 24;
+ if (alpha == 0) {
+ row[i] = 0;
+ } else if (alpha != 0xff) {
+ uint8_t r = multiply_alpha (alpha, (p >> 16) & 0xff);
+ uint8_t g = multiply_alpha (alpha, (p >> 8) & 0xff);
+ uint8_t b = multiply_alpha (alpha, (p >> 0) & 0xff);
+ row[i] = (alpha << 24) | (r << 16) | (g << 8) | (b << 0);
+ }
+ }
+
+ data += stride;
+ }
+}
+
+static cairo_int_status_t
+_vg_get_image (cairo_vg_surface_t *surface,
+ int x, int y,
+ int width, int height,
+ cairo_image_surface_t **image_out)
+{
+ cairo_image_surface_t *image;
+ pixman_image_t *pixman_image;
+ pixman_format_code_t pixman_format;
+ cairo_bool_t needs_premultiply;
+
+ pixman_format = _vg_format_to_pixman (surface->format,
+ &needs_premultiply);
+ if (pixman_format == 0)
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ pixman_image = pixman_image_create_bits (pixman_format,
+ width, height,
+ NULL, 0);
+ if (unlikely (pixman_image == NULL))
+ return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+
+ vgFinish ();
+ CHECK_VG_ERRORS();
+
+ vgGetImageSubData (surface->image,
+ pixman_image_get_data (pixman_image),
+ pixman_image_get_stride (pixman_image),
+ surface->format,
+ x, y, width, height);
+
+ image = (cairo_image_surface_t *)
+ _cairo_image_surface_create_for_pixman_image (pixman_image,
+ pixman_format);
+ if (unlikely (image->base.status)) {
+ pixman_image_unref (pixman_image);
+ return image->base.status;
+ }
+
+ if (needs_premultiply)
+ premultiply_argb (image->data, width, height, image->stride);
+
+ *image_out = image;
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_vg_surface_acquire_source_image (void *abstract_surface,
+ cairo_image_surface_t **image_out,
+ void **image_extra)
+{
+ cairo_vg_surface_t *surface = abstract_surface;
+
+ CHECK_VG_ERRORS();
+ *image_extra = NULL;
+ return _vg_get_image (surface,
+ 0, 0, surface->width, surface->height,
+ image_out);
+}
+
+static void
+_vg_surface_release_source_image (void *abstract_surface,
+ cairo_image_surface_t *image,
+ void *image_extra)
+{
+ cairo_surface_destroy (&image->base);
+}
+
+static cairo_status_t
+_vg_surface_finish (void *abstract_surface)
+{
+ cairo_vg_surface_t *surface = abstract_surface;
+ cairo_vg_context_t *context = _vg_context_lock (surface->context);
+
+ if (surface->snapshot_cache_entry.hash) {
+ _cairo_cache_remove (&context->snapshot_cache,
+ &surface->snapshot_cache_entry);
+
+ surface->snapshot_cache_entry.hash = 0;
+ }
+
+ _cairo_surface_clipper_reset (&surface->clipper);
+
+ if (surface->own_image)
+ vgDestroyImage (surface->image);
+
+ _vg_context_destroy_target (context, surface);
+
+ _vg_context_unlock (context);
+ _vg_context_destroy (context);
+
+ CHECK_VG_ERRORS();
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static const cairo_surface_backend_t cairo_vg_surface_backend = {
+ CAIRO_SURFACE_TYPE_VG,
+ _vg_surface_finish,
+
+ _cairo_default_context_create, /* XXX */
+
+ _vg_surface_create_similar,
+ NULL, /* create similar image */
+ NULL, /* map to image */
+ NULL, /* unmap image */
+
+ _cairo_surface_default_source,
+ _vg_surface_acquire_source_image,
+ _vg_surface_release_source_image,
+ NULL, /* snapshot */
+
+ NULL, /* copy_page */
+ NULL, /* show_page */
+
+ _vg_surface_get_extents,
+ _vg_surface_get_font_options, /* get_font_options */
+
+ NULL, /* flush */
+ NULL, /* mark dirty */
+
+ _vg_surface_paint,
+ _vg_surface_mask,
+ _vg_surface_stroke,
+ _vg_surface_fill,
+ NULL, /* fill-stroke */
+ _vg_surface_show_glyphs,
+};
+
+static cairo_surface_t *
+_vg_surface_create_internal (cairo_vg_context_t *context,
+ VGImage image,
+ VGImageFormat format,
+ int width, int height)
+{
+ cairo_vg_surface_t *surface;
+
+ surface = malloc (sizeof (cairo_vg_surface_t));
+ if (unlikely (surface == NULL))
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
+
+ surface->context = _vg_context_reference (context);
+
+ surface->image = image;
+ surface->format = format;
+
+ _cairo_surface_init (&surface->base,
+ &cairo_vg_surface_backend,
+ NULL, /* device */
+ _vg_format_to_content (format));
+
+ surface->width = width;
+ surface->height = height;
+
+ _cairo_surface_clipper_init (&surface->clipper,
+ _vg_surface_clipper_intersect_clip_path);
+
+ surface->snapshot_cache_entry.hash = 0;
+
+ surface->target_id = 0;
+
+ CHECK_VG_ERRORS();
+ return &surface->base;
+}
+
+cairo_surface_t *
+cairo_vg_surface_create_for_image (cairo_vg_context_t *context,
+ VGImage image,
+ VGImageFormat format,
+ int width, int height)
+{
+ cairo_bool_t premult;
+
+ if (context->status)
+ return _cairo_surface_create_in_error (context->status);
+
+ if (image == VG_INVALID_HANDLE)
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
+ if (_vg_format_to_pixman (format, &premult) == 0)
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_FORMAT));
+
+ return _vg_surface_create_internal (context, image, format, width, height);
+}
+
+cairo_surface_t *
+cairo_vg_surface_create (cairo_vg_context_t *context,
+ cairo_content_t content,
+ int width,
+ int height)
+{
+ VGImage image;
+ VGImageFormat format;
+ cairo_surface_t *surface;
+
+ if (context->status)
+ return _cairo_surface_create_in_error (context->status);
+
+ if (! CAIRO_CONTENT_VALID (content))
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_CONTENT));
+
+ if (width > vgGeti (VG_MAX_IMAGE_WIDTH) ||
+ height > vgGeti (VG_MAX_IMAGE_HEIGHT))
+ {
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE));
+ }
+
+
+ format = _vg_format_for_content (content);
+ image = vgCreateImage (format, width, height, VG_IMAGE_QUALITY_BETTER);
+ if (image == VG_INVALID_HANDLE)
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
+
+ surface = _vg_surface_create_internal (context,
+ image, format, width, height);
+ if (unlikely (surface->status))
+ return surface;
+
+ ((cairo_vg_surface_t *) surface)->own_image = TRUE;
+ return surface;
+}
+slim_hidden_def (cairo_vg_surface_create);
+
+VGImage
+cairo_vg_surface_get_image (cairo_surface_t *abstract_surface)
+{
+ cairo_vg_surface_t *surface;
+
+ if (abstract_surface->backend != &cairo_vg_surface_backend) {
+ _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
+ return VG_INVALID_HANDLE;
+ }
+
+ surface = (cairo_vg_surface_t *) abstract_surface;
+ return surface->image;
+}
+
+int
+cairo_vg_surface_get_width (cairo_surface_t *abstract_surface)
+{
+ cairo_vg_surface_t *surface;
+
+ if (abstract_surface->backend != &cairo_vg_surface_backend) {
+ _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
+ return 0;
+ }
+
+ surface = (cairo_vg_surface_t *) abstract_surface;
+ return surface->width;
+}
+
+int
+cairo_vg_surface_get_height (cairo_surface_t *abstract_surface)
+{
+ cairo_vg_surface_t *surface;
+
+ if (abstract_surface->backend != &cairo_vg_surface_backend) {
+ _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
+ return 0;
+ }
+
+ surface = (cairo_vg_surface_t *) abstract_surface;
+ return surface->height;
+}
+
+VGImageFormat
+cairo_vg_surface_get_format (cairo_surface_t *abstract_surface)
+{
+ cairo_vg_surface_t *surface;
+
+ if (abstract_surface->backend != &cairo_vg_surface_backend) {
+ _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
+ return 0;
+ }
+
+ surface = (cairo_vg_surface_t *) abstract_surface;
+ return surface->format;
+}
+
+/* GL specific context support :-(
+ *
+ * OpenVG like cairo defers creation of surface (and the necessary
+ * paraphernalia to the application.
+ */
+
+static const cairo_vg_context_t _vg_context_nil = {
+ CAIRO_STATUS_NO_MEMORY,
+ CAIRO_REFERENCE_COUNT_INVALID
+};
+
+static const cairo_vg_context_t _vg_context_nil_invalid_visual = {
+ CAIRO_STATUS_INVALID_VISUAL,
+ CAIRO_REFERENCE_COUNT_INVALID
+};
+
+#if CAIRO_HAS_GLX_FUNCTIONS
+#include <GL/glx.h>
+
+static cairo_status_t
+glx_create_target (cairo_vg_context_t *context,
+ cairo_vg_surface_t *surface)
+{
+ /* XXX hmm, magic required for creating an FBO points to VGImage! */
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+}
+
+static cairo_status_t
+glx_set_target (cairo_vg_context_t *context,
+ cairo_vg_surface_t *surface)
+{
+#if 0
+ glXMakeContextCurrent (context->display,
+ (GLXDrawable) surface->target_id,
+ (GLXDrawable) surface->target_id,
+ context->context);
+#else
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+#endif
+}
+
+static void
+glx_destroy_target (cairo_vg_context_t *context,
+ cairo_vg_surface_t *surface)
+{
+}
+
+cairo_vg_context_t *
+cairo_vg_context_create_for_glx (Display *dpy, GLXContext ctx)
+{
+ cairo_vg_context_t *context;
+ cairo_status_t status;
+
+ context = malloc (sizeof (*context));
+ if (unlikely (context == NULL))
+ return (cairo_vg_context_t *) &_vg_context_nil;
+
+ context->display = dpy;
+ context->context = ctx;
+
+ context->create_target = glx_create_target;
+ context->set_target = glx_set_target;
+ context->destroy_target = glx_destroy_target;
+
+ status = _vg_context_init (context);
+ if (unlikely (status)) {
+ free (context);
+ return (cairo_vg_context_t *) &_vg_context_nil;
+ }
+
+ return context;
+}
+#endif
+
+#if CAIRO_HAS_EGL_FUNCTIONS
+static cairo_status_t
+egl_create_target (cairo_vg_context_t *context,
+ cairo_vg_surface_t *surface)
+{
+ EGLSurface *egl_surface;
+#define RED 1
+#define GREEN 3
+#define BLUE 5
+#define ALPHA 7
+ int attribs[] = {
+ EGL_RED_SIZE, 0,
+ EGL_GREEN_SIZE, 0,
+ EGL_BLUE_SIZE, 0,
+ EGL_ALPHA_SIZE, 0,
+ EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+ EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,
+ EGL_NONE
+ };
+ pixman_format_code_t pixman_format;
+ EGLConfig config;
+ int num_configs = 0;
+ cairo_bool_t needs_premultiply;
+
+ pixman_format = _vg_format_to_pixman (surface->format, &needs_premultiply);
+ if (pixman_format == 0)
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ /* XXX no control over pixel ordering! */
+ attribs[RED] = PIXMAN_FORMAT_R (pixman_format);
+ attribs[GREEN] = PIXMAN_FORMAT_G (pixman_format);
+ attribs[BLUE] = PIXMAN_FORMAT_B (pixman_format);
+ attribs[ALPHA] = PIXMAN_FORMAT_A (pixman_format);
+
+ if (! eglChooseConfig (context->display,
+ attribs,
+ &config, 1, &num_configs) ||
+ num_configs != 1)
+ {
+ fprintf(stderr, "Error: eglChooseConfig() failed.\n");
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
+
+ egl_surface =
+ eglCreatePbufferFromClientBuffer (context->display,
+ EGL_OPENVG_IMAGE,
+ (EGLClientBuffer) surface->image,
+ config,
+ NULL);
+ surface->target_id = (unsigned long) egl_surface;
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+egl_set_target (cairo_vg_context_t *context,
+ cairo_vg_surface_t *surface)
+{
+ if (! eglMakeCurrent (context->display,
+ (EGLSurface *) surface->target_id,
+ (EGLSurface *) surface->target_id,
+ context->context))
+ {
+ return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+ }
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static void
+egl_destroy_target (cairo_vg_context_t *context,
+ cairo_vg_surface_t *surface)
+{
+ eglDestroySurface (context->display,
+ (EGLSurface *) surface->target_id);
+}
+
+cairo_vg_context_t *
+cairo_vg_context_create_for_egl (EGLDisplay egl_display,
+ EGLContext egl_context)
+{
+ cairo_vg_context_t *context;
+ cairo_status_t status;
+
+ context = malloc (sizeof (*context));
+ if (unlikely (context == NULL))
+ return (cairo_vg_context_t *) &_vg_context_nil;
+
+ status = _vg_context_init (context);
+ if (unlikely (status)) {
+ free (context);
+ return (cairo_vg_context_t *) &_vg_context_nil;
+ }
+
+ context->display = egl_display;
+ context->context = egl_context;
+
+ context->create_target = egl_create_target;
+ context->set_target = egl_set_target;
+ context->destroy_target = egl_destroy_target;
+
+ return context;
+}
+#endif
+
+cairo_status_t
+cairo_vg_context_status (cairo_vg_context_t *context)
+{
+ return context->status;
+}
+
+void
+cairo_vg_context_destroy (cairo_vg_context_t *context)
+{
+ if (context == NULL || CAIRO_REFERENCE_COUNT_IS_INVALID (&context->ref_count))
+ return;
+
+ _vg_context_destroy (context);
+}