diff options
Diffstat (limited to 'Build/source/libs/cairo/cairo-1.14.2/src/cairo-cogl-surface.c')
| -rw-r--r-- | Build/source/libs/cairo/cairo-1.14.2/src/cairo-cogl-surface.c | 2805 |
1 files changed, 2805 insertions, 0 deletions
diff --git a/Build/source/libs/cairo/cairo-1.14.2/src/cairo-cogl-surface.c b/Build/source/libs/cairo/cairo-1.14.2/src/cairo-cogl-surface.c new file mode 100644 index 00000000000..c57fd7f433c --- /dev/null +++ b/Build/source/libs/cairo/cairo-1.14.2/src/cairo-cogl-surface.c @@ -0,0 +1,2805 @@ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2011 Intel Corporation. + * + * 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): + * Robert Bragg <robert@linux.intel.com> + */ +#include "cairoint.h" + +#include "cairo-cache-private.h" +#include "cairo-error-private.h" +#include "cairo-path-fixed-private.h" +#include "cairo-recording-surface-private.h" +#include "cairo-surface-clipper-private.h" +#include "cairo-fixed-private.h" +#include "cairo-device-private.h" +#include "cairo-composite-rectangles-private.h" +#include "cairo-image-surface-inline.h" +#include "cairo-cogl-private.h" +#include "cairo-cogl-gradient-private.h" +#include "cairo-arc-private.h" +#include "cairo-traps-private.h" +#include "cairo-cogl-context-private.h" +#include "cairo-cogl-utils-private.h" +#include "cairo-box-inline.h" +#include "cairo-surface-subsurface-inline.h" +#include "cairo-surface-fallback-private.h" +#include "cairo-surface-offset-private.h" + +#include "cairo-cogl.h" + +#include <cogl/cogl2-experimental.h> +#include <glib.h> + +#define CAIRO_COGL_DEBUG 0 +//#define FILL_WITH_COGL_PATH +//#define USE_CAIRO_PATH_FLATTENER +#define ENABLE_PATH_CACHE +//#define DISABLE_BATCHING +#define USE_COGL_RECTANGLE_API +#define ENABLE_RECTANGLES_FASTPATH + +#if defined (USE_COGL_RECTANGLE_API) || defined (ENABLE_PATH_CACHE) +#define NEED_COGL_CONTEXT +#endif + +#if CAIRO_COGL_DEBUG && __GNUC__ +#define UNSUPPORTED(reason) ({ \ + g_warning ("cairo-cogl: hit unsupported operation: %s", reason); \ + CAIRO_INT_STATUS_UNSUPPORTED; \ +}) +#else +#define UNSUPPORTED(reason) CAIRO_INT_STATUS_UNSUPPORTED +#endif + +#define CAIRO_COGL_PATH_META_CACHE_SIZE (1024 * 1024) + +typedef struct _cairo_cogl_texture_attributes { + /* nabbed from cairo_surface_attributes_t... */ + cairo_matrix_t matrix; + cairo_extend_t extend; + cairo_filter_t filter; + cairo_bool_t has_component_alpha; + + CoglPipelineWrapMode s_wrap; + CoglPipelineWrapMode t_wrap; +} cairo_cogl_texture_attributes_t; + +typedef enum _cairo_cogl_journal_entry_type { + CAIRO_COGL_JOURNAL_ENTRY_TYPE_RECTANGLE, + CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE, + CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH, + CAIRO_COGL_JOURNAL_ENTRY_TYPE_CLIP +} cairo_cogl_journal_entry_type_t; + +typedef struct _cairo_cogl_journal_entry { + cairo_cogl_journal_entry_type_t type; +} cairo_cogl_journal_entry_t; + +typedef struct _cairo_cogl_journal_clip_entry { + cairo_cogl_journal_entry_t base; + cairo_clip_t *clip; +} cairo_cogl_journal_clip_entry_t; + +typedef struct _cairo_cogl_journal_rect_entry { + cairo_cogl_journal_entry_t base; + CoglPipeline *pipeline; + float x; + float y; + float width; + float height; + int n_layers; + cairo_matrix_t ctm; +} cairo_cogl_journal_rect_entry_t; + +typedef struct _cairo_cogl_journal_prim_entry { + cairo_cogl_journal_entry_t base; + CoglPipeline *pipeline; + CoglPrimitive *primitive; + gboolean has_transform; + cairo_matrix_t transform; +} cairo_cogl_journal_prim_entry_t; + +typedef struct _cairo_cogl_journal_path_entry { + cairo_cogl_journal_entry_t base; + CoglPipeline *pipeline; + CoglPath *path; +} cairo_cogl_journal_path_entry_t; + +typedef struct _cairo_cogl_path_fill_meta { + cairo_cache_entry_t cache_entry; + cairo_reference_count_t ref_count; + int counter; + cairo_path_fixed_t *user_path; + cairo_matrix_t ctm_inverse; + + /* TODO */ +#if 0 + /* A cached path tessellation should be re-usable with different rotations + * and translations but not for different scales. + * + * one idea is to track the diagonal lenghts of a unit rectangle + * transformed through the original ctm use to tessellate the geometry + * so we can check what the lengths are for any new ctm to know if + * this geometry is compatible. + */ +#endif + + CoglPrimitive *prim; +} cairo_cogl_path_fill_meta_t; + +typedef struct _cairo_cogl_path_stroke_meta { + cairo_cache_entry_t cache_entry; + cairo_reference_count_t ref_count; + int counter; + cairo_path_fixed_t *user_path; + cairo_matrix_t ctm_inverse; + cairo_stroke_style_t style; + double tolerance; + + /* TODO */ +#if 0 + /* A cached path tessellation should be re-usable with different rotations + * and translations but not for different scales. + * + * one idea is to track the diagonal lenghts of a unit rectangle + * transformed through the original ctm use to tessellate the geometry + * so we can check what the lengths are for any new ctm to know if + * this geometry is compatible. + */ +#endif + + CoglPrimitive *prim; +} cairo_cogl_path_stroke_meta_t; + +static cairo_surface_t * +_cairo_cogl_surface_create_full (cairo_cogl_device_t *dev, + cairo_bool_t ignore_alpha, + CoglFramebuffer *framebuffer, + CoglTexture *texture); + +static cairo_int_status_t +_cairo_cogl_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); + +static void +_cairo_cogl_journal_flush (cairo_cogl_surface_t *surface); + +cairo_private extern const cairo_surface_backend_t _cairo_cogl_surface_backend; + +slim_hidden_proto (cairo_cogl_device_create); +slim_hidden_proto (cairo_cogl_surface_create); +slim_hidden_proto (cairo_cogl_surface_get_framebuffer); +slim_hidden_proto (cairo_cogl_surface_get_texture); +slim_hidden_proto (cairo_cogl_surface_end_frame); + +static cairo_cogl_device_t * +to_device (cairo_device_t *device) +{ + return (cairo_cogl_device_t *)device; +} + +/* moves trap points such that they become the actual corners of the trapezoid */ +static void +_sanitize_trap (cairo_trapezoid_t *t) +{ + cairo_trapezoid_t s = *t; + +#define FIX(lr, tb, p) \ + if (t->lr.p.y != t->tb) { \ + t->lr.p.x = s.lr.p2.x + _cairo_fixed_mul_div_floor (s.lr.p1.x - s.lr.p2.x, s.tb - s.lr.p2.y, s.lr.p1.y - s.lr.p2.y); \ + t->lr.p.y = s.tb; \ + } + FIX (left, top, p1); + FIX (left, bottom, p2); + FIX (right, top, p1); + FIX (right, bottom, p2); +} + +static cairo_status_t +_cairo_cogl_surface_ensure_framebuffer (cairo_cogl_surface_t *surface) +{ + GError *error = NULL; + + if (surface->framebuffer) + return CAIRO_STATUS_SUCCESS; + + surface->framebuffer = COGL_FRAMEBUFFER (cogl_offscreen_new_to_texture (surface->texture)); + if (!cogl_framebuffer_allocate (surface->framebuffer, &error)) { + g_error_free (error); + cogl_object_unref (surface->framebuffer); + surface->framebuffer = NULL; + return CAIRO_STATUS_NO_MEMORY; + } + + cogl_push_framebuffer (surface->framebuffer); + cogl_ortho (0, surface->width, + surface->height, 0, + -1, 100); + cogl_pop_framebuffer (); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_surface_t * +_cairo_cogl_surface_create_similar (void *abstract_surface, + cairo_content_t content, + int width, + int height) +{ + cairo_cogl_surface_t *reference_surface = abstract_surface; + cairo_cogl_surface_t *surface; + CoglTexture *texture; + cairo_status_t status; + + texture = cogl_texture_new_with_size (width, height, + COGL_TEXTURE_NO_SLICING, + (content & CAIRO_CONTENT_COLOR) ? + COGL_PIXEL_FORMAT_BGRA_8888_PRE : + COGL_PIXEL_FORMAT_A_8); + if (!texture) + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + + surface = (cairo_cogl_surface_t *) + _cairo_cogl_surface_create_full (to_device(reference_surface->base.device), + (content & CAIRO_CONTENT_ALPHA) == 0, + NULL, + texture); + if (unlikely (surface->base.status)) + return &surface->base; + + status = _cairo_cogl_surface_ensure_framebuffer (surface); + if (unlikely (status)) { + cairo_surface_destroy (&surface->base); + return _cairo_surface_create_in_error (status); + } + + return &surface->base; +} + +static cairo_bool_t +_cairo_cogl_surface_get_extents (void *abstract_surface, + cairo_rectangle_int_t *extents) +{ + cairo_cogl_surface_t *surface = abstract_surface; + + extents->x = 0; + extents->y = 0; + extents->width = surface->width; + extents->height = surface->height; + + return TRUE; +} + +static void +_cairo_cogl_journal_free (cairo_cogl_surface_t *surface) +{ + GList *l; + + for (l = surface->journal->head; l; l = l->next) { + cairo_cogl_journal_entry_t *entry = l->data; + + if (entry->type == CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE) { + cairo_cogl_journal_prim_entry_t *prim_entry = + (cairo_cogl_journal_prim_entry_t *)entry; + cogl_object_unref (prim_entry->primitive); + } else if (entry->type == CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH) { + cairo_cogl_journal_path_entry_t *path_entry = + (cairo_cogl_journal_path_entry_t *)entry; + cogl_object_unref (path_entry->path); + } + } + + g_queue_free (surface->journal); + surface->journal = NULL; +} + +#ifdef FILL_WITH_COGL_PATH +static void +_cairo_cogl_journal_log_path (cairo_cogl_surface_t *surface, + CoglPipeline *pipeline, + CoglPath *path) +{ + cairo_cogl_journal_path_entry_t *entry; + + if (unlikely (surface->journal == NULL)) + surface->journal = g_queue_new (); + + /* FIXME: Instead of a GList here we should stack allocate the journal + * entries so it would be cheaper to allocate and they can all be freed in + * one go after flushing! */ + entry = g_slice_new (cairo_cogl_journal_path_entry_t); + entry->base.type = CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH; + + entry->pipeline = cogl_object_ref (pipeline); + entry->path = cogl_object_ref (path); + + g_queue_push_tail (surface->journal, entry); + +#ifdef DISABLE_BATCHING + _cairo_cogl_journal_flush (surface); +#endif +} +#endif /* FILL_WITH_COGL_PATH */ + +static void +_cairo_cogl_journal_log_primitive (cairo_cogl_surface_t *surface, + CoglPipeline *pipeline, + CoglPrimitive *primitive, + cairo_matrix_t *transform) +{ + cairo_cogl_journal_prim_entry_t *entry; + + if (unlikely (surface->journal == NULL)) + surface->journal = g_queue_new (); + + /* FIXME: Instead of a GList here we should stack allocate the journal + * entries so it would be cheaper to allocate and they can all be freed in + * one go after flushing! */ + entry = g_slice_new (cairo_cogl_journal_prim_entry_t); + entry->base.type = CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE; + + entry->pipeline = cogl_object_ref (pipeline); + + if (transform) { + entry->transform = *transform; + entry->has_transform = TRUE; + } else + entry->has_transform = FALSE; + + entry->primitive = cogl_object_ref (primitive); + + g_queue_push_tail (surface->journal, entry); + +#ifdef DISABLE_BATCHING + _cairo_cogl_journal_flush (surface); +#endif +} + +static void +_cairo_cogl_journal_log_rectangle (cairo_cogl_surface_t *surface, + CoglPipeline *pipeline, + float x, + float y, + float width, + float height, + int n_layers, + cairo_matrix_t *ctm) +{ + cairo_cogl_journal_rect_entry_t *entry; + + if (unlikely (surface->journal == NULL)) + surface->journal = g_queue_new (); + + /* FIXME: Instead of a GList here we should stack allocate the journal + * entries so it would be cheaper to allocate and they can all be freed in + * one go after flushing! */ + entry = g_slice_new (cairo_cogl_journal_rect_entry_t); + entry->base.type = CAIRO_COGL_JOURNAL_ENTRY_TYPE_RECTANGLE; + + entry->pipeline = cogl_object_ref (pipeline); + + entry->x = x; + entry->y = y; + entry->width = width; + entry->height = height; + entry->ctm = *ctm; + + entry->n_layers = n_layers; + + g_queue_push_tail (surface->journal, entry); + +#ifdef DISABLE_BATCHING + _cairo_cogl_journal_flush (surface); +#endif +} + +static void +_cairo_cogl_journal_log_clip (cairo_cogl_surface_t *surface, + const cairo_clip_t *clip) +{ + cairo_cogl_journal_clip_entry_t *entry; + + if (unlikely (surface->journal == NULL)) + surface->journal = g_queue_new (); + + /* FIXME: Instead of a GList here we should stack allocate the journal + * entries so it would be cheaper to allocate and they can all be freed in + * one go after flushing! */ + entry = g_slice_new (cairo_cogl_journal_clip_entry_t); + entry->base.type = CAIRO_COGL_JOURNAL_ENTRY_TYPE_CLIP; + entry->clip = _cairo_clip_copy (clip); + + g_queue_push_tail (surface->journal, entry); +} + +static void +_cairo_cogl_journal_discard (cairo_cogl_surface_t *surface) +{ + GList *l; + + if (!surface->journal) { + assert (surface->last_clip == NULL); + return; + } + + if (surface->buffer_stack && surface->buffer_stack_offset) { + cogl_buffer_unmap (COGL_BUFFER (surface->buffer_stack)); + cogl_object_unref (surface->buffer_stack); + surface->buffer_stack = NULL; + } + + for (l = surface->journal->head; l; l = l->next) { + cairo_cogl_journal_entry_t *entry = l->data; + gsize entry_size; + + switch (entry->type) + { + case CAIRO_COGL_JOURNAL_ENTRY_TYPE_CLIP: { + cairo_cogl_journal_clip_entry_t *clip_entry = + (cairo_cogl_journal_clip_entry_t *)entry; + _cairo_clip_destroy (clip_entry->clip); + entry_size = sizeof (cairo_cogl_journal_clip_entry_t); + break; + } + case CAIRO_COGL_JOURNAL_ENTRY_TYPE_RECTANGLE: { + cairo_cogl_journal_rect_entry_t *rect_entry = + (cairo_cogl_journal_rect_entry_t *)entry; + cogl_object_unref (rect_entry->pipeline); + entry_size = sizeof (cairo_cogl_journal_rect_entry_t); + break; + } + case CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE: { + cairo_cogl_journal_prim_entry_t *prim_entry = + (cairo_cogl_journal_prim_entry_t *)entry; + cogl_object_unref (prim_entry->pipeline); + cogl_object_unref (prim_entry->primitive); + entry_size = sizeof (cairo_cogl_journal_prim_entry_t); + break; + } + case CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH: { + cairo_cogl_journal_path_entry_t *path_entry = + (cairo_cogl_journal_path_entry_t *)entry; + cogl_object_unref (path_entry->pipeline); + cogl_object_unref (path_entry->path); + entry_size = sizeof (cairo_cogl_journal_path_entry_t); + break; + } + default: + assert (0); /* not reached! */ + entry_size = 0; /* avoid compiler warning */ + } + g_slice_free1 (entry_size, entry); + } + + g_queue_clear (surface->journal); + + if (surface->last_clip) { + _cairo_clip_destroy (surface->last_clip); + surface->last_clip = NULL; + } +} + +static CoglAttributeBuffer * +_cairo_cogl_surface_allocate_buffer_space (cairo_cogl_surface_t *surface, + size_t size, + size_t *offset, + void **pointer) +{ + /* XXX: In the Cogl journal we found it more efficient to have a pool of + * buffers that we re-cycle but for now we simply thow away our stack + * buffer each time we flush. */ + if (unlikely (surface->buffer_stack && + (surface->buffer_stack_size - surface->buffer_stack_offset) < size)) { + cogl_buffer_unmap (COGL_BUFFER (surface->buffer_stack)); + cogl_object_unref (surface->buffer_stack); + surface->buffer_stack = NULL; + surface->buffer_stack_size *= 2; + } + + if (unlikely (surface->buffer_stack_size < size)) + surface->buffer_stack_size = size * 2; + + if (unlikely (surface->buffer_stack == NULL)) { + surface->buffer_stack = cogl_attribute_buffer_new (surface->buffer_stack_size, NULL); + surface->buffer_stack_pointer = + cogl_buffer_map (COGL_BUFFER (surface->buffer_stack), + COGL_BUFFER_ACCESS_WRITE, + COGL_BUFFER_MAP_HINT_DISCARD); + surface->buffer_stack_offset = 0; + } + + *pointer = surface->buffer_stack_pointer + surface->buffer_stack_offset; + *offset = surface->buffer_stack_offset; + + surface->buffer_stack_offset += size; + return cogl_object_ref (surface->buffer_stack); +} + + +static CoglAttributeBuffer * +_cairo_cogl_traps_to_triangles_buffer (cairo_cogl_surface_t *surface, + cairo_traps_t *traps, + size_t *offset, + gboolean one_shot) +{ + CoglAttributeBuffer *buffer; + int n_traps = traps->num_traps; + int i; + CoglVertexP2 *triangles; + + if (one_shot) { + buffer = _cairo_cogl_surface_allocate_buffer_space (surface, + n_traps * sizeof (CoglVertexP2) * 6, + offset, + (void **)&triangles); + if (!buffer) + return NULL; + } else { + buffer = cogl_attribute_buffer_new (n_traps * sizeof (CoglVertexP2) * 6, NULL); + if (!buffer) + return NULL; + triangles = cogl_buffer_map (COGL_BUFFER (buffer), + COGL_BUFFER_ACCESS_WRITE, + COGL_BUFFER_MAP_HINT_DISCARD); + if (!triangles) + return NULL; + *offset = 0; + } + + /* XXX: This is can be very expensive. I'm not sure a.t.m if it's + * predominantly the bandwidth required or the cost of the fixed_to_float + * conversions but either way we should try using an index buffer to + * reduce the amount we upload by 1/3 (offset by allocating and uploading + * indices though) sadly though my experience with the intel mesa drivers + * is that slow paths can easily be hit when starting to use indices. + */ + for (i = 0; i < n_traps; i++) + { + CoglVertexP2 *p = &triangles[i * 6]; + cairo_trapezoid_t *trap = &traps->traps[i]; + + p[0].x = _cairo_cogl_util_fixed_to_float (trap->left.p1.x); + p[0].y = _cairo_cogl_util_fixed_to_float (trap->left.p1.y); + + p[1].x = _cairo_cogl_util_fixed_to_float (trap->left.p2.x); + p[1].y = _cairo_cogl_util_fixed_to_float (trap->left.p2.y); + + p[2].x = _cairo_cogl_util_fixed_to_float (trap->right.p2.x); + p[2].y = _cairo_cogl_util_fixed_to_float (trap->right.p2.y); + + p[3].x = _cairo_cogl_util_fixed_to_float (trap->left.p1.x); + p[3].y = _cairo_cogl_util_fixed_to_float (trap->left.p1.y); + + p[4].x = _cairo_cogl_util_fixed_to_float (trap->right.p2.x); + p[4].y = _cairo_cogl_util_fixed_to_float (trap->right.p2.y); + + p[5].x = _cairo_cogl_util_fixed_to_float (trap->right.p1.x); + p[5].y = _cairo_cogl_util_fixed_to_float (trap->right.p1.y); + } + + if (!one_shot) + cogl_buffer_unmap (COGL_BUFFER (buffer)); + + return buffer; +} + +/* Used for solid fills, in this case we just need a mesh made of + * a single (2-component) position attribute. */ +static CoglPrimitive * +_cairo_cogl_traps_to_composite_prim_p2 (cairo_cogl_surface_t *surface, + cairo_traps_t *traps, + gboolean one_shot) +{ + size_t offset; + CoglAttributeBuffer *buffer = _cairo_cogl_traps_to_triangles_buffer (surface, traps, &offset, one_shot); + CoglAttribute *pos = cogl_attribute_new (buffer, + "cogl_position_in", + sizeof (CoglVertexP2), + offset, + 2, + COGL_ATTRIBUTE_TYPE_FLOAT); + CoglPrimitive *prim; + + /* The attribute will have taken a reference on the buffer */ + cogl_object_unref (buffer); + + prim = cogl_primitive_new (COGL_VERTICES_MODE_TRIANGLES, + traps->num_traps * 6, pos, NULL); + + /* The primitive will now keep the attribute alive... */ + cogl_object_unref (pos); + + return prim; +} + +/* Used for surface fills, in this case we need a mesh made of a single + * (2-component) position attribute + we also alias the same attribute as + * (2-component) texture coordinates */ +static CoglPrimitive * +_cairo_cogl_traps_to_composite_prim_p2t2 (cairo_cogl_surface_t *surface, + cairo_traps_t *traps, + gboolean one_shot) +{ + size_t offset; + CoglAttributeBuffer *buffer = _cairo_cogl_traps_to_triangles_buffer (surface, traps, &offset, one_shot); + CoglAttribute *pos = cogl_attribute_new (buffer, + "cogl_position_in", + sizeof (CoglVertexP2), + offset, + 2, + COGL_ATTRIBUTE_TYPE_FLOAT); + CoglAttribute *tex_coords = cogl_attribute_new (buffer, + "cogl_tex_coord0_in", + sizeof (CoglVertexP2), + 0, + 2, + COGL_ATTRIBUTE_TYPE_FLOAT); + CoglPrimitive *prim; + + /* The attributes will have taken references on the buffer */ + cogl_object_unref (buffer); + + prim = cogl_primitive_new (COGL_VERTICES_MODE_TRIANGLES, + traps->num_traps * 6, pos, tex_coords, NULL); + + /* The primitive will now keep the attributes alive... */ + cogl_object_unref (pos); + cogl_object_unref (tex_coords); + + return prim; +} + +static CoglPrimitive * +_cairo_cogl_traps_to_composite_prim (cairo_cogl_surface_t *surface, + cairo_traps_t *traps, + int n_layers, + gboolean one_shot) +{ + int n_traps = traps->num_traps; + int i; + + /* XXX: Ideally we would skip tessellating to traps entirely since + * given their representation, conversion to triangles is quite expensive. + * + * This simplifies the conversion to triangles by making the end points of + * the two side lines actually just correspond to the corners of the + * traps. + */ + for (i = 0; i < n_traps; i++) + _sanitize_trap (&traps->traps[i]); + + if (n_layers == 0) + return _cairo_cogl_traps_to_composite_prim_p2 (surface, traps, one_shot); + else { + assert (n_layers == 1); + return _cairo_cogl_traps_to_composite_prim_p2t2 (surface, traps, one_shot); + } +} + +static cairo_int_status_t +_cairo_cogl_fill_to_primitive (cairo_cogl_surface_t *surface, + const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + int n_layers, + cairo_bool_t one_shot, + CoglPrimitive **primitive, + size_t *size) +{ + cairo_traps_t traps; + cairo_int_status_t status; + + _cairo_traps_init (&traps); + status = _cairo_path_fixed_fill_to_traps (path, fill_rule, tolerance, &traps); + if (unlikely (status)) + goto BAIL; + + if (traps.num_traps == 0) { + status = CAIRO_INT_STATUS_NOTHING_TO_DO; + goto BAIL; + } + + *size = traps.num_traps * sizeof (CoglVertexP2) * 6; + + *primitive = _cairo_cogl_traps_to_composite_prim (surface, &traps, n_layers, one_shot); + if (!*primitive) { + status = CAIRO_INT_STATUS_NO_MEMORY; + goto BAIL; + } + +BAIL: + _cairo_traps_fini (&traps); + return status; +} + +static void +_cairo_cogl_clip_push_box (const cairo_box_t *box) +{ + if (_cairo_box_is_pixel_aligned (box)) { + cairo_rectangle_int_t rect; + _cairo_box_round_to_rectangle (box, &rect); + cogl_clip_push_window_rectangle (rect.x, rect.y, + rect.width, rect.height); + } else { + double x1, y1, x2, y2; + _cairo_box_to_doubles (box, &x1, &y1, &x2, &y2); + cogl_clip_push_rectangle (x1, y1, x2, y2); + } +} + +static void +_cairo_cogl_journal_flush (cairo_cogl_surface_t *surface) +{ + GList *l; + int clip_stack_depth = 0; + int i; + + if (!surface->journal) + return; + + if (surface->buffer_stack && surface->buffer_stack_offset) { + cogl_buffer_unmap (COGL_BUFFER (surface->buffer_stack)); + cogl_object_unref (surface->buffer_stack); + surface->buffer_stack = NULL; + } + + cogl_set_framebuffer (surface->framebuffer); + + cogl_push_matrix (); + + for (l = surface->journal->head; l; l = l->next) { + cairo_cogl_journal_entry_t *entry = l->data; + + switch (entry->type) + { + case CAIRO_COGL_JOURNAL_ENTRY_TYPE_CLIP: { + cairo_cogl_journal_clip_entry_t *clip_entry = + (cairo_cogl_journal_clip_entry_t *)entry; + cairo_clip_path_t *path; +#if 0 + cairo_bool_t checked_for_primitives = FALSE; + cairo_cogl_clip_primitives_t *clip_primitives; +#endif + + for (i = 0; i < clip_stack_depth; i++) + cogl_clip_pop (); + clip_stack_depth = 0; + + for (path = clip_entry->clip->path, i = 0; path; path = path->prev, i++) { + cairo_rectangle_int_t extents; + cairo_int_status_t status; + CoglPrimitive *prim; + size_t prim_size; + + _cairo_path_fixed_approximate_clip_extents (&path->path, &extents); + + /* TODO - maintain a fifo of the last 10 used clips with cached + * primitives to see if we can avoid tessellating the path and + * uploading the vertices... + */ +#if 0 + if (!checked_for_primitives) { + clip_primitives = find_clip_primitives (clip); + checked_for_primitives = TRUE; + } + if (clip_primitives) + prim = clip_primitives->primitives[i]; +#endif + status = _cairo_cogl_fill_to_primitive (surface, + &path->path, + path->fill_rule, + path->tolerance, + 0, + TRUE, + &prim, + &prim_size); + if (unlikely (status)) { + g_warning ("Failed to get primitive for clip path while flushing journal"); + continue; + } + clip_stack_depth++; + cogl_clip_push_primitive (prim, + extents.x, extents.y, + extents.x + extents.width, + extents.y + extents.height); + cogl_object_unref (prim); + } + + for (i = 0; i < clip_entry->clip->num_boxes; i++) { + clip_stack_depth++; + _cairo_cogl_clip_push_box (&clip_entry->clip->boxes[i]); + } + + surface->n_clip_updates_per_frame++; + break; + } + case CAIRO_COGL_JOURNAL_ENTRY_TYPE_RECTANGLE: { + cairo_cogl_journal_rect_entry_t *rect_entry = + (cairo_cogl_journal_rect_entry_t *)entry; + float tex_coords[8]; + float x1 = rect_entry->x; + float y1 = rect_entry->y; + float x2 = rect_entry->x + rect_entry->width; + float y2 = rect_entry->y + rect_entry->height; + cairo_matrix_t *ctm = &rect_entry->ctm; + float ctmfv[16] = { + ctm->xx, ctm->yx, 0, 0, + ctm->xy, ctm->yy, 0, 0, + 0, 0, 1, 0, + ctm->x0, ctm->y0, 0, 1 + }; + CoglMatrix transform; + + cogl_matrix_init_from_array (&transform, ctmfv); + + if (rect_entry->n_layers) { + g_assert (rect_entry->n_layers <= 2); + tex_coords[0] = x1; + tex_coords[1] = y1; + tex_coords[2] = x2; + tex_coords[3] = y2; + if (rect_entry->n_layers > 1) + memcpy (&tex_coords[4], tex_coords, sizeof (float) * 4); + } + + cogl_set_source (rect_entry->pipeline); + cogl_push_matrix (); + cogl_transform (&transform); + cogl_rectangle_with_multitexture_coords (x1, y1, x2, y2, + tex_coords, 4 * rect_entry->n_layers); + cogl_pop_matrix (); + break; + } + case CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE: { + cairo_cogl_journal_prim_entry_t *prim_entry = + (cairo_cogl_journal_prim_entry_t *)entry; + CoglMatrix transform; + + cogl_push_matrix (); + if (prim_entry->has_transform) { + cairo_matrix_t *ctm = &prim_entry->transform; + float ctmfv[16] = { + ctm->xx, ctm->yx, 0, 0, + ctm->xy, ctm->yy, 0, 0, + 0, 0, 1, 0, + ctm->x0, ctm->y0, 0, 1 + }; + cogl_matrix_init_from_array (&transform, ctmfv); + cogl_transform (&transform); + } else { + cogl_matrix_init_identity (&transform); + cogl_set_modelview_matrix (&transform); + } + + cogl_set_source (prim_entry->pipeline); + cogl_primitive_draw (prim_entry->primitive); + cogl_pop_matrix (); + break; + } + case CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH: { + cairo_cogl_journal_path_entry_t *path_entry = + (cairo_cogl_journal_path_entry_t *)entry; + + cogl_set_source (path_entry->pipeline); + cogl_path_fill (path_entry->path); + break; + } + default: + assert (0); /* not reached! */ + } + } + + cogl_pop_matrix (); + + for (i = 0; i < clip_stack_depth; i++) + cogl_clip_pop (); + + _cairo_cogl_journal_discard (surface); +} + +static cairo_status_t +_cairo_cogl_surface_flush (void *abstract_surface, + unsigned flags) +{ + cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)abstract_surface; + + if (flags) + return CAIRO_STATUS_SUCCESS; + + _cairo_cogl_journal_flush (surface); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_cogl_surface_finish (void *abstract_surface) +{ + cairo_cogl_surface_t *surface = abstract_surface; + + if (surface->texture) + cogl_object_unref (surface->texture); + + if (surface->framebuffer) + cogl_object_unref (surface->framebuffer); + + if (surface->journal) + _cairo_cogl_journal_free (surface); + + /*XXX wtf */ + cairo_device_release (surface->base.device); + + return CAIRO_STATUS_SUCCESS; +} + +static CoglPixelFormat +get_cogl_format_from_cairo_format (cairo_format_t cairo_format); + +/* XXX: We often use RGBA format for onscreen framebuffers so make sure + * to handle CAIRO_FORMAT_INVALID sensibly */ +static cairo_format_t +get_cairo_format_from_cogl_format (CoglPixelFormat format) +{ + switch ((int)format) + { + case COGL_PIXEL_FORMAT_A_8: + return CAIRO_FORMAT_A8; + case COGL_PIXEL_FORMAT_RGB_565: + return CAIRO_FORMAT_RGB16_565; + + case COGL_PIXEL_FORMAT_BGRA_8888_PRE: + case COGL_PIXEL_FORMAT_ARGB_8888_PRE: + case COGL_PIXEL_FORMAT_RGBA_8888_PRE: + /* Note: this is ambiguous since CAIRO_FORMAT_RGB24 + * would also map to the same CoglPixelFormat */ + return CAIRO_FORMAT_ARGB32; + + default: + g_warning("bad format: %x a? %d, bgr? %d, pre %d, format: %d\n", + format, + format & COGL_A_BIT, + format & COGL_BGR_BIT, + format & COGL_PREMULT_BIT, + format & ~(COGL_A_BIT | COGL_BGR_BIT | COGL_PREMULT_BIT)); + return CAIRO_FORMAT_INVALID; + } +} + +static CoglPixelFormat +get_cogl_format_from_cairo_format (cairo_format_t cairo_format) +{ + switch (cairo_format) + { + case CAIRO_FORMAT_ARGB32: + case CAIRO_FORMAT_RGB24: +#if G_BYTE_ORDER == G_LITTLE_ENDIAN + return COGL_PIXEL_FORMAT_BGRA_8888_PRE; +#else + return COGL_PIXEL_FORMAT_ARGB_8888_PRE; +#endif + case CAIRO_FORMAT_A8: + return COGL_PIXEL_FORMAT_A_8; + case CAIRO_FORMAT_RGB16_565: + return COGL_PIXEL_FORMAT_RGB_565; + case CAIRO_FORMAT_INVALID: + case CAIRO_FORMAT_A1: + case CAIRO_FORMAT_RGB30: + return 0; + } + + g_warn_if_reached (); + return 0; +} + +static cairo_status_t +_cairo_cogl_surface_read_rect_to_image_surface (cairo_cogl_surface_t *surface, + cairo_rectangle_int_t *interest, + cairo_image_surface_t **image_out) +{ + cairo_image_surface_t *image; + cairo_status_t status; + cairo_format_t cairo_format; + CoglPixelFormat cogl_format; + + /* TODO: Add cogl_texture_get_region() API so we don't have to ensure the + * surface is bound to an fbo to read back pixels */ + status = _cairo_cogl_surface_ensure_framebuffer (surface); + if (unlikely (status)) + return status; + + cairo_format = get_cairo_format_from_cogl_format (surface->cogl_format); + if (cairo_format == CAIRO_FORMAT_INVALID) { + cairo_format = CAIRO_FORMAT_ARGB32; + cogl_format = get_cogl_format_from_cairo_format (cairo_format); + } else { + cogl_format = cogl_framebuffer_get_color_format (surface->framebuffer); + } + + image = (cairo_image_surface_t *) + cairo_image_surface_create (cairo_format, surface->width, surface->height); + if (image->base.status) + return image->base.status; + + /* TODO: Add cogl_framebuffer_read_pixels() API */ + cogl_push_framebuffer (surface->framebuffer); + cogl_read_pixels (0, 0, surface->width, surface->height, + COGL_READ_PIXELS_COLOR_BUFFER, + cogl_format, + image->data); + cogl_pop_framebuffer (); + + *image_out = image; + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_cogl_surface_acquire_source_image (void *abstract_surface, + cairo_image_surface_t **image_out, + void **image_extra) +{ + cairo_cogl_surface_t *surface = abstract_surface; + cairo_status_t status; + + if (surface->texture) { + cairo_format_t format = get_cairo_format_from_cogl_format (surface->cogl_format); + cairo_image_surface_t *image = (cairo_image_surface_t *) + cairo_image_surface_create (format, surface->width, surface->height); + if (image->base.status) + return image->base.status; + + cogl_texture_get_data (surface->texture, + cogl_texture_get_format (surface->texture), + 0, + image->data); + + image->base.is_clear = FALSE; + *image_out = image; + } else { + cairo_rectangle_int_t extents = { + 0, 0, surface->width, surface->height + }; + status = _cairo_cogl_surface_read_rect_to_image_surface (surface, &extents, + image_out); + if (unlikely (status)) + return status; + } + + *image_extra = NULL; + + return CAIRO_STATUS_SUCCESS; +} + +static void +_cairo_cogl_surface_release_source_image (void *abstract_surface, + cairo_image_surface_t *image, + void *image_extra) +{ + cairo_surface_destroy (&image->base); +} + +static cairo_status_t +_cairo_cogl_surface_clear (cairo_cogl_surface_t *surface, + const cairo_color_t *color) +{ + /* Anything batched in the journal up until now is redundant... */ + _cairo_cogl_journal_discard (surface); + + /* XXX: we currently implicitly clear the depth and stencil buffer here + * but since we use the framebuffer_discard extension when available I + * suppose this doesn't matter too much. + * + * The main concern is that we want to avoid re-loading an external z + * buffer at the start of each frame, but also many gpu architectures have + * optimizations for how they handle the depth/stencil buffers and can get + * upset if they aren't cleared together at the start of the frame. + * + * FIXME: we need a way to assert that the clip stack currently isn't + * using the stencil buffer before clearing it here! + */ + cogl_framebuffer_clear4f (surface->framebuffer, + COGL_BUFFER_BIT_COLOR | + COGL_BUFFER_BIT_DEPTH | + COGL_BUFFER_BIT_STENCIL, + color->red * color->alpha, + color->green * color->alpha, + color->blue * color->alpha, + color->alpha); + return CAIRO_STATUS_SUCCESS; +} + +cairo_status_t +_cairo_cogl_path_fixed_rectangle (cairo_path_fixed_t *path, + cairo_fixed_t x, + cairo_fixed_t y, + cairo_fixed_t width, + cairo_fixed_t height) +{ + cairo_status_t status; + + status = _cairo_path_fixed_move_to (path, x, y); + if (unlikely (status)) + return status; + + status = _cairo_path_fixed_rel_line_to (path, width, 0); + if (unlikely (status)) + return status; + + status = _cairo_path_fixed_rel_line_to (path, 0, height); + if (unlikely (status)) + return status; + + status = _cairo_path_fixed_rel_line_to (path, -width, 0); + if (unlikely (status)) + return status; + + status = _cairo_path_fixed_close_path (path); + if (unlikely (status)) + return status; + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +_cairo_cogl_surface_paint (void *abstract_surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_clip_t *clip) +{ + cairo_cogl_surface_t *surface; + cairo_path_fixed_t path; + cairo_status_t status; + cairo_matrix_t identity; + + if (clip == NULL) { + if (op == CAIRO_OPERATOR_CLEAR) + return _cairo_cogl_surface_clear (abstract_surface, CAIRO_COLOR_TRANSPARENT); + else if (source->type == CAIRO_PATTERN_TYPE_SOLID && + (op == CAIRO_OPERATOR_SOURCE || + (op == CAIRO_OPERATOR_OVER && (((cairo_surface_t *)abstract_surface)->is_clear || _cairo_pattern_is_opaque_solid (source))))) { + return _cairo_cogl_surface_clear (abstract_surface, + &((cairo_solid_pattern_t *) source)->color); + } + } + + /* fallback to handling the paint in terms of a fill... */ + + surface = abstract_surface; + + _cairo_path_fixed_init (&path); + + status = _cairo_cogl_path_fixed_rectangle (&path, 0, 0, surface->width, surface->height); + if (unlikely (status)) + goto BAIL; + +#ifdef NEED_COGL_CONTEXT + /* XXX: in cairo-cogl-context.c we set some sideband data on the + * surface before issuing a fill so we need to do that here too... */ + surface->user_path = &path; + cairo_matrix_init_identity (&identity); + surface->ctm = &identity; + surface->ctm_inverse = &identity; + surface->path_is_rectangle = TRUE; + surface->path_rectangle_x = 0; + surface->path_rectangle_y = 0; + surface->path_rectangle_width = surface->width; + surface->path_rectangle_height = surface->height; +#endif + + status = _cairo_cogl_surface_fill (abstract_surface, + op, + source, + &path, + CAIRO_FILL_RULE_WINDING, + 1, + CAIRO_ANTIALIAS_DEFAULT, + clip); +BAIL: + _cairo_path_fixed_fini (&path); + return status; +} + +static CoglPipelineWrapMode +get_cogl_wrap_mode_for_extend (cairo_extend_t extend_mode) +{ + switch (extend_mode) + { + case CAIRO_EXTEND_NONE: + return COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE; + case CAIRO_EXTEND_PAD: + return COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE; + case CAIRO_EXTEND_REPEAT: + return COGL_PIPELINE_WRAP_MODE_REPEAT; + case CAIRO_EXTEND_REFLECT: + /* TODO: return COGL_PIPELINE_WRAP_MODE_MIRROR; */ + return CAIRO_EXTEND_REPEAT; + } + assert (0); /* not reached */ + return COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE; +} + +#if 0 +/* Given an arbitrary texture, check if it's already a pot texture and simply + * return it back if so. If not create a new pot texture, scale the old to + * fill it, unref the old and return a pointer to the new pot texture. */ +static cairo_int_status_t +_cairo_cogl_get_pot_texture (CoglContext *context, + CoglTexture *texture, + CoglTexture **pot_texture) +{ + int width = cogl_texture_get_width (texture); + int height = cogl_texture_get_height (texture); + int pot_width; + int pot_height; + CoglHandle offscreen = NULL; + CoglTexture2D *pot = NULL; + GError *error; + + pot_width = _cairo_cogl_util_next_p2 (width); + pot_height = _cairo_cogl_util_next_p2 (height); + + if (pot_width == width && pot_height == height) + return CAIRO_INT_STATUS_SUCCESS; + + for (;;) { + error = NULL; + pot = cogl_texture_2d_new_with_size (context, + pot_width, + pot_height, + cogl_texture_get_format (texture), + &error); + if (pot) + break; + else + g_error_free (error); + + if (pot_width > pot_height) + pot_width >>= 1; + else + pot_height >>= 1; + + if (!pot_width || !pot_height) + break; + } + + *pot_texture = COGL_TEXTURE (pot); + + if (!pot) + return CAIRO_INT_STATUS_NO_MEMORY; + + /* Use the GPU to do a bilinear filtered scale from npot to pot... */ + offscreen = cogl_offscreen_new_to_texture (COGL_TEXTURE (pot)); + error = NULL; + if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen), &error)) { + /* NB: if we don't pass an error then Cogl is allowed to simply abort + * automatically. */ + g_error_free (error); + cogl_object_unref (pot); + *pot_texture = NULL; + return CAIRO_INT_STATUS_NO_MEMORY; + } + + cogl_push_framebuffer (COGL_FRAMEBUFFER (offscreen)); + cogl_set_source_texture (texture); + cogl_rectangle (-1, 1, 1, -1); + cogl_pop_framebuffer (); + + cogl_object_unref (offscreen); +} +#endif + +/* NB: a reference for the texture is transferred to the caller which should + * be unrefed */ +static CoglTexture * +_cairo_cogl_acquire_surface_texture (cairo_cogl_surface_t *reference_surface, + cairo_surface_t *abstract_surface) +{ + cairo_image_surface_t *image; + cairo_image_surface_t *acquired_image = NULL; + void *image_extra; + CoglPixelFormat format; + cairo_image_surface_t *image_clone = NULL; + CoglTexture2D *texture; + GError *error = NULL; + cairo_surface_t *clone; + + if (abstract_surface->device == reference_surface->base.device) { + cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)abstract_surface; + _cairo_cogl_surface_flush (surface, 0); + return surface->texture ? cogl_object_ref (surface->texture) : NULL; + } + + if (abstract_surface->type == CAIRO_SURFACE_TYPE_COGL) { + if (_cairo_surface_is_subsurface (abstract_surface)) { + cairo_cogl_surface_t *surface; + + surface = (cairo_cogl_surface_t *) + _cairo_surface_subsurface_get_target (abstract_surface); + if (surface->base.device == reference_surface->base.device) + return surface->texture ? cogl_object_ref (surface->texture) : NULL; + } + } + + clone = _cairo_surface_has_snapshot (abstract_surface, &_cairo_cogl_surface_backend); + if (clone) { + cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)clone; + return surface->texture ? cogl_object_ref (surface->texture) : NULL; + } + + g_warning ("Uploading image surface to texture"); + + if (_cairo_surface_is_image (abstract_surface)) { + image = (cairo_image_surface_t *)abstract_surface; + } else { + cairo_status_t status = _cairo_surface_acquire_source_image (abstract_surface, + &acquired_image, &image_extra); + if (unlikely (status)) { + g_warning ("acquire_source_image failed: %s [%d]\n", + cairo_status_to_string (status), status); + return NULL; + } + image = acquired_image; + } + + format = get_cogl_format_from_cairo_format (image->format); + if (!format) + { + image_clone = _cairo_image_surface_coerce (image); + if (unlikely (image_clone->base.status)) { + g_warning ("image_surface_coerce failed"); + texture = NULL; + goto BAIL; + } + + format = get_cogl_format_from_cairo_format (image_clone->format); + assert (format); + } + + texture = cogl_texture_2d_new_from_data (to_device(reference_surface->base.device)->cogl_context, + image->width, + image->height, + format, /* incoming */ + format, /* desired */ + image->stride, + image->data, + &error); + if (!texture) { + g_warning ("Failed to allocate texture: %s", error->message); + g_error_free (error); + goto BAIL; + } + + clone = _cairo_cogl_surface_create_full (to_device(reference_surface->base.device), + reference_surface->ignore_alpha, + NULL, COGL_TEXTURE (texture)); + + _cairo_surface_attach_snapshot (abstract_surface, clone, NULL); + + /* Attaching the snapshot will take a reference on the clone surface... */ + cairo_surface_destroy (clone); + +BAIL: + if (image_clone) + cairo_surface_destroy (&image_clone->base); + if (acquired_image) + _cairo_surface_release_source_image (abstract_surface, acquired_image, image_extra); + + return COGL_TEXTURE (texture); +} + +/* NB: a reference for the texture is transferred to the caller which should + * be unrefed */ +static CoglTexture * +_cairo_cogl_acquire_pattern_texture (const cairo_pattern_t *pattern, + cairo_cogl_surface_t *destination, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + cairo_cogl_texture_attributes_t *attributes) +{ + CoglTexture *texture = NULL; + + switch ((int)pattern->type) + { + case CAIRO_PATTERN_TYPE_SURFACE: { + cairo_surface_t *surface = ((cairo_surface_pattern_t *)pattern)->surface; + texture = _cairo_cogl_acquire_surface_texture (destination, surface); + if (!texture) + return NULL; + + /* XXX: determine if it would have no effect to change the + * extend mode to EXTEND_PAD instead since we can simply map + * EXTEND_PAD to CLAMP_TO_EDGE without needing fragment shader + * tricks or extra border texels. */ +#if 0 + /* TODO: We still need to consider HW such as SGX which doesn't have + * full support for NPOT textures. */ + if (pattern->extend == CAIRO_EXTEND_REPEAT || pattern->extend == CAIRO_EXTEND_REFLECT) { + _cairo_cogl_get_pot_texture (); + } +#endif + + cairo_matrix_init_identity (&attributes->matrix); + + /* Convert from un-normalized source coordinates in backend + * coordinates to normalized texture coordinates */ + cairo_matrix_scale (&attributes->matrix, + 1.0f / cogl_texture_get_width (texture), + 1.0f / cogl_texture_get_height (texture)); + + /* XXX: need to multiply in the pattern->matrix */ + + attributes->extend = pattern->extend; + attributes->filter = CAIRO_FILTER_BILINEAR; + attributes->has_component_alpha = pattern->has_component_alpha; + + attributes->s_wrap = get_cogl_wrap_mode_for_extend (pattern->extend); + attributes->t_wrap = attributes->s_wrap; + + return texture; + } + case CAIRO_PATTERN_TYPE_RADIAL: + case CAIRO_PATTERN_TYPE_MESH: { + cairo_surface_t *surface; + cairo_matrix_t texture_matrix; + + surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, + extents->width, extents->height); + if (_cairo_surface_offset_paint (surface, + extents->x, extents->y, + CAIRO_OPERATOR_SOURCE, + pattern, NULL)) { + cairo_surface_destroy (surface); + return NULL; + } + + texture = _cairo_cogl_acquire_surface_texture (destination, surface); + if (!texture) + goto BAIL; + + cairo_matrix_init_identity (&texture_matrix); + + /* Convert from un-normalized source coordinates in backend + * coordinates to normalized texture coordinates */ + cairo_matrix_scale (&texture_matrix, + 1.0f / cogl_texture_get_width (texture), + 1.0f / cogl_texture_get_height (texture)); + + cairo_matrix_translate (&texture_matrix, -extents->x, -extents->y); + + attributes->matrix = texture_matrix; + attributes->extend = pattern->extend; + attributes->filter = CAIRO_FILTER_NEAREST; + attributes->has_component_alpha = pattern->has_component_alpha; + + /* any pattern extend modes have already been dealt with... */ + attributes->s_wrap = COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE; + attributes->t_wrap = attributes->s_wrap; + +BAIL: + cairo_surface_destroy (surface); + + return texture; + } + case CAIRO_PATTERN_TYPE_LINEAR: { + cairo_linear_pattern_t *linear_pattern = (cairo_linear_pattern_t *)pattern; + cairo_cogl_linear_gradient_t *gradient; + cairo_cogl_linear_texture_entry_t *linear_texture; + cairo_int_status_t status; + float a, b; + float dist; + float scale; + float angle; + + status = _cairo_cogl_get_linear_gradient (to_device(destination->base.device), + pattern->extend, + linear_pattern->base.n_stops, + linear_pattern->base.stops, + &gradient); + if (unlikely (status)) + return NULL; + + linear_texture = _cairo_cogl_linear_gradient_texture_for_extend (gradient, pattern->extend); + + attributes->extend = pattern->extend; + attributes->filter = CAIRO_FILTER_BILINEAR; + attributes->has_component_alpha = pattern->has_component_alpha; + attributes->s_wrap = get_cogl_wrap_mode_for_extend (pattern->extend); + attributes->t_wrap = COGL_PIPELINE_WRAP_MODE_REPEAT; + + cairo_matrix_init_identity (&attributes->matrix); + + a = linear_pattern->pd2.x - linear_pattern->pd1.x; + b = linear_pattern->pd2.y - linear_pattern->pd1.y; + dist = sqrtf (a*a + b*b); + scale = 1.0f / dist; + angle = - atan2f (b, a); + + cairo_matrix_rotate (&attributes->matrix, angle); + cairo_matrix_scale (&attributes->matrix, scale, scale); + + cairo_matrix_translate (&attributes->matrix, + -linear_pattern->pd1.x, + -linear_pattern->pd1.y); + + /* XXX: this caught me out: cairo doesn't follow the standard + * maths convention for multiplying two matrices A x B - cairo + * does B x A so the final matrix is as if A's transforms were + * applied first. + */ + cairo_matrix_multiply (&attributes->matrix, + &pattern->matrix, + &attributes->matrix); + + return cogl_object_ref (linear_texture->texture); + } + default: + g_warning ("Un-supported source type"); + return NULL; + } +} + +static void +set_layer_texture_with_attributes (CoglPipeline *pipeline, + int layer_index, + CoglTexture *texture, + cairo_cogl_texture_attributes_t *attributes) +{ + cogl_pipeline_set_layer_texture (pipeline, layer_index, texture); + + if (!_cairo_matrix_is_identity (&attributes->matrix)) { + cairo_matrix_t *m = &attributes->matrix; + float texture_matrixfv[16] = { + m->xx, m->yx, 0, 0, + m->xy, m->yy, 0, 0, + 0, 0, 1, 0, + m->x0, m->y0, 0, 1 + }; + CoglMatrix texture_matrix; + cogl_matrix_init_from_array (&texture_matrix, texture_matrixfv); + cogl_pipeline_set_layer_matrix (pipeline, layer_index, &texture_matrix); + } + + if (attributes->s_wrap != attributes->t_wrap) { + cogl_pipeline_set_layer_wrap_mode_s (pipeline, layer_index, attributes->s_wrap); + cogl_pipeline_set_layer_wrap_mode_t (pipeline, layer_index, attributes->t_wrap); + } else + cogl_pipeline_set_layer_wrap_mode (pipeline, layer_index, attributes->s_wrap); +} + +static CoglPipeline * +get_source_mask_operator_destination_pipeline (const cairo_pattern_t *mask, + const cairo_pattern_t *source, + cairo_operator_t op, + cairo_cogl_surface_t *destination, + cairo_composite_rectangles_t *extents) +{ + cairo_cogl_template_type template_type; + CoglPipeline *pipeline; + + switch ((int)source->type) + { + case CAIRO_PATTERN_TYPE_SOLID: + template_type = mask ? + CAIRO_COGL_TEMPLATE_TYPE_MASK_SOLID : CAIRO_COGL_TEMPLATE_TYPE_SOLID; + break; + case CAIRO_PATTERN_TYPE_SURFACE: + case CAIRO_PATTERN_TYPE_LINEAR: + case CAIRO_PATTERN_TYPE_RADIAL: + case CAIRO_PATTERN_TYPE_MESH: + template_type = mask ? + CAIRO_COGL_TEMPLATE_TYPE_MASK_TEXTURE : CAIRO_COGL_TEMPLATE_TYPE_TEXTURE; + break; + default: + g_warning ("Un-supported source type"); + return NULL; + } + + pipeline = cogl_pipeline_copy (to_device(destination->base.device)->template_pipelines[op][template_type]); + + if (source->type == CAIRO_PATTERN_TYPE_SOLID) { + cairo_solid_pattern_t *solid_pattern = (cairo_solid_pattern_t *)source; + cogl_pipeline_set_color4f (pipeline, + solid_pattern->color.red * solid_pattern->color.alpha, + solid_pattern->color.green * solid_pattern->color.alpha, + solid_pattern->color.blue * solid_pattern->color.alpha, + solid_pattern->color.alpha); + } else { + cairo_cogl_texture_attributes_t attributes; + CoglTexture *texture = + _cairo_cogl_acquire_pattern_texture (source, destination, + &extents->bounded, + &extents->source_sample_area, + &attributes); + if (!texture) + goto BAIL; + set_layer_texture_with_attributes (pipeline, 0, texture, &attributes); + cogl_object_unref (texture); + } + + if (mask) { + if (mask->type == CAIRO_PATTERN_TYPE_SOLID) { + cairo_solid_pattern_t *solid_pattern = (cairo_solid_pattern_t *)mask; + CoglColor color; + cogl_color_init_from_4f (&color, + solid_pattern->color.red * solid_pattern->color.alpha, + solid_pattern->color.green * solid_pattern->color.alpha, + solid_pattern->color.blue * solid_pattern->color.alpha, + solid_pattern->color.alpha); + cogl_pipeline_set_layer_combine_constant (pipeline, 1, &color); + } else { + cairo_cogl_texture_attributes_t attributes; + CoglTexture *texture = + _cairo_cogl_acquire_pattern_texture (mask, destination, + &extents->bounded, + &extents->mask_sample_area, + &attributes); + if (!texture) + goto BAIL; + set_layer_texture_with_attributes (pipeline, 1, texture, &attributes); + cogl_object_unref (texture); + } + } + + return pipeline; + +BAIL: + cogl_object_unref (pipeline); + return NULL; +} + +#if 0 +CoglPrimitive * +_cairo_cogl_rectangle_new_p2t2t2 (float x, + float y, + float width, + float height) +{ + CoglVertexP2 vertices[] = { + {x, y}, {x, y + height}, {x + width, y + height}, + {x, y}, {x + width, y + height}, {x + width, y} + }; + CoglAttributeBuffer *buffer = cogl_attribute_buffer_new (sizeof (vertices)); + CoglAttribute *pos = cogl_attribute_new (buffer, + "cogl_position_in", + sizeof (CoglVertexP2), + 0, + 2, + COGL_ATTRIBUTE_TYPE_FLOAT); + CoglAttribute *tex_coords0 = cogl_attribute_new (buffer, + "cogl_tex_coord0_in", + sizeof (CoglVertexP2), + 0, + 2, + COGL_ATTRIBUTE_TYPE_FLOAT); + CoglAttribute *tex_coords0 = cogl_attribute_new (buffer, + "cogl_tex_coord0_in", + sizeof (CoglVertexP2), + 0, + 2, + COGL_ATTRIBUTE_TYPE_FLOAT); + CoglPrimitive *prim; + + cogl_buffer_set_data (COGL_BUFFER (buffer), 0, vertices, sizeof (vertices)); + + /* The attributes will now keep the buffer alive... */ + cogl_object_unref (buffer); + + prim = cogl_primitive_new (COGL_VERTICES_MODE_TRIANGLES, + 6, pos, tex_coords, NULL); + + /* The primitive will now keep the attribute alive... */ + cogl_object_unref (pos); + + return prim; +} +#endif + +static void +_cairo_cogl_log_clip (cairo_cogl_surface_t *surface, + const cairo_clip_t *clip) +{ + if (!_cairo_clip_equal (clip, surface->last_clip)) { + _cairo_cogl_journal_log_clip (surface, clip); + _cairo_clip_destroy (surface->last_clip); + surface->last_clip = _cairo_clip_copy (clip); + } +} + +static void +_cairo_cogl_maybe_log_clip (cairo_cogl_surface_t *surface, + cairo_composite_rectangles_t *composite) +{ + cairo_clip_t *clip = composite->clip; + + if (_cairo_composite_rectangles_can_reduce_clip (composite, clip)) + clip = NULL; + + if (clip == NULL) { + if (_cairo_composite_rectangles_can_reduce_clip (composite, + surface->last_clip)) + return; + } + + _cairo_cogl_log_clip (surface, clip); +} + +static cairo_bool_t +is_operator_supported (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 cairo_int_status_t +_cairo_cogl_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_cogl_surface_t *surface = abstract_surface; + cairo_composite_rectangles_t extents; + cairo_status_t status; + CoglPipeline *pipeline; + cairo_matrix_t identity; + + /* XXX: Use this to smoke test the acquire_source/dest_image fallback + * paths... */ + //return CAIRO_INT_STATUS_UNSUPPORTED; + + if (!is_operator_supported (op)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + status = _cairo_composite_rectangles_init_for_mask (&extents, + &surface->base, + op, source, mask, clip); + if (unlikely (status)) + return status; + + pipeline = get_source_mask_operator_destination_pipeline (mask, source, + op, surface, &extents); + if (!pipeline){ + status = CAIRO_INT_STATUS_UNSUPPORTED; + goto BAIL; + } + + _cairo_cogl_maybe_log_clip (surface, &extents); + + cairo_matrix_init_identity (&identity); + _cairo_cogl_journal_log_rectangle (surface, pipeline, + extents.bounded.x, + extents.bounded.y, + extents.bounded.width, + extents.bounded.height, + 2, + &identity); + + /* The journal will take a reference on the pipeline and clip_path... */ + cogl_object_unref (pipeline); + +BAIL: + return status; +} + +static int +_cairo_cogl_source_n_layers (const cairo_pattern_t *source) +{ + switch ((int)source->type) + { + case CAIRO_PATTERN_TYPE_SOLID: + return 0; + case CAIRO_PATTERN_TYPE_LINEAR: + case CAIRO_PATTERN_TYPE_RADIAL: + case CAIRO_PATTERN_TYPE_MESH: + case CAIRO_PATTERN_TYPE_SURFACE: + return 1; + default: + g_warning ("Unsupported source type"); + return 0; + } +} + +static cairo_bool_t +_cairo_cogl_path_fill_meta_equal (const void *key_a, const void *key_b) +{ + const cairo_cogl_path_fill_meta_t *meta0 = key_a; + const cairo_cogl_path_fill_meta_t *meta1 = key_b; + + return _cairo_path_fixed_equal (meta0->user_path, meta1->user_path); +} + +static cairo_bool_t +_cairo_cogl_stroke_style_equal (const cairo_stroke_style_t *a, + const cairo_stroke_style_t *b) +{ + if (a->line_width == b->line_width && + a->line_cap == b->line_cap && + a->line_join == b->line_join && + a->miter_limit == b->miter_limit && + a->num_dashes == b->num_dashes && + a->dash_offset == b->dash_offset) + { + unsigned int i; + for (i = 0; i < a->num_dashes; i++) { + if (a->dash[i] != b->dash[i]) + return FALSE; + } + } + return TRUE; +} + +static cairo_bool_t +_cairo_cogl_path_stroke_meta_equal (const void *key_a, const void *key_b) +{ + const cairo_cogl_path_stroke_meta_t *meta0 = key_a; + const cairo_cogl_path_stroke_meta_t *meta1 = key_b; + + return _cairo_cogl_stroke_style_equal (&meta0->style, &meta1->style) && + _cairo_path_fixed_equal (meta0->user_path, meta1->user_path); +} + +static cairo_cogl_path_stroke_meta_t * +_cairo_cogl_path_stroke_meta_reference (cairo_cogl_path_stroke_meta_t *meta) +{ + assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&meta->ref_count)); + + _cairo_reference_count_inc (&meta->ref_count); + + return meta; +} + +static void +_cairo_cogl_path_stroke_meta_destroy (cairo_cogl_path_stroke_meta_t *meta) +{ + assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&meta->ref_count)); + + if (! _cairo_reference_count_dec_and_test (&meta->ref_count)) + return; + + _cairo_path_fixed_fini (meta->user_path); + free (meta->user_path); + + _cairo_stroke_style_fini (&meta->style); + + if (meta->prim) + cogl_object_unref (meta->prim); + + free (meta); +} + +static cairo_cogl_path_stroke_meta_t * +_cairo_cogl_path_stroke_meta_lookup (cairo_cogl_device_t *ctx, + unsigned long hash, + cairo_path_fixed_t *user_path, + const cairo_stroke_style_t *style, + double tolerance) +{ + cairo_cogl_path_stroke_meta_t *ret; + cairo_cogl_path_stroke_meta_t lookup; + + lookup.cache_entry.hash = hash; + lookup.user_path = user_path; + lookup.style = *style; + lookup.tolerance = tolerance; + + ret = _cairo_cache_lookup (&ctx->path_stroke_staging_cache, &lookup.cache_entry); + if (!ret) + ret = _cairo_cache_lookup (&ctx->path_stroke_prim_cache, &lookup.cache_entry); + return ret; +} + +static void +_cairo_cogl_path_stroke_meta_set_prim_size (cairo_cogl_surface_t *surface, + cairo_cogl_path_stroke_meta_t *meta, + size_t size) +{ + /* now that we know the meta structure is associated with a primitive + * we promote it from the staging cache into the primitive cache. + */ + + /* XXX: _cairo_cache borks if you try and remove an entry that's already + * been evicted so we explicitly look it up first... */ + if (_cairo_cache_lookup (&to_device(surface->base.device)->path_stroke_staging_cache, &meta->cache_entry)) { + _cairo_cogl_path_stroke_meta_reference (meta); + _cairo_cache_remove (&to_device(surface->base.device)->path_stroke_staging_cache, &meta->cache_entry); + } + + meta->cache_entry.size = size; + if (_cairo_cache_insert (&to_device(surface->base.device)->path_stroke_prim_cache, &meta->cache_entry) != + CAIRO_STATUS_SUCCESS) + _cairo_cogl_path_stroke_meta_destroy (meta); +} + +static unsigned int +_cairo_cogl_stroke_style_hash (unsigned int hash, + const cairo_stroke_style_t *style) +{ + unsigned int i; + hash = _cairo_hash_bytes (hash, &style->line_width, sizeof (style->line_width)); + hash = _cairo_hash_bytes (hash, &style->line_cap, sizeof (style->line_cap)); + hash = _cairo_hash_bytes (hash, &style->line_join, sizeof (style->line_join)); + hash = _cairo_hash_bytes (hash, &style->miter_limit, sizeof (style->miter_limit)); + hash = _cairo_hash_bytes (hash, &style->num_dashes, sizeof (style->num_dashes)); + hash = _cairo_hash_bytes (hash, &style->dash_offset, sizeof (style->dash_offset)); + for (i = 0; i < style->num_dashes; i++) + hash = _cairo_hash_bytes (hash, &style->dash[i], sizeof (double)); + return hash; +} + +static cairo_cogl_path_stroke_meta_t * +_cairo_cogl_get_path_stroke_meta (cairo_cogl_surface_t *surface, + const cairo_stroke_style_t *style, + double tolerance) +{ + unsigned long hash; + cairo_cogl_path_stroke_meta_t *meta = NULL; + cairo_path_fixed_t *meta_path = NULL; + cairo_status_t status; + + if (!surface->user_path) + return NULL; + + hash = _cairo_path_fixed_hash (surface->user_path); + hash = _cairo_cogl_stroke_style_hash (hash, style); + hash = _cairo_hash_bytes (hash, &tolerance, sizeof (tolerance)); + + meta = _cairo_cogl_path_stroke_meta_lookup (to_device(surface->base.device), hash, + surface->user_path, style, tolerance); + if (meta) + return meta; + + meta = calloc (1, sizeof (cairo_cogl_path_stroke_meta_t)); + if (!meta) + goto BAIL; + CAIRO_REFERENCE_COUNT_INIT (&meta->ref_count, 1); + meta->cache_entry.hash = hash; + meta->counter = 0; + meta_path = malloc (sizeof (cairo_path_fixed_t)); + if (!meta_path) + goto BAIL; + /* FIXME: we should add a ref-counted wrapper for our user_paths + * so we don't have to keep copying them here! */ + status = _cairo_path_fixed_init_copy (meta_path, surface->user_path); + if (unlikely (status)) + goto BAIL; + meta->user_path = meta_path; + meta->ctm_inverse = *surface->ctm_inverse; + + status = _cairo_stroke_style_init_copy (&meta->style, style); + if (unlikely (status)) { + _cairo_path_fixed_fini (meta_path); + goto BAIL; + } + meta->tolerance = tolerance; + + return meta; + +BAIL: + free (meta_path); + free (meta); + return NULL; +} + +static cairo_int_status_t +_cairo_cogl_stroke_to_primitive (cairo_cogl_surface_t *surface, + 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, + int n_layers, + cairo_bool_t one_shot, + CoglPrimitive **primitive, + size_t *size) +{ + cairo_traps_t traps; + cairo_int_status_t status; + + _cairo_traps_init (&traps); + + status = _cairo_path_fixed_stroke_polygon_to_traps (path, style, + ctm, ctm_inverse, + tolerance, + &traps); + if (unlikely (status)) + goto BAIL; + + if (traps.num_traps == 0) { + status = CAIRO_INT_STATUS_NOTHING_TO_DO; + goto BAIL; + } + + *size = traps.num_traps * sizeof (CoglVertexP2) * 6; + + //g_print ("new stroke prim\n"); + *primitive = _cairo_cogl_traps_to_composite_prim (surface, &traps, n_layers, one_shot); + if (!*primitive) { + status = CAIRO_INT_STATUS_NO_MEMORY; + goto BAIL; + } + +BAIL: + _cairo_traps_fini (&traps); + return status; +} + +static cairo_int_status_t +_cairo_cogl_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_cogl_surface_t *surface = (cairo_cogl_surface_t *)abstract_surface; + cairo_composite_rectangles_t extents; + CoglPipeline *pipeline; + cairo_status_t status; +#ifdef ENABLE_PATH_CACHE + cairo_cogl_path_stroke_meta_t *meta = NULL; + cairo_matrix_t transform_matrix; +#endif + cairo_matrix_t *transform = NULL; + gboolean one_shot = TRUE; + CoglPrimitive *prim = NULL; + cairo_bool_t new_prim = FALSE; + + if (! is_operator_supported (op)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + /* FIXME - support unbounded operators */ + if (!_cairo_operator_bounded_by_mask (op)) { + /* Currently IN this is the only unbounded operator we aim to support + * in cairo-cogl. */ + assert (op == CAIRO_OPERATOR_IN); + g_warning ("FIXME: handle stroking with unbounded operators!"); + return CAIRO_INT_STATUS_UNSUPPORTED; + } + + status = _cairo_composite_rectangles_init_for_stroke (&extents, + &surface->base, + op, source, path, + style, + ctm, + clip); + if (unlikely (status)) + return status; + +#ifdef ENABLE_PATH_CACHE + /* FIXME: we are currently leaking the meta state if we don't reach + * the cache_insert at the end. */ + meta = _cairo_cogl_get_path_stroke_meta (surface, style, tolerance); + if (meta) { + prim = meta->prim; + if (prim) { + cairo_matrix_multiply (&transform_matrix, &meta->ctm_inverse, surface->ctm); + transform = &transform_matrix; + } else if (meta->counter++ > 10) + one_shot = FALSE; + } +#endif + + if (!prim) { + int n_layers = _cairo_cogl_source_n_layers (source); + size_t prim_size = 0; + status = _cairo_cogl_stroke_to_primitive (surface, path, style, + ctm, ctm_inverse, tolerance, + n_layers, one_shot, + &prim, &prim_size); + if (unlikely (status)) + return status; + new_prim = TRUE; +#if defined (ENABLE_PATH_CACHE) + if (meta) { + meta->prim = cogl_object_ref (prim); + _cairo_cogl_path_stroke_meta_set_prim_size (surface, meta, prim_size); + } +#endif + } + + pipeline = get_source_mask_operator_destination_pipeline (NULL, source, + op, surface, &extents); + if (!pipeline) + return CAIRO_INT_STATUS_UNSUPPORTED; + + _cairo_cogl_maybe_log_clip (surface, &extents); + + _cairo_cogl_journal_log_primitive (surface, pipeline, prim, transform); + + /* The journal will take a reference on the pipeline and primitive... */ + cogl_object_unref (pipeline); + if (new_prim) + cogl_object_unref (prim); + + return CAIRO_INT_STATUS_SUCCESS; +} + +static cairo_cogl_path_fill_meta_t * +_cairo_cogl_path_fill_meta_reference (cairo_cogl_path_fill_meta_t *meta) +{ + assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&meta->ref_count)); + + _cairo_reference_count_inc (&meta->ref_count); + + return meta; +} + +static void +_cairo_cogl_path_fill_meta_destroy (cairo_cogl_path_fill_meta_t *meta) +{ + assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&meta->ref_count)); + + if (! _cairo_reference_count_dec_and_test (&meta->ref_count)) + return; + + _cairo_path_fixed_fini (meta->user_path); + free (meta->user_path); + + if (meta->prim) + cogl_object_unref (meta->prim); + + free (meta); +} + +static cairo_cogl_path_fill_meta_t * +_cairo_cogl_path_fill_meta_lookup (cairo_cogl_device_t *ctx, + unsigned long hash, + cairo_path_fixed_t *user_path) +{ + cairo_cogl_path_fill_meta_t *ret; + cairo_cogl_path_fill_meta_t lookup; + + lookup.cache_entry.hash = hash; + lookup.user_path = user_path; + + ret = _cairo_cache_lookup (&ctx->path_fill_staging_cache, &lookup.cache_entry); + if (!ret) + ret = _cairo_cache_lookup (&ctx->path_fill_prim_cache, &lookup.cache_entry); + return ret; +} + +static void +_cairo_cogl_path_fill_meta_set_prim_size (cairo_cogl_surface_t *surface, + cairo_cogl_path_fill_meta_t *meta, + size_t size) +{ + /* now that we know the meta structure is associated with a primitive + * we promote it from the staging cache into the primitive cache. + */ + + /* XXX: _cairo_cache borks if you try and remove an entry that's already + * been evicted so we explicitly look it up first... */ + if (_cairo_cache_lookup (&to_device(surface->base.device)->path_fill_staging_cache, &meta->cache_entry)) { + _cairo_cogl_path_fill_meta_reference (meta); + _cairo_cache_remove (&to_device(surface->base.device)->path_fill_staging_cache, &meta->cache_entry); + } + + meta->cache_entry.size = size; + if (_cairo_cache_insert (&to_device(surface->base.device)->path_fill_prim_cache, &meta->cache_entry) != + CAIRO_STATUS_SUCCESS) + _cairo_cogl_path_fill_meta_destroy (meta); +} + +static cairo_cogl_path_fill_meta_t * +_cairo_cogl_get_path_fill_meta (cairo_cogl_surface_t *surface) +{ + unsigned long hash; + cairo_cogl_path_fill_meta_t *meta = NULL; + cairo_path_fixed_t *meta_path = NULL; + cairo_status_t status; + + if (!surface->user_path) + return NULL; + + hash = _cairo_path_fixed_hash (surface->user_path); + + meta = _cairo_cogl_path_fill_meta_lookup (to_device(surface->base.device), + hash, surface->user_path); + if (meta) + return meta; + + meta = calloc (1, sizeof (cairo_cogl_path_fill_meta_t)); + if (!meta) + goto BAIL; + meta->cache_entry.hash = hash; + meta->counter = 0; + CAIRO_REFERENCE_COUNT_INIT (&meta->ref_count, 1); + meta_path = malloc (sizeof (cairo_path_fixed_t)); + if (!meta_path) + goto BAIL; + /* FIXME: we should add a ref-counted wrapper for our user_paths + * so we don't have to keep copying them here! */ + status = _cairo_path_fixed_init_copy (meta_path, surface->user_path); + if (unlikely (status)) + goto BAIL; + meta->user_path = meta_path; + meta->ctm_inverse = *surface->ctm_inverse; + + /* To start with - until we associate a CoglPrimitive with the meta + * structure - we keep the meta in a staging structure until we + * see whether it actually gets re-used. */ + meta->cache_entry.size = 1; + if (_cairo_cache_insert (&to_device(surface->base.device)->path_fill_staging_cache, &meta->cache_entry) != + CAIRO_STATUS_SUCCESS) + _cairo_cogl_path_fill_meta_destroy (meta); + + return meta; + +BAIL: + free (meta_path); + free (meta); + return NULL; +} + +static cairo_int_status_t +_cairo_cogl_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_cogl_surface_t *surface = abstract_surface; + cairo_composite_rectangles_t extents; + cairo_status_t status; +#ifdef ENABLE_PATH_CACHE + cairo_cogl_path_fill_meta_t *meta = NULL; + cairo_matrix_t transform_matrix; +#endif + cairo_matrix_t *transform = NULL; + cairo_bool_t one_shot = TRUE; + CoglPrimitive *prim = NULL; + cairo_bool_t new_prim = FALSE; + CoglPipeline *pipeline; + + if (! is_operator_supported (op)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + /* FIXME - support unbounded operators */ + if (!_cairo_operator_bounded_by_mask (op)) { + /* Currently IN this is the only unbounded operator we aim to support + * in cairo-cogl. */ + assert (op == CAIRO_OPERATOR_IN); + g_warning ("FIXME: handle filling with unbounded operators!"); + return CAIRO_INT_STATUS_UNSUPPORTED; + } + + status = _cairo_composite_rectangles_init_for_fill (&extents, + &surface->base, + op, source, path, + clip); + if (unlikely (status)) + return status; + +#ifndef FILL_WITH_COGL_PATH +#ifdef ENABLE_PATH_CACHE + meta = _cairo_cogl_get_path_fill_meta (surface); + if (meta) { + prim = meta->prim; + if (prim) { + cairo_matrix_multiply (&transform_matrix, &meta->ctm_inverse, surface->ctm); + transform = &transform_matrix; + } else if (meta->counter++ > 10) + one_shot = FALSE; + } +#endif /* ENABLE_PATH_CACHE */ + + if (!prim) { + int n_layers = _cairo_cogl_source_n_layers (source); + size_t prim_size; + status = _cairo_cogl_fill_to_primitive (surface, path, fill_rule, tolerance, + one_shot, n_layers, &prim, &prim_size); + if (unlikely (status)) + return status; + new_prim = TRUE; +#ifdef ENABLE_PATH_CACHE + if (meta) { + meta->prim = cogl_object_ref (prim); + _cairo_cogl_path_fill_meta_set_prim_size (surface, meta, prim_size); + } +#endif /* ENABLE_PATH_CACHE */ + } + +#endif /* !FILL_WITH_COGL_PATH */ + + pipeline = get_source_mask_operator_destination_pipeline (NULL, source, + op, surface, &extents); + if (!pipeline) + return CAIRO_INT_STATUS_UNSUPPORTED; + + _cairo_cogl_maybe_log_clip (surface, &extents); + +#ifndef FILL_WITH_COGL_PATH + _cairo_cogl_journal_log_primitive (surface, pipeline, prim, transform); + /* The journal will take a reference on the prim */ + if (new_prim) + cogl_object_unref (prim); +#else + CoglPath * cogl_path = _cairo_cogl_util_path_from_cairo (path, fill_rule, tolerance); + _cairo_cogl_journal_log_path (surface, pipeline, cogl_path); + cogl_object_unref (cogl_path); +#endif + + /* The journal will take a reference on the pipeline... */ + cogl_object_unref (pipeline); + + return CAIRO_INT_STATUS_SUCCESS; +} + +cairo_int_status_t +_cairo_cogl_surface_fill_rectangle (void *abstract_surface, + cairo_operator_t op, + const cairo_pattern_t *source, + double x, + double y, + double width, + double height, + cairo_matrix_t *ctm, + const cairo_clip_t *clip) +{ + cairo_cogl_surface_t *surface = abstract_surface; + CoglPipeline *pipeline; + + if (! is_operator_supported (op)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + /* FIXME - support unbounded operators */ + if (!_cairo_operator_bounded_by_mask (op)) { + /* Currently IN this is the only unbounded operator we aim to support + * in cairo-cogl. */ + assert (op == CAIRO_OPERATOR_IN); + g_warning ("FIXME: handle filling with unbounded operators!"); + return CAIRO_INT_STATUS_UNSUPPORTED; + } + + /* FIXME */ +#if 0 + status = _cairo_composite_rectangles_init_for_fill_rectangle (&extents, + &surface->base, + op, source, path, + clip); + if (unlikely (status)) + return status; +#endif + + if (source->type == CAIRO_PATTERN_TYPE_SOLID) { + double x1 = x; + double y1 = y; + double x2 = x1 + width; + double y2 = y1 + height; + + pipeline = get_source_mask_operator_destination_pipeline (NULL, source, + op, surface, NULL); + if (!pipeline) + return CAIRO_INT_STATUS_UNSUPPORTED; + + _cairo_cogl_log_clip (surface, clip); + + _cairo_cogl_journal_log_rectangle (surface, + pipeline, + x1, y1, x2, y2, + 0, + ctm); + return CAIRO_INT_STATUS_SUCCESS; + } else + return CAIRO_INT_STATUS_UNSUPPORTED; + + /* TODO: + * We need to acquire the textures here, look at the corresponding + * attributes and see if this can be trivially handled by logging + * a textured rectangle only needing simple scaling or translation + * of texture coordinates. + * + * At this point we should also aim to remap the default + * EXTEND_NONE mode to EXTEND_PAD which is more efficient if we + * know it makes no difference either way since we can map that to + * CLAMP_TO_EDGE. + */ +} + +static cairo_int_status_t +_cairo_cogl_surface_show_glyphs (void *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) +{ + return CAIRO_INT_STATUS_UNSUPPORTED; +} + +const cairo_surface_backend_t _cairo_cogl_surface_backend = { + CAIRO_SURFACE_TYPE_COGL, + _cairo_cogl_surface_finish, +#ifdef NEED_COGL_CONTEXT + _cairo_cogl_context_create, +#else + _cairo_default_context_create, +#endif + + _cairo_cogl_surface_create_similar, + NULL, /* create similar image */ + NULL, /* map to image */ + NULL, /* unmap image */ + + _cairo_surface_default_source, + _cairo_cogl_surface_acquire_source_image, + _cairo_cogl_surface_release_source_image, + NULL, /* snapshot */ + + NULL, /* copy_page */ + NULL, /* show_page */ + + _cairo_cogl_surface_get_extents, + NULL, /* get_font_options */ + + _cairo_cogl_surface_flush, /* flush */ + NULL, /* mark_dirty_rectangle */ + + _cairo_cogl_surface_paint, + _cairo_cogl_surface_mask, + _cairo_cogl_surface_stroke, + _cairo_cogl_surface_fill, + NULL, /* fill_stroke*/ + _cairo_surface_fallback_glyphs, +}; + +static cairo_surface_t * +_cairo_cogl_surface_create_full (cairo_cogl_device_t *dev, + cairo_bool_t ignore_alpha, + CoglFramebuffer *framebuffer, + CoglTexture *texture) +{ + cairo_cogl_surface_t *surface; + cairo_status_t status; + + status = cairo_device_acquire (&dev->base); + if (unlikely (status)) + return _cairo_surface_create_in_error (status); + + surface = malloc (sizeof (cairo_cogl_surface_t)); + if (unlikely (surface == NULL)) + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + + surface->ignore_alpha = ignore_alpha; + + surface->framebuffer = framebuffer; + if (framebuffer) { + surface->width = cogl_framebuffer_get_width (framebuffer); + surface->height = cogl_framebuffer_get_height (framebuffer); + surface->cogl_format = cogl_framebuffer_get_color_format (framebuffer); + cogl_object_ref (framebuffer); + } + + /* FIXME: If texture == NULL and we are given an offscreen framebuffer + * then we want a way to poke inside the framebuffer to get a texture */ + surface->texture = texture; + if (texture) { + if (!framebuffer) { + surface->width = cogl_texture_get_width (texture); + surface->height = cogl_texture_get_height (texture); + surface->cogl_format = cogl_texture_get_format (texture); + } + cogl_object_ref (texture); + } + + assert(surface->width && surface->height); + + surface->journal = NULL; + + surface->buffer_stack = NULL; + surface->buffer_stack_size = 4096; + + surface->last_clip = NULL; + + surface->n_clip_updates_per_frame = 0; + + _cairo_surface_init (&surface->base, + &_cairo_cogl_surface_backend, + &dev->base, + CAIRO_CONTENT_COLOR_ALPHA); + + return &surface->base; +} + +cairo_surface_t * +cairo_cogl_surface_create (cairo_device_t *abstract_device, + CoglFramebuffer *framebuffer) +{ + cairo_cogl_device_t *dev = (cairo_cogl_device_t *)abstract_device; + + if (abstract_device == NULL) + return _cairo_surface_create_in_error (CAIRO_STATUS_DEVICE_ERROR); + + if (abstract_device->status) + return _cairo_surface_create_in_error (abstract_device->status); + + if (abstract_device->backend->type != CAIRO_DEVICE_TYPE_COGL) + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); + + return _cairo_cogl_surface_create_full (dev, FALSE, framebuffer, NULL); +} +slim_hidden_def (cairo_cogl_surface_create); + +CoglFramebuffer * +cairo_cogl_surface_get_framebuffer (cairo_surface_t *abstract_surface) +{ + cairo_cogl_surface_t *surface; + + if (abstract_surface->backend != &_cairo_cogl_surface_backend) { + _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); + return NULL; + } + + surface = (cairo_cogl_surface_t *) abstract_surface; + + return surface->framebuffer; +} +slim_hidden_def (cairo_cogl_surface_get_framebuffer); + +CoglTexture * +cairo_cogl_surface_get_texture (cairo_surface_t *abstract_surface) +{ + cairo_cogl_surface_t *surface; + + if (abstract_surface->backend != &_cairo_cogl_surface_backend) { + _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); + return NULL; + } + + surface = (cairo_cogl_surface_t *) abstract_surface; + + return surface->texture; +} +slim_hidden_def (cairo_cogl_surface_get_texture); + +static cairo_status_t +_cairo_cogl_device_flush (void *device) +{ + cairo_status_t status; + + status = cairo_device_acquire (device); + if (unlikely (status)) + return status; + + /* XXX: we don't need to flush Cogl here, we just need to flush + * any batching we do of compositing primitives. */ + + cairo_device_release (device); + + return CAIRO_STATUS_SUCCESS; +} + +static void +_cairo_cogl_device_finish (void *device) +{ + cairo_status_t status; + + status = cairo_device_acquire (device); + if (unlikely (status)) + return; + + /* XXX: Drop references to external resources */ + + cairo_device_release (device); +} + +static void +_cairo_cogl_device_destroy (void *device) +{ + cairo_cogl_device_t *dev = device; + + /* FIXME: Free stuff! */ + + g_free (dev); +} + +static const cairo_device_backend_t _cairo_cogl_device_backend = { + CAIRO_DEVICE_TYPE_COGL, + + NULL, /* lock */ + NULL, /* unlock */ + + _cairo_cogl_device_flush, + _cairo_cogl_device_finish, + _cairo_cogl_device_destroy, +}; + +static cairo_bool_t +set_blend (CoglPipeline *pipeline, const char *blend_string) +{ + GError *error = NULL; + if (!cogl_pipeline_set_blend (pipeline, blend_string, &error)) { + g_warning ("Unsupported blend string with current gpu/driver: %s", blend_string); + g_error_free (error); + return FALSE; + } + return TRUE; +} + +static cairo_bool_t +_cairo_cogl_setup_op_state (CoglPipeline *pipeline, cairo_operator_t op) +{ + cairo_bool_t status = FALSE; + + switch ((int)op) + { + case CAIRO_OPERATOR_SOURCE: + status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR, 0)"); + break; + case CAIRO_OPERATOR_OVER: + status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR, DST_COLOR * (1 - SRC_COLOR[A]))"); + break; + case CAIRO_OPERATOR_IN: + status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR * DST_COLOR[A], 0)"); + break; + case CAIRO_OPERATOR_DEST_OVER: + status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR * (1 - DST_COLOR[A]), DST_COLOR)"); + break; + case CAIRO_OPERATOR_DEST_IN: + status = set_blend (pipeline, "RGBA = ADD (0, DST_COLOR * SRC_COLOR[A])"); + break; + case CAIRO_OPERATOR_ADD: + status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR, DST_COLOR)"); + break; + } + + return status; +} + +static void +create_templates_for_op (cairo_cogl_device_t *dev, cairo_operator_t op) +{ + CoglPipeline *base = cogl_pipeline_new (); + CoglPipeline *pipeline; + CoglColor color; + + if (!_cairo_cogl_setup_op_state (base, op)) { + cogl_object_unref (base); + return; + } + + dev->template_pipelines[op][CAIRO_COGL_TEMPLATE_TYPE_SOLID] = base; + + pipeline = cogl_pipeline_copy (base); + cogl_pipeline_set_layer_texture (pipeline, 0, dev->dummy_texture); + dev->template_pipelines[op][CAIRO_COGL_TEMPLATE_TYPE_TEXTURE] = pipeline; + + pipeline = cogl_pipeline_copy (base); + cogl_pipeline_set_layer_combine (pipeline, 1, + "RGBA = MODULATE (PREVIOUS, CONSTANT[A])", + NULL); + cogl_pipeline_set_layer_combine_constant (pipeline, 1, &color); + cogl_pipeline_set_layer_texture (pipeline, 1, dev->dummy_texture); + dev->template_pipelines[op][CAIRO_COGL_TEMPLATE_TYPE_MASK_SOLID] = pipeline; + + pipeline = cogl_pipeline_copy (base); + cogl_pipeline_set_layer_combine (pipeline, 1, + "RGBA = MODULATE (PREVIOUS, TEXTURE[A])", + NULL); + cogl_pipeline_set_layer_texture (pipeline, 1, dev->dummy_texture); + dev->template_pipelines[op][CAIRO_COGL_TEMPLATE_TYPE_MASK_TEXTURE] = pipeline; +} + +cairo_device_t * +cairo_cogl_device_create (CoglContext *cogl_context) +{ + cairo_cogl_device_t *dev = g_new0 (cairo_cogl_device_t, 1); + cairo_status_t status; + + dev->backend_vtable_initialized = FALSE; + + dev->cogl_context = cogl_context; + + dev->dummy_texture = cogl_texture_new_with_size (1, 1, + COGL_TEXTURE_NO_SLICING, + COGL_PIXEL_FORMAT_ANY); + if (!dev->dummy_texture) + goto ERROR; + + memset (dev->template_pipelines, 0, sizeof (dev->template_pipelines)); + create_templates_for_op (dev, CAIRO_OPERATOR_SOURCE); + create_templates_for_op (dev, CAIRO_OPERATOR_OVER); + create_templates_for_op (dev, CAIRO_OPERATOR_IN); + create_templates_for_op (dev, CAIRO_OPERATOR_DEST_OVER); + create_templates_for_op (dev, CAIRO_OPERATOR_DEST_IN); + create_templates_for_op (dev, CAIRO_OPERATOR_ADD); + + status = _cairo_cache_init (&dev->linear_cache, + _cairo_cogl_linear_gradient_equal, + NULL, + (cairo_destroy_func_t) _cairo_cogl_linear_gradient_destroy, + CAIRO_COGL_LINEAR_GRADIENT_CACHE_SIZE); + if (unlikely (status)) + return _cairo_device_create_in_error(status); + + status = _cairo_cache_init (&dev->path_fill_staging_cache, + _cairo_cogl_path_fill_meta_equal, + NULL, + (cairo_destroy_func_t) _cairo_cogl_path_fill_meta_destroy, + 1000); + + status = _cairo_cache_init (&dev->path_stroke_staging_cache, + _cairo_cogl_path_stroke_meta_equal, + NULL, + (cairo_destroy_func_t) _cairo_cogl_path_stroke_meta_destroy, + 1000); + + status = _cairo_cache_init (&dev->path_fill_prim_cache, + _cairo_cogl_path_fill_meta_equal, + NULL, + (cairo_destroy_func_t) _cairo_cogl_path_fill_meta_destroy, + CAIRO_COGL_PATH_META_CACHE_SIZE); + + status = _cairo_cache_init (&dev->path_stroke_prim_cache, + _cairo_cogl_path_stroke_meta_equal, + NULL, + (cairo_destroy_func_t) _cairo_cogl_path_stroke_meta_destroy, + CAIRO_COGL_PATH_META_CACHE_SIZE); + + _cairo_device_init (&dev->base, &_cairo_cogl_device_backend); + return &dev->base; + +ERROR: + g_free (dev); + return _cairo_device_create_in_error (CAIRO_STATUS_DEVICE_ERROR); +} +slim_hidden_def (cairo_cogl_device_create); + +void +cairo_cogl_surface_end_frame (cairo_surface_t *abstract_surface) +{ + cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)abstract_surface; + cairo_surface_flush (abstract_surface); + + //g_print ("n_clip_update_per_frame = %d\n", surface->n_clip_updates_per_frame); + surface->n_clip_updates_per_frame = 0; +} +slim_hidden_def (cairo_cogl_surface_end_frame); |