src/cairo-vg-surface.c

   1 /* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */
   2 /* cairo - a vector graphics library with display and print output
   3  *
   4  * Copyright © 2008 Opened Hand Ltd.
   5  * Copyright © 2009 Chris Wilson
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it either under the terms of the GNU Lesser General Public
   9  * License version 2.1 as published by the Free Software Foundation
  10  * (the "LGPL") or, at your option, under the terms of the Mozilla
  11  * Public License Version 1.1 (the "MPL"). If you do not alter this
  12  * notice, a recipient may use your version of this file under either
  13  * the MPL or the LGPL.
  14  *
  15  * You should have received a copy of the LGPL along with this library
  16  * in the file COPYING-LGPL-2.1; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
  18  * You should have received a copy of the MPL along with this library
  19  * in the file COPYING-MPL-1.1
  20  *
  21  * The contents of this file are subject to the Mozilla Public License
  22  * Version 1.1 (the "License"); you may not use this file except in
  23  * compliance with the License. You may obtain a copy of the License at
  24  * http://www.mozilla.og/MPL/
  25  *
  26  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
  27  * OF ANY KIND, either express or implied. See the LGPL or the MPL for
  28  * the specific language governing rights and limitations.
  29  *
  30  * Contributor(s):
  31  *      Pierre Tardy      <tardyp@gmail.com>
  32  *      Øyvind Kolås      <pippin@gimp.org>
  33  *      Vladimi Vukicevic <vladimir@mozilla.com> (stubbed out base backend)
  34  *      Chris Wilson      <chris@chris-wilson.co.uk>
  35  */
  36
  37 #include "cairoint.h"
  38
  39 #include "cairo-vg.h"
  40
  41 #include "cairo-cache-private.h"
  42 #include "cairo-default-context-private.h"
  43 #include "cairo-error-private.h"
  44 #include "cairo-image-surface-private.h"
  45 #include "cairo-path-fixed-private.h"
  46 #include "cairo-recording-surface-inline.h"
  47 #include "cairo-surface-clipper-private.h"
  48
  49 #include <pixman.h>
  50 #include <VG/openvg.h>
  51
  52 //#define OPENVG_DEBUG
  53
  54 /*
  55  * Work that needs to be done:
  56  *  - Glyph cache / proper font support
  57  *
  58  *  - First-class paths
  59  *    Paths are expensive for OpenVG, reuse paths whenever possible.
  60  *    So add a path cache, and first class paths!
  61  */
  62
  63 typedef struct _cairo_vg_surface cairo_vg_surface_t;
  64
  65 /* XXX need GL specific context control. :( */
  66 struct _cairo_vg_context {
  67     cairo_status_t status;
  68     cairo_reference_count_t ref_count;
  69
  70     unsigned long target_id;
  71
  72     VGPaint             paint;
  73     cairo_vg_surface_t *source;
  74     double              alpha;
  75
  76     cairo_cache_t snapshot_cache;
  77
  78     void *display;
  79     void *context;
  80
  81     cairo_status_t (*create_target) (cairo_vg_context_t *,
  82                                      cairo_vg_surface_t *);
  83     cairo_status_t (*set_target) (cairo_vg_context_t *,
  84                                   cairo_vg_surface_t *);
  85     void (*destroy_target) (cairo_vg_context_t *, cairo_vg_surface_t *);
  86 };
  87
  88 struct _cairo_vg_surface {
  89     cairo_surface_t base;
  90
  91     cairo_vg_context_t *context;
  92
  93     VGImage         image;
  94     VGImageFormat   format;
  95     int             width;
  96     int             height;
  97     cairo_bool_t    own_image;
  98
  99     cairo_cache_entry_t snapshot_cache_entry;
 100
 101     cairo_surface_clipper_t clipper;
 102
 103     unsigned long target_id;
 104 };
 105
 106 static const cairo_surface_backend_t cairo_vg_surface_backend;
 107
 108 slim_hidden_proto (cairo_vg_surface_create);
 109
 110 static cairo_surface_t *
 111 _vg_surface_create_internal (cairo_vg_context_t *context,
 112                              VGImage image,
 113                              VGImageFormat format,
 114                              int width, int height);
 115
 116 static cairo_vg_context_t *
 117 _vg_context_reference (cairo_vg_context_t *context)
 118 {
 119     assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&context->ref_count));
 120
 121     _cairo_reference_count_inc (&context->ref_count);
 122
 123     return context;
 124 }
 125
 126 static cairo_vg_context_t *
 127 _vg_context_lock (cairo_vg_context_t *context)
 128 {
 129     /* XXX if we need to add locking, then it has to be recursive */
 130     return context;
 131 }
 132
 133 static cairo_int_status_t
 134 _vg_context_set_target (cairo_vg_context_t *context,
 135                         cairo_vg_surface_t *surface)
 136 {
 137     cairo_status_t status;
 138
 139     if (surface->target_id == 0) {
 140         status = context->create_target (context, surface);
 141         if (unlikely (status))
 142             return status;
 143     }
 144
 145     if (context->target_id == surface->target_id)
 146         return CAIRO_STATUS_SUCCESS;
 147
 148     context->target_id = surface->target_id;
 149
 150     return context->set_target (context, surface);
 151 }
 152
 153 static void
 154 _vg_context_destroy_target (cairo_vg_context_t *context,
 155                             cairo_vg_surface_t *surface)
 156 {
 157     if (surface->target_id == 0)
 158         return;
 159
 160     if (context->target_id == surface->target_id)
 161         context->set_target (context, NULL);
 162
 163     context->destroy_target (context, surface);
 164 }
 165
 166 static cairo_bool_t
 167 _vg_snapshot_cache_can_remove (const void *entry)
 168 {
 169     return TRUE;
 170 }
 171
 172 static void
 173 _vg_snapshot_cache_remove (void *cache_entry)
 174 {
 175     cairo_vg_surface_t *surface = cairo_container_of (cache_entry,
 176                                                       cairo_vg_surface_t,
 177                                                       snapshot_cache_entry);
 178     surface->snapshot_cache_entry.hash = 0;
 179     cairo_surface_destroy (&surface->base);
 180 }
 181
 182 static cairo_status_t
 183 _vg_context_init (cairo_vg_context_t *context)
 184 {
 185     cairo_status_t status;
 186
 187     context->status = CAIRO_STATUS_SUCCESS;
 188     CAIRO_REFERENCE_COUNT_INIT (&context->ref_count, 1);
 189
 190     status = _cairo_cache_init (&context->snapshot_cache,
 191                                 NULL,
 192                                 _vg_snapshot_cache_can_remove,
 193                                 _vg_snapshot_cache_remove,
 194                                 16*1024*1024);
 195     if (unlikely (status))
 196         return status;
 197
 198     context->target_id = 0;
 199     context->source = NULL;
 200     context->alpha = 1.0;
 201
 202     context->paint = vgCreatePaint ();
 203     vgLoadIdentity ();
 204
 205     return CAIRO_STATUS_SUCCESS;
 206 }
 207
 208 static void
 209 _vg_context_destroy (cairo_vg_context_t *context)
 210 {
 211     assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&context->ref_count));
 212
 213     if (! _cairo_reference_count_dec_and_test (&context->ref_count))
 214         return;
 215
 216     if (context->paint != VG_INVALID_HANDLE)
 217         vgDestroyPaint (context->paint);
 218
 219     _cairo_cache_fini (&context->snapshot_cache);
 220     free (context);
 221 }
 222
 223 static void
 224 _vg_context_unlock (cairo_vg_context_t *context)
 225 {
 226 }
 227
 228 #ifdef OPENVG_DEBUG
 229 static void check_vg_errors(const char*function,int line)
 230 {
 231     int err = vgGetError();
 232     if (err != VG_NO_ERROR){
 233         printf("%s+%d:vgError detected: 0x%08x.\n",function, line,err);
 234         assert(err == VG_NO_ERROR);
 235     }
 236
 237 }
 238 #define CHECK_VG_ERRORS() check_vg_errors(__FILE__,__LINE__)
 239 #else
 240 #define CHECK_VG_ERRORS() do{}while(0)
 241 #endif //OPENVG_DEBUG
 242
 243 static pixman_format_code_t
 244 _vg_format_to_pixman (VGImageFormat format,
 245                       cairo_bool_t *needs_premult_fixup)
 246 {
 247     *needs_premult_fixup = FALSE;
 248     switch (format) {
 249         /* RGB{A,X} channel ordering */
 250     case VG_sRGBX_8888: return PIXMAN_r8g8b8x8;
 251     case VG_sRGBA_8888: *needs_premult_fixup = TRUE; return PIXMAN_r8g8b8a8;
 252     case VG_sRGBA_8888_PRE: return PIXMAN_r8g8b8a8;
 253     case VG_sRGB_565: return PIXMAN_r5g6b5;
 254     case VG_sRGBA_5551: return 0;
 255     case VG_sRGBA_4444: return 0;
 256     case VG_sL_8: return PIXMAN_g8;
 257     case VG_lRGBX_8888: return 0;
 258     case VG_lRGBA_8888: return 0;
 259     case VG_lRGBA_8888_PRE: return 0;
 260     case VG_lL_8: return 0;
 261     case VG_A_8: return PIXMAN_a8;
 262     case VG_BW_1: return PIXMAN_a1;
 263     case VG_A_1: return PIXMAN_a1;
 264     case VG_A_4: return PIXMAN_a4;
 265
 266         /* {A,X}RGB channel ordering */
 267     case VG_sXRGB_8888: return PIXMAN_x8r8g8b8;
 268     case VG_sARGB_8888: *needs_premult_fixup = TRUE; return PIXMAN_a8r8g8b8;
 269     case VG_sARGB_8888_PRE: return PIXMAN_a8r8g8b8;
 270     case VG_sARGB_1555: return 0;
 271     case VG_sARGB_4444: return 0;
 272     case VG_lXRGB_8888: return 0;
 273     case VG_lARGB_8888: return 0;
 274     case VG_lARGB_8888_PRE: return 0;
 275
 276         /* BGR{A,X} channel ordering */
 277     case VG_sBGRX_8888: return PIXMAN_b8g8r8x8;
 278     case VG_sBGRA_8888: *needs_premult_fixup = TRUE; return PIXMAN_b8g8r8a8;
 279     case VG_sBGRA_8888_PRE: return PIXMAN_b8g8r8a8;
 280     case VG_sBGR_565: return PIXMAN_b5g6r5;
 281     case VG_sBGRA_5551: return 0;
 282     case VG_sBGRA_4444: return 0;
 283     case VG_lBGRX_8888: return 0;
 284     case VG_lBGRA_8888: return 0;
 285     case VG_lBGRA_8888_PRE: return 0;
 286
 287         /* {A,X}BGR channel ordering */
 288     case VG_sXBGR_8888: return PIXMAN_x8b8g8r8;
 289     case VG_sABGR_8888: *needs_premult_fixup = TRUE; return PIXMAN_a8b8g8r8;
 290     case VG_sABGR_8888_PRE: return PIXMAN_a8b8g8r8;
 291     case VG_sABGR_1555: return 0;
 292     case VG_sABGR_4444: return 0;
 293     case VG_lXBGR_8888: return 0;
 294     case VG_lABGR_8888: return 0;
 295     case VG_lABGR_8888_PRE: return 0;
 296     default: return 0;
 297     }
 298 }
 299
 300 static pixman_format_code_t
 301 _vg_format_to_content (VGImageFormat format)
 302 {
 303     /* XXX could use more simple bit tests */
 304     switch (format) {
 305         /* RGB{A,X} channel ordering */
 306     case VG_sRGBX_8888: return CAIRO_CONTENT_COLOR;
 307     case VG_sRGBA_8888: return CAIRO_CONTENT_COLOR_ALPHA;
 308     case VG_sRGBA_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
 309     case VG_sRGB_565: return CAIRO_CONTENT_COLOR;
 310     case VG_sRGBA_5551: return CAIRO_CONTENT_COLOR_ALPHA;
 311     case VG_sRGBA_4444: return CAIRO_CONTENT_COLOR_ALPHA;
 312     case VG_sL_8: return CAIRO_CONTENT_ALPHA;
 313     case VG_lRGBX_8888: return CAIRO_CONTENT_COLOR;
 314     case VG_lRGBA_8888: return CAIRO_CONTENT_COLOR_ALPHA;
 315     case VG_lRGBA_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
 316     case VG_lL_8: return CAIRO_CONTENT_ALPHA;
 317     case VG_A_8: return CAIRO_CONTENT_ALPHA;
 318     case VG_A_4: return CAIRO_CONTENT_ALPHA;
 319     case VG_A_1: return CAIRO_CONTENT_ALPHA;
 320     case VG_BW_1: return CAIRO_CONTENT_ALPHA;
 321
 322         /* {A,X}RGB channel ordering */
 323     case VG_sXRGB_8888: return CAIRO_CONTENT_COLOR;
 324     case VG_sARGB_8888: return CAIRO_CONTENT_COLOR_ALPHA;
 325     case VG_sARGB_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
 326     case VG_sARGB_1555: return CAIRO_CONTENT_COLOR_ALPHA;
 327     case VG_sARGB_4444: return CAIRO_CONTENT_COLOR_ALPHA;
 328     case VG_lXRGB_8888: return CAIRO_CONTENT_COLOR;
 329     case VG_lARGB_8888: return CAIRO_CONTENT_COLOR_ALPHA;
 330     case VG_lARGB_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
 331
 332         /* BGR{A,X} channel ordering */
 333     case VG_sBGRX_8888: return CAIRO_CONTENT_COLOR;
 334     case VG_sBGRA_8888: return CAIRO_CONTENT_COLOR_ALPHA;
 335     case VG_sBGRA_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
 336     case VG_sBGR_565: return CAIRO_CONTENT_COLOR;
 337     case VG_sBGRA_5551: return CAIRO_CONTENT_COLOR_ALPHA;
 338     case VG_sBGRA_4444: return CAIRO_CONTENT_COLOR_ALPHA;
 339     case VG_lBGRX_8888: return CAIRO_CONTENT_COLOR;
 340     case VG_lBGRA_8888: return CAIRO_CONTENT_COLOR_ALPHA;
 341     case VG_lBGRA_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
 342
 343         /* {A,X}BGR channel ordering */
 344     case VG_sXBGR_8888: return CAIRO_CONTENT_COLOR;
 345     case VG_sABGR_8888: return CAIRO_CONTENT_COLOR_ALPHA;
 346     case VG_sABGR_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
 347     case VG_sABGR_1555: return CAIRO_CONTENT_COLOR_ALPHA;
 348     case VG_sABGR_4444: return CAIRO_CONTENT_COLOR_ALPHA;
 349     case VG_lXBGR_8888: return CAIRO_CONTENT_COLOR;
 350     case VG_lABGR_8888: return CAIRO_CONTENT_COLOR_ALPHA;
 351     case VG_lABGR_8888_PRE: return CAIRO_CONTENT_COLOR_ALPHA;
 352     default: return 0;
 353     }
 354 }
 355
 356 static VGImageFormat
 357 _vg_format_from_pixman (pixman_format_code_t format)
 358 {
 359     /* XXX _PRE needs fixup */
 360     switch ((int) format) {
 361     case PIXMAN_r5g6b5: return VG_sRGB_565;
 362     case PIXMAN_g8: return VG_sL_8;
 363     case PIXMAN_a8: return VG_A_8;
 364     case PIXMAN_a1: return VG_BW_1;
 365     case PIXMAN_x8r8g8b8: return VG_sXRGB_8888;
 366     case PIXMAN_a8r8g8b8: return VG_sARGB_8888; // _PRE
 367     case PIXMAN_b8g8r8x8: return VG_sBGRX_8888;
 368     case PIXMAN_b8g8r8a8: return VG_sBGRA_8888; // _PRE
 369     case PIXMAN_b5g6r5: return VG_sBGR_565;
 370     case PIXMAN_x8b8g8r8: return VG_sXBGR_8888;
 371     case PIXMAN_a8b8g8r8: return VG_sABGR_8888; // _PRE
 372     default: return 0;
 373     }
 374 }
 375
 376 static VGImageFormat
 377 _vg_format_for_content (cairo_content_t content)
 378 {
 379     switch (content) {
 380     case CAIRO_CONTENT_ALPHA: return VG_A_8;
 381     case CAIRO_CONTENT_COLOR: return VG_sXRGB_8888;
 382     default: ASSERT_NOT_REACHED;
 383     case CAIRO_CONTENT_COLOR_ALPHA: return VG_sARGB_8888; // _PRE
 384     }
 385 }
 386
 387 static cairo_surface_t *
 388 _vg_surface_create_similar (void            *abstract_surface,
 389                             cairo_content_t  content,
 390                             int              width,
 391                             int              height)
 392 {
 393     cairo_vg_surface_t *surface = abstract_surface;
 394
 395     if (width > vgGeti (VG_MAX_IMAGE_WIDTH) ||
 396         height > vgGeti (VG_MAX_IMAGE_HEIGHT))
 397     {
 398         return NULL;
 399     }
 400
 401     return cairo_vg_surface_create (surface->context, content, width, height);
 402 }
 403
 404 static cairo_status_t
 405 _vg_surface_clipper_intersect_clip_path (cairo_surface_clipper_t *clipper,
 406                                          cairo_path_fixed_t *path,
 407                                          cairo_fill_rule_t   fill_rule,
 408                                          double              tolerance,
 409                                          cairo_antialias_t   antialias)
 410 {
 411     cairo_vg_surface_t *surface = cairo_container_of (clipper,
 412                                                       cairo_vg_surface_t,
 413                                                       clipper);
 414     cairo_vg_surface_t *mask;
 415     cairo_status_t status;
 416
 417     if (path == NULL) {
 418         vgMask (VG_INVALID_HANDLE,
 419                 VG_FILL_MASK, 0, 0, surface->width, surface->height);
 420         vgSeti (VG_MASKING, VG_FALSE);
 421         CHECK_VG_ERRORS();
 422         return CAIRO_STATUS_SUCCESS;
 423     }
 424
 425     mask = (cairo_vg_surface_t *)
 426         _vg_surface_create_similar (surface, CAIRO_CONTENT_ALPHA,
 427                                     surface->width, surface->height);
 428     if (unlikely (mask == NULL))
 429         return CAIRO_INT_STATUS_UNSUPPORTED;
 430     if (unlikely (mask->base.status))
 431         return mask->base.status;
 432
 433     status = _cairo_surface_fill (&mask->base,
 434                                   CAIRO_OPERATOR_SOURCE,
 435                                   &_cairo_pattern_white.base,
 436                                   path, fill_rule, tolerance, antialias,
 437                                   NULL);
 438     if (status) {
 439         cairo_surface_destroy (&mask->base);
 440         return status;
 441     }
 442
 443     vgSeti (VG_MASKING, VG_TRUE);
 444     vgMask (mask->image, VG_INTERSECT_MASK, 0, 0, mask->width, mask->height);
 445
 446     cairo_surface_destroy (&mask->base);
 447
 448     CHECK_VG_ERRORS();
 449     return CAIRO_STATUS_SUCCESS;
 450 }
 451
 452 static cairo_bool_t
 453 _vg_surface_get_extents (void                  *abstract_surface,
 454                          cairo_rectangle_int_t *extents)
 455 {
 456     cairo_vg_surface_t *surface = abstract_surface;
 457
 458     extents->x = 0;
 459     extents->y = 0;
 460     extents->width  = surface->width;
 461     extents->height = surface->height;
 462
 463     return TRUE;
 464 }
 465
 466 #define MAX_SEG  16  /* max number of knots to upload in a batch */
 467
 468 typedef struct _vg_path {
 469     VGPath path;
 470     const cairo_matrix_t *ctm_inverse;
 471
 472     VGubyte gseg[MAX_SEG];
 473     VGfloat gdata[MAX_SEG*3*2];
 474     int dcount;
 475     int scount;
 476 } vg_path_t;
 477
 478 static cairo_status_t
 479 _vg_move_to (void          *closure,
 480              const cairo_point_t *point)
 481 {
 482     vg_path_t *path = closure;
 483     double x = _cairo_fixed_to_double (point->x);
 484     double y = _cairo_fixed_to_double (point->y);
 485
 486     if (path->ctm_inverse)
 487         cairo_matrix_transform_point (path->ctm_inverse, &x, &y);
 488
 489     path->gseg[path->scount++] = VG_MOVE_TO;
 490     path->gdata[path->dcount++] = x;
 491     path->gdata[path->dcount++] = y;
 492
 493     if (path->scount >= MAX_SEG-1) {
 494         vgAppendPathData (path->path, path->scount, path->gseg, path->gdata);
 495         path->scount = 0;
 496         path->dcount = 0;
 497     }
 498
 499     CHECK_VG_ERRORS();
 500     return CAIRO_STATUS_SUCCESS;
 501 }
 502
 503 static cairo_status_t
 504 _vg_line_to (void          *closure,
 505              const cairo_point_t *point)
 506 {
 507     vg_path_t *path = closure;
 508     double x = _cairo_fixed_to_double (point->x);
 509     double y = _cairo_fixed_to_double (point->y);
 510
 511     if (path->ctm_inverse)
 512         cairo_matrix_transform_point (path->ctm_inverse, &x, &y);
 513
 514     path->gseg[path->scount++] = VG_LINE_TO;
 515     path->gdata[path->dcount++] = x;
 516     path->gdata[path->dcount++] = y;
 517
 518     if (path->scount >= MAX_SEG-1) {
 519         vgAppendPathData (path->path, path->scount, path->gseg, path->gdata);
 520         path->scount = 0;
 521         path->dcount = 0;
 522     }
 523
 524     CHECK_VG_ERRORS();
 525     return CAIRO_STATUS_SUCCESS;
 526 }
 527
 528 static cairo_status_t
 529 _vg_curve_to (void          *closure,
 530               const cairo_point_t *p0,
 531               const cairo_point_t *p1,
 532               const cairo_point_t *p2)
 533 {
 534     vg_path_t *path = closure;
 535     double x0 = _cairo_fixed_to_double (p0->x);
 536     double y0 = _cairo_fixed_to_double (p0->y);
 537     double x1 = _cairo_fixed_to_double (p1->x);
 538     double y1 = _cairo_fixed_to_double (p1->y);
 539     double x2 = _cairo_fixed_to_double (p2->x);
 540     double y2 = _cairo_fixed_to_double (p2->y);
 541
 542     if (path->ctm_inverse) {
 543         cairo_matrix_transform_point (path->ctm_inverse, &x0, &y0);
 544         cairo_matrix_transform_point (path->ctm_inverse, &x1, &y1);
 545         cairo_matrix_transform_point (path->ctm_inverse, &x2, &y2);
 546     }
 547
 548     path->gseg[path->scount++] = VG_CUBIC_TO;
 549     path->gdata[path->dcount++] = x0;
 550     path->gdata[path->dcount++] = y0;
 551     path->gdata[path->dcount++] = x1;
 552     path->gdata[path->dcount++] = y1;
 553     path->gdata[path->dcount++] = x2;
 554     path->gdata[path->dcount++] = y2;
 555
 556     if (path->scount >= MAX_SEG-1) {
 557         vgAppendPathData(path->path, path->scount, path->gseg, path->gdata);
 558         path->scount = 0;
 559         path->dcount = 0;
 560     }
 561
 562     CHECK_VG_ERRORS();
 563     return CAIRO_STATUS_SUCCESS;
 564 }
 565
 566 static cairo_status_t
 567 _vg_close_path (void *closure)
 568 {
 569     vg_path_t *path = closure;
 570
 571     path->gseg[path->scount++] = VG_CLOSE_PATH;
 572
 573     if (path->scount >= MAX_SEG-1) {
 574         vgAppendPathData (path->path, path->scount, path->gseg, path->gdata);
 575         path->scount = 0;
 576         path->dcount = 0;
 577     }
 578
 579     CHECK_VG_ERRORS();
 580     return CAIRO_STATUS_SUCCESS;
 581 }
 582
 583 static void
 584 _vg_path_from_cairo (vg_path_t    *vg_path,
 585                      const cairo_path_fixed_t *path)
 586 {
 587     cairo_status_t status;
 588
 589     vg_path->scount = 0;
 590     vg_path->dcount = 0;
 591
 592     status = _cairo_path_fixed_interpret (path,
 593                                           _vg_move_to,
 594                                           _vg_line_to,
 595                                           _vg_curve_to,
 596                                           _vg_close_path,
 597                                           vg_path);
 598     assert (status == CAIRO_STATUS_SUCCESS);
 599
 600     vgAppendPathData (vg_path->path,
 601                       vg_path->scount, vg_path->gseg, vg_path->gdata);
 602     CHECK_VG_ERRORS();
 603 }
 604
 605 static cairo_bool_t
 606 _vg_is_supported_operator (cairo_operator_t op)
 607 {
 608     switch ((int) op) {
 609     case CAIRO_OPERATOR_SOURCE:
 610     case CAIRO_OPERATOR_OVER:
 611     case CAIRO_OPERATOR_IN:
 612     case CAIRO_OPERATOR_DEST_OVER:
 613     case CAIRO_OPERATOR_DEST_IN:
 614     case CAIRO_OPERATOR_ADD:
 615         return TRUE;
 616
 617     default:
 618         return FALSE;
 619     }
 620 }
 621
 622 static VGBlendMode
 623 _vg_operator (cairo_operator_t op)
 624 {
 625     switch ((int) op) {
 626     case CAIRO_OPERATOR_SOURCE:
 627         return VG_BLEND_SRC;
 628     case CAIRO_OPERATOR_OVER:
 629         return VG_BLEND_SRC_OVER;
 630     case CAIRO_OPERATOR_IN:
 631         return VG_BLEND_SRC_IN;
 632     case CAIRO_OPERATOR_DEST_OVER:
 633         return VG_BLEND_DST_OVER;
 634     case CAIRO_OPERATOR_DEST_IN:
 635         return VG_BLEND_DST_IN;
 636     case CAIRO_OPERATOR_ADD:
 637         return VG_BLEND_ADDITIVE;
 638     default:
 639         ASSERT_NOT_REACHED;
 640         return VG_BLEND_SRC_OVER;
 641     }
 642 }
 643
 644 static VGFillRule
 645 _vg_fill_rule_from_cairo (cairo_fill_rule_t rule)
 646 {
 647     switch (rule) {
 648     case CAIRO_FILL_RULE_EVEN_ODD: return VG_EVEN_ODD;
 649     case CAIRO_FILL_RULE_WINDING: return VG_NON_ZERO;
 650     }
 651
 652     ASSERT_NOT_REACHED;
 653     return VG_NON_ZERO;
 654 }
 655
 656 static VGRenderingQuality
 657 _vg_rendering_quality_from_cairo (cairo_antialias_t aa)
 658 {
 659     switch (aa) {
 660     case CAIRO_ANTIALIAS_DEFAULT:
 661     case CAIRO_ANTIALIAS_SUBPIXEL:
 662     case CAIRO_ANTIALIAS_GOOD:
 663     case CAIRO_ANTIALIAS_BEST:
 664         return VG_RENDERING_QUALITY_BETTER;
 665
 666     case CAIRO_ANTIALIAS_GRAY:
 667     case CAIRO_ANTIALIAS_FAST:
 668         return VG_RENDERING_QUALITY_FASTER;
 669
 670     case CAIRO_ANTIALIAS_NONE:
 671         return VG_RENDERING_QUALITY_NONANTIALIASED;
 672     }
 673
 674     ASSERT_NOT_REACHED;
 675     return VG_RENDERING_QUALITY_BETTER;
 676 }
 677
 678 static VGCapStyle
 679 _vg_line_cap_from_cairo (cairo_line_cap_t cap)
 680 {
 681     switch (cap) {
 682     case CAIRO_LINE_CAP_BUTT:   return VG_CAP_BUTT;
 683     case CAIRO_LINE_CAP_ROUND:  return VG_CAP_ROUND;
 684     case CAIRO_LINE_CAP_SQUARE: return VG_CAP_SQUARE;
 685     }
 686
 687     ASSERT_NOT_REACHED;
 688     return VG_CAP_BUTT;
 689 }
 690
 691 static VGJoinStyle
 692 _vg_line_join_from_cairo (cairo_line_join_t join)
 693 {
 694     switch (join) {
 695     case CAIRO_LINE_JOIN_MITER: return VG_JOIN_MITER;
 696     case CAIRO_LINE_JOIN_ROUND: return VG_JOIN_ROUND;
 697     case CAIRO_LINE_JOIN_BEVEL: return VG_JOIN_BEVEL;
 698     }
 699
 700     ASSERT_NOT_REACHED;
 701     return VG_JOIN_MITER;
 702 }
 703
 704 static void
 705 _vg_matrix_from_cairo (VGfloat *dst, const cairo_matrix_t *src)
 706 {
 707     dst[0] = /* sx  */ src->xx;
 708     dst[1] = /* shy */ src->yx;
 709     dst[2] = /* w0  */ 0;
 710     dst[3] = /* shx */ src->xy;
 711     dst[4] = /* sy  */ src->yy;
 712     dst[5] = /* w1  */ 0;
 713     dst[6] = /* tx  */ src->x0;
 714     dst[7] = /* ty  */ src->y0;
 715     dst[8] = /* w2  */ 0;
 716 }
 717
 718 static cairo_status_t
 719 _vg_setup_gradient_stops (cairo_vg_context_t *context,
 720                           const cairo_gradient_pattern_t *pattern)
 721 {
 722     VGint numstops = pattern->n_stops;
 723     VGfloat *stops, stack_stops[CAIRO_STACK_ARRAY_LENGTH (VGfloat)];
 724     int i;
 725
 726     if (numstops*5 < ARRAY_LENGTH (stack_stops)) {
 727         stops = stack_stops;
 728     } else {
 729         stops = _cairo_malloc_ab (numstops, 5*sizeof (VGfloat));
 730         if (unlikely (stops == NULL))
 731             return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 732     }
 733
 734     for (i = 0; i < numstops; i++) {
 735         stops[i*5 + 0] = pattern->stops[i].offset;
 736         stops[i*5 + 1] = pattern->stops[i].color.red;
 737         stops[i*5 + 2] = pattern->stops[i].color.green;
 738         stops[i*5 + 3] = pattern->stops[i].color.blue;
 739         stops[i*5 + 4] = pattern->stops[i].color.alpha * context->alpha;
 740     }
 741
 742     vgSetParameterfv (context->paint,
 743                       VG_PAINT_COLOR_RAMP_STOPS, numstops * 5, stops);
 744
 745     if (stops != stack_stops)
 746         free (stops);
 747
 748     CHECK_VG_ERRORS();
 749     return CAIRO_STATUS_SUCCESS;
 750 }
 751
 752 static void
 753 _vg_set_source_matrix (const cairo_pattern_t *pat)
 754 {
 755     cairo_matrix_t mat;
 756     cairo_status_t status;
 757     VGfloat vmat[9];
 758
 759     mat = pat->matrix;
 760     status = cairo_matrix_invert (&mat);
 761     assert (status == CAIRO_STATUS_SUCCESS);
 762
 763     _vg_matrix_from_cairo (vmat, &mat);
 764
 765     vgSeti (VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);
 766     vgLoadMatrix (vmat);
 767     vgSeti (VG_MATRIX_MODE, VG_MATRIX_STROKE_PAINT_TO_USER);
 768     vgLoadMatrix (vmat);
 769     vgSeti (VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
 770
 771     CHECK_VG_ERRORS();
 772 }
 773
 774 static cairo_status_t
 775 _vg_setup_linear_source (cairo_vg_context_t *context,
 776                          const cairo_linear_pattern_t *lpat)
 777 {
 778     VGfloat linear[4];
 779
 780     linear[0] = lpat->pd1.x;
 781     linear[1] = lpat->pd1.y;
 782     linear[2] = lpat->pd2.x;
 783     linear[3] = lpat->pd2.y;
 784
 785     vgSetParameteri (context->paint,
 786                      VG_PAINT_COLOR_RAMP_SPREAD_MODE,
 787                      VG_COLOR_RAMP_SPREAD_PAD);
 788     vgSetParameteri (context->paint,
 789                      VG_PAINT_TYPE,
 790                      VG_PAINT_TYPE_LINEAR_GRADIENT);
 791     vgSetParameterfv (context->paint,
 792                       VG_PAINT_LINEAR_GRADIENT, 4, linear);
 793
 794     _vg_set_source_matrix (&lpat->base.base);
 795
 796     CHECK_VG_ERRORS();
 797     return _vg_setup_gradient_stops (context, &lpat->base);
 798
 799 }
 800
 801 static cairo_status_t
 802 _vg_setup_radial_source (cairo_vg_context_t *context,
 803                          const cairo_radial_pattern_t *rpat)
 804 {
 805     VGfloat radial[5];
 806
 807     radial[0] = rpat->cd1.center.x;
 808     radial[1] = rpat->cd1.center.y;
 809     radial[2] = rpat->cd2.center.x;
 810     radial[3] = rpat->cd2.center.y;
 811     radial[4] = rpat->cd2.radius;
 812
 813     vgSetParameteri (context->paint,
 814                      VG_PAINT_COLOR_RAMP_SPREAD_MODE, VG_COLOR_RAMP_SPREAD_PAD);
 815     vgSetParameteri (context->paint,
 816                      VG_PAINT_TYPE, VG_PAINT_TYPE_RADIAL_GRADIENT);
 817     vgSetParameterfv (context->paint,
 818                       VG_PAINT_RADIAL_GRADIENT, 5, radial);
 819
 820     _vg_set_source_matrix (&rpat->base.base);
 821
 822     /* FIXME: copy/adapt fixes from SVG backend to add inner radius */
 823
 824     CHECK_VG_ERRORS();
 825     return _vg_setup_gradient_stops (context, &rpat->base);
 826 }
 827
 828 static cairo_status_t
 829 _vg_setup_solid_source (cairo_vg_context_t *context,
 830                         const cairo_solid_pattern_t *spat)
 831 {
 832     VGfloat color[] = {
 833         spat->color.red,
 834         spat->color.green,
 835         spat->color.blue,
 836         spat->color.alpha * context->alpha
 837     };
 838
 839     vgSetParameteri (context->paint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
 840     vgSetParameterfv (context->paint, VG_PAINT_COLOR, 4, color);
 841
 842     CHECK_VG_ERRORS();
 843     return CAIRO_STATUS_SUCCESS;
 844 }
 845
 846 static cairo_vg_surface_t *
 847 _vg_clone_recording_surface (cairo_vg_context_t *context,
 848                         cairo_surface_t *surface)
 849 {
 850     VGImage vg_image;
 851     VGImageFormat format;
 852     cairo_status_t status;
 853     cairo_rectangle_int_t extents;
 854     cairo_vg_surface_t *clone;
 855
 856     status = _cairo_surface_get_extents (surface, &extents);
 857     if (status)
 858         return NULL;
 859
 860     if (extents.width > vgGeti (VG_MAX_IMAGE_WIDTH) ||
 861         extents.height > vgGeti (VG_MAX_IMAGE_HEIGHT))
 862     {
 863         return NULL;
 864     }
 865
 866     format = _vg_format_for_content (surface->content);
 867
 868     /* NONALIASED, FASTER, BETTER */
 869     vg_image = vgCreateImage (format,
 870                               extents.width, extents.height,
 871                               VG_IMAGE_QUALITY_FASTER);
 872     clone = (cairo_vg_surface_t *)
 873         _vg_surface_create_internal (context, vg_image, format,
 874                                      extents.width, extents.height);
 875     cairo_surface_set_device_offset (&clone->base, -extents.x, -extents.y);
 876
 877     status = _cairo_recording_surface_replay (surface, &clone->base);
 878     if (unlikely (status)) {
 879         cairo_surface_destroy (&clone->base);
 880         return (cairo_vg_surface_t *) _cairo_surface_create_in_error (status);
 881     }
 882
 883     return clone;
 884 }
 885
 886 static cairo_vg_surface_t *
 887 _vg_clone_image_surface (cairo_vg_context_t *context,
 888                          cairo_surface_t *surface)
 889 {
 890     cairo_image_surface_t *image;
 891     void *image_extra;
 892     cairo_status_t status;
 893     VGImage vg_image;
 894     VGImageFormat format;
 895     cairo_rectangle_int_t extents;
 896     cairo_vg_surface_t *clone;
 897
 898     if (surface->backend->acquire_source_image == NULL)
 899         return NULL;
 900
 901     status = _cairo_surface_get_extents (surface, &extents);
 902     if (status)
 903         return NULL;
 904
 905     if (extents.width > vgGeti (VG_MAX_IMAGE_WIDTH) ||
 906         extents.height > vgGeti (VG_MAX_IMAGE_HEIGHT))
 907     {
 908         return NULL;
 909     }
 910
 911     status = _cairo_surface_acquire_source_image (surface,
 912                                                   &image, &image_extra);
 913     if (unlikely (status))
 914         return (cairo_vg_surface_t *) _cairo_surface_create_in_error (status);
 915
 916     format = _vg_format_from_pixman (image->pixman_format);
 917     if (format == 0)
 918         format = _vg_format_for_content (image->base.content);
 919
 920     /* NONALIASED, FASTER, BETTER */
 921     vg_image = vgCreateImage (format,
 922                               image->width, image->height,
 923                               VG_IMAGE_QUALITY_FASTER);
 924     clone = (cairo_vg_surface_t *)
 925         _vg_surface_create_internal (context, vg_image, format,
 926                                     image->width, image->height);
 927     if (unlikely (clone->base.status))
 928         return clone;
 929
 930     vgImageSubData (clone->image,
 931                     image->data, image->stride,
 932                     format, 0, 0, image->width, image->height);
 933
 934     _cairo_surface_release_source_image (surface, image, image_extra);
 935
 936     return clone;
 937 }
 938
 939 static void
 940 _vg_surface_remove_from_cache (cairo_surface_t *abstract_surface)
 941 {
 942     cairo_vg_surface_t *surface = (cairo_vg_surface_t *) abstract_surface;
 943
 944     if (surface->snapshot_cache_entry.hash) {
 945         cairo_vg_context_t *context;
 946
 947         context = _vg_context_lock (surface->context);
 948         _cairo_cache_remove (&context->snapshot_cache,
 949                              &surface->snapshot_cache_entry);
 950         _vg_context_unlock (context);
 951
 952         surface->snapshot_cache_entry.hash = 0;
 953     }
 954 }
 955
 956 static cairo_status_t
 957 _vg_setup_surface_source (cairo_vg_context_t *context,
 958                           const cairo_surface_pattern_t *spat)
 959 {
 960     cairo_surface_t *snapshot;
 961     cairo_vg_surface_t *clone;
 962     cairo_status_t status;
 963
 964     snapshot = _cairo_surface_has_snapshot (spat->surface,
 965                                             &cairo_vg_surface_backend);
 966     if (snapshot != NULL) {
 967         clone = (cairo_vg_surface_t *) cairo_surface_reference (snapshot);
 968         goto DONE;
 969     }
 970
 971     if (_cairo_surface_is_recording (spat->surface))
 972         clone = _vg_clone_recording_surface (context, spat->surface);
 973     else
 974         clone = _vg_clone_image_surface (context, spat->surface);
 975     if (clone == NULL)
 976         return CAIRO_INT_STATUS_UNSUPPORTED;
 977     if (unlikely (clone->base.status))
 978         return clone->base.status;
 979
 980     clone->snapshot_cache_entry.hash = clone->base.unique_id;
 981     status = _cairo_cache_insert (&context->snapshot_cache,
 982                                   &clone->snapshot_cache_entry);
 983     if (unlikely (status)) {
 984         clone->snapshot_cache_entry.hash = 0;
 985         cairo_surface_destroy (&clone->base);
 986         return status;
 987     }
 988
 989     _cairo_surface_attach_snapshot (spat->surface, &clone->base,
 990                                     _vg_surface_remove_from_cache);
 991
 992 DONE:
 993     cairo_surface_destroy (&context->source->base);
 994     context->source = clone;
 995
 996     vgSetParameteri (context->paint, VG_PAINT_TYPE, VG_PAINT_TYPE_PATTERN);
 997
 998     switch (spat->base.extend) {
 999     case CAIRO_EXTEND_PAD:
1000         vgSetParameteri (context->paint,
1001                          VG_PAINT_PATTERN_TILING_MODE,
1002                          VG_TILE_PAD);
1003         break;
1004
1005     case CAIRO_EXTEND_NONE:
1006         vgSetParameteri (context->paint,
1007                          VG_PAINT_PATTERN_TILING_MODE,
1008                          VG_TILE_FILL);
1009         {
1010             VGfloat color[] = {0,0,0,0};
1011             vgSetfv (VG_TILE_FILL_COLOR, 4, color);
1012         }
1013         break;
1014
1015     case CAIRO_EXTEND_REPEAT:
1016         vgSetParameteri (context->paint,
1017                          VG_PAINT_PATTERN_TILING_MODE,
1018                          VG_TILE_REPEAT);
1019         break;
1020
1021     default:
1022         ASSERT_NOT_REACHED;
1023     case CAIRO_EXTEND_REFLECT:
1024         vgSetParameteri (context->paint,
1025                          VG_PAINT_PATTERN_TILING_MODE,
1026                          VG_TILE_REFLECT);
1027         break;
1028     }
1029     vgPaintPattern (context->paint, context->source->image);
1030
1031     _vg_set_source_matrix (&spat->base);
1032
1033     CHECK_VG_ERRORS();
1034     return CAIRO_STATUS_SUCCESS;
1035 }
1036
1037 static cairo_status_t
1038 setup_source (cairo_vg_context_t *context,
1039               const cairo_pattern_t *source)
1040 {
1041     switch (source->type) {
1042     case CAIRO_PATTERN_TYPE_SOLID:
1043         return _vg_setup_solid_source (context,
1044                                        (cairo_solid_pattern_t *) source);
1045     case CAIRO_PATTERN_TYPE_LINEAR:
1046         return _vg_setup_linear_source (context,
1047                                         (cairo_linear_pattern_t *) source);
1048     case CAIRO_PATTERN_TYPE_RADIAL:
1049         return _vg_setup_radial_source (context,
1050                                         (cairo_radial_pattern_t *) source);
1051     case CAIRO_PATTERN_TYPE_SURFACE:
1052         return _vg_setup_surface_source (context,
1053                                          (cairo_surface_pattern_t *) source);
1054     default:
1055         ASSERT_NOT_REACHED;
1056         return CAIRO_INT_STATUS_UNSUPPORTED;
1057     }
1058 }
1059
1060 static cairo_int_status_t
1061 _vg_surface_stroke (void                       *abstract_surface,
1062                     cairo_operator_t            op,
1063                     const cairo_pattern_t      *source,
1064                     const cairo_path_fixed_t   *path,
1065                     const cairo_stroke_style_t *style,
1066                     const cairo_matrix_t       *ctm,
1067                     const cairo_matrix_t       *ctm_inverse,
1068                     double                      tolerance,
1069                     cairo_antialias_t           antialias,
1070                     const cairo_clip_t         *clip)
1071 {
1072     cairo_vg_surface_t *surface = abstract_surface;
1073     cairo_vg_context_t *context;
1074     cairo_status_t status;
1075     VGfloat state[9];
1076     VGfloat strokeTransform[9];
1077     vg_path_t vg_path;
1078
1079     if (! _vg_is_supported_operator (op))
1080         return CAIRO_INT_STATUS_UNSUPPORTED;
1081
1082     context = _vg_context_lock (surface->context);
1083     status = _vg_context_set_target (context, surface);
1084     if (status) {
1085         _vg_context_unlock (context);
1086         return status;
1087     }
1088
1089     status = setup_source (context, source);
1090     if (status) {
1091         _vg_context_unlock (context);
1092         return status;
1093     }
1094
1095     status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
1096     if (unlikely (status)) {
1097         _vg_context_unlock (context);
1098         return status;
1099     }
1100
1101     vg_path.path = vgCreatePath (VG_PATH_FORMAT_STANDARD,
1102                                  VG_PATH_DATATYPE_F,
1103                                  1, 0, 0, 0,
1104                                  VG_PATH_CAPABILITY_ALL);
1105
1106     vgGetMatrix (state);
1107     _vg_matrix_from_cairo (strokeTransform, ctm);
1108     vgMultMatrix (strokeTransform);
1109
1110     vg_path.ctm_inverse = ctm_inverse;
1111
1112     _vg_path_from_cairo (&vg_path, path);
1113
1114     /* XXX DASH_PATTERN, DASH_PHASE */
1115     vgSetf (VG_STROKE_LINE_WIDTH, style->line_width);
1116     vgSetf (VG_STROKE_MITER_LIMIT, style->miter_limit);
1117     vgSetf (VG_STROKE_JOIN_STYLE, _vg_line_join_from_cairo (style->line_join));
1118     vgSetf (VG_STROKE_CAP_STYLE, _vg_line_cap_from_cairo (style->line_cap));
1119
1120     vgSeti (VG_BLEND_MODE, _vg_operator (op));
1121
1122     vgSetPaint (context->paint, VG_STROKE_PATH);
1123
1124     vgDrawPath (vg_path.path, VG_STROKE_PATH);
1125
1126     vgDestroyPath (vg_path.path);
1127
1128     vgLoadMatrix (state);
1129
1130     CHECK_VG_ERRORS();
1131     _vg_context_unlock (context);
1132
1133     return CAIRO_STATUS_SUCCESS;
1134 }
1135
1136 static cairo_int_status_t
1137 _vg_surface_fill (void                     *abstract_surface,
1138                   cairo_operator_t          op,
1139                   const cairo_pattern_t    *source,
1140                   const cairo_path_fixed_t *path,
1141                   cairo_fill_rule_t         fill_rule,
1142                   double                    tolerance,
1143                   cairo_antialias_t         antialias,
1144                   const cairo_clip_t       *clip)
1145 {
1146     cairo_vg_surface_t *surface = abstract_surface;
1147     cairo_vg_context_t *context;
1148     cairo_status_t status;
1149     vg_path_t vg_path;
1150
1151     if (op == CAIRO_OPERATOR_DEST)
1152         return CAIRO_STATUS_SUCCESS;
1153
1154     if (! _vg_is_supported_operator (op))
1155         return CAIRO_INT_STATUS_UNSUPPORTED;
1156
1157     context = _vg_context_lock (surface->context);
1158     status = _vg_context_set_target (context, surface);
1159     if (status) {
1160         _vg_context_unlock (context);
1161         return status;
1162     }
1163
1164     status = setup_source (context, source);
1165     if (status) {
1166         _vg_context_unlock (context);
1167         return status;
1168     }
1169
1170     status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
1171     if (unlikely (status)) {
1172         _vg_context_unlock (context);
1173         return status;
1174     }
1175
1176     vg_path.path = vgCreatePath (VG_PATH_FORMAT_STANDARD,
1177                                  VG_PATH_DATATYPE_F,
1178                                  1, 0,
1179                                  0, 0,
1180                                  VG_PATH_CAPABILITY_ALL);
1181     vg_path.ctm_inverse = NULL;
1182
1183     _vg_path_from_cairo (&vg_path, path);
1184
1185     /* XXX tolerance */
1186
1187     vgSeti (VG_BLEND_MODE, _vg_operator (op));
1188     vgSetf (VG_FILL_RULE, _vg_fill_rule_from_cairo (fill_rule));
1189     vgSetf (VG_RENDERING_QUALITY, _vg_rendering_quality_from_cairo (antialias));
1190
1191     vgSetPaint (context->paint, VG_FILL_PATH);
1192
1193     vgDrawPath (vg_path.path, VG_FILL_PATH);
1194
1195     vgDestroyPath (vg_path.path);
1196
1197     _vg_context_unlock (context);
1198
1199     CHECK_VG_ERRORS();
1200     return CAIRO_STATUS_SUCCESS;
1201 }
1202
1203 static cairo_int_status_t
1204 _vg_surface_paint (void                  *abstract_surface,
1205                    cairo_operator_t       op,
1206                    const cairo_pattern_t *source,
1207                    const cairo_clip_t    *clip)
1208 {
1209     cairo_vg_surface_t *surface = abstract_surface;
1210     cairo_vg_context_t *context;
1211     cairo_status_t status;
1212
1213     if (op == CAIRO_OPERATOR_DEST)
1214         return CAIRO_STATUS_SUCCESS;
1215
1216     if (! _vg_is_supported_operator (op))
1217         return CAIRO_INT_STATUS_UNSUPPORTED;
1218
1219     context = _vg_context_lock (surface->context);
1220     status = _vg_context_set_target (context, surface);
1221     if (status) {
1222         _vg_context_unlock (context);
1223         return status;
1224     }
1225
1226     status = setup_source (context, source);
1227     if (status) {
1228         _vg_context_unlock (context);
1229         return status;
1230     }
1231
1232     status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
1233     if (unlikely (status)) {
1234         _vg_context_unlock (context);
1235         return status;
1236     }
1237
1238     vgSeti (VG_BLEND_MODE, _vg_operator (op));
1239     vgSetPaint (context->paint, VG_FILL_PATH);
1240
1241     { /* creating a rectangular path that should cover the extent */
1242         VGubyte segs[] = {
1243             VG_MOVE_TO_ABS, VG_LINE_TO_ABS,
1244             VG_LINE_TO_ABS, VG_LINE_TO_ABS,
1245             VG_CLOSE_PATH
1246         };
1247         VGfloat data[] = {
1248             0, 0,
1249             surface->width, 0,
1250             surface->width, surface->height,
1251             0, surface->height
1252         };
1253         VGPath fullext;
1254
1255         fullext = vgCreatePath (VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
1256                                 1,0,0,0, VG_PATH_CAPABILITY_ALL);
1257         vgAppendPathData (fullext, sizeof(segs), segs, data);
1258
1259         vgDrawPath (fullext, VG_FILL_PATH);
1260
1261         vgDestroyPath (fullext);
1262     }
1263
1264     _vg_context_unlock (context);
1265
1266     CHECK_VG_ERRORS();
1267     return CAIRO_STATUS_SUCCESS;
1268 }
1269
1270 static cairo_int_status_t
1271 _vg_surface_mask (void                   *abstract_surface,
1272                   cairo_operator_t        op,
1273                   const cairo_pattern_t  *source,
1274                   const cairo_pattern_t  *mask,
1275                   const cairo_clip_t     *clip)
1276 {
1277     cairo_vg_surface_t *surface = abstract_surface;
1278     cairo_status_t status;
1279
1280     if (! _vg_is_supported_operator (op))
1281         return CAIRO_INT_STATUS_UNSUPPORTED;
1282
1283     /* Handle paint-with-alpha to do fades cheaply */
1284     if (mask->type == CAIRO_PATTERN_TYPE_SOLID) {
1285         cairo_solid_pattern_t *solid = (cairo_solid_pattern_t *) mask;
1286         cairo_vg_context_t *context = _vg_context_lock (surface->context);
1287         double alpha = context->alpha;
1288
1289         context->alpha = solid->color.alpha;
1290         status = _vg_surface_paint (abstract_surface, op, source, clip);
1291         context->alpha = alpha;
1292
1293         _vg_context_unlock (context);
1294
1295         return status;
1296     }
1297
1298     return CAIRO_INT_STATUS_UNSUPPORTED;
1299 }
1300
1301 static void
1302 _vg_surface_get_font_options (void                  *abstract_surface,
1303                               cairo_font_options_t  *options)
1304 {
1305     _cairo_font_options_init_default (options);
1306
1307     cairo_font_options_set_hint_metrics (options, CAIRO_HINT_METRICS_ON);
1308     _cairo_font_options_set_round_glyph_positions (options, CAIRO_ROUND_GLYPH_POS_OFF);
1309 }
1310
1311 static cairo_int_status_t
1312 _vg_surface_show_glyphs (void                   *abstract_surface,
1313                          cairo_operator_t        op,
1314                          const cairo_pattern_t  *source,
1315                          cairo_glyph_t          *glyphs,
1316                          int                     num_glyphs,
1317                          cairo_scaled_font_t    *scaled_font,
1318                          const cairo_clip_t     *clip)
1319 {
1320     cairo_status_t status = CAIRO_STATUS_SUCCESS;
1321     cairo_path_fixed_t path;
1322
1323     if (num_glyphs <= 0)
1324         return CAIRO_STATUS_SUCCESS;
1325
1326     _cairo_path_fixed_init (&path);
1327
1328     /* XXX Glyph cache! OpenVG font support in 1.1? */
1329
1330     status = _cairo_scaled_font_glyph_path (scaled_font,
1331                                             glyphs, num_glyphs,
1332                                             &path);
1333     if (unlikely (status))
1334         goto BAIL;
1335
1336     status = _vg_surface_fill (abstract_surface,
1337                                op, source, &path,
1338                                CAIRO_FILL_RULE_WINDING,
1339                                CAIRO_GSTATE_TOLERANCE_DEFAULT,
1340                                CAIRO_ANTIALIAS_DEFAULT,
1341                                clip);
1342 BAIL:
1343     _cairo_path_fixed_fini (&path);
1344     return status;
1345 }
1346
1347 static inline int
1348 multiply_alpha (int alpha, int color)
1349 {
1350     int temp = alpha * color + 0x80;
1351     return (temp + (temp >> 8)) >> 8;
1352 }
1353
1354 static void
1355 premultiply_argb (uint8_t   *data,
1356                   int        width,
1357                   int        height,
1358                   int        stride)
1359 {
1360     int i;
1361
1362     while (height --) {
1363         uint32_t *row = (uint32_t *) data;
1364
1365         for (i = 0; i < width; i++) {
1366             uint32_t p = row[i];
1367             uint8_t  alpha;
1368
1369             alpha = p >> 24;
1370             if (alpha == 0) {
1371                  row[i] = 0;
1372             } else if (alpha != 0xff) {
1373                 uint8_t r = multiply_alpha (alpha, (p >> 16) & 0xff);
1374                 uint8_t g = multiply_alpha (alpha, (p >>  8) & 0xff);
1375                 uint8_t b = multiply_alpha (alpha, (p >>  0) & 0xff);
1376                 row[i] = (alpha << 24) | (r << 16) | (g << 8) | (b << 0);
1377             }
1378         }
1379
1380         data += stride;
1381     }
1382 }
1383
1384 static cairo_int_status_t
1385 _vg_get_image (cairo_vg_surface_t *surface,
1386                int x, int y,
1387                int width, int height,
1388                cairo_image_surface_t **image_out)
1389 {
1390     cairo_image_surface_t *image;
1391     pixman_image_t *pixman_image;
1392     pixman_format_code_t pixman_format;
1393     cairo_bool_t needs_premultiply;
1394
1395     pixman_format = _vg_format_to_pixman (surface->format,
1396                                           &needs_premultiply);
1397     if (pixman_format == 0)
1398         return CAIRO_INT_STATUS_UNSUPPORTED;
1399
1400     pixman_image = pixman_image_create_bits (pixman_format,
1401                                              width, height,
1402                                              NULL, 0);
1403     if (unlikely (pixman_image == NULL))
1404         return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1405
1406     vgFinish ();
1407     CHECK_VG_ERRORS();
1408
1409     vgGetImageSubData (surface->image,
1410                        pixman_image_get_data (pixman_image),
1411                        pixman_image_get_stride (pixman_image),
1412                        surface->format,
1413                        x, y, width, height);
1414
1415     image = (cairo_image_surface_t *)
1416         _cairo_image_surface_create_for_pixman_image (pixman_image,
1417                                                       pixman_format);
1418     if (unlikely (image->base.status)) {
1419         pixman_image_unref (pixman_image);
1420         return image->base.status;
1421     }
1422
1423     if (needs_premultiply)
1424         premultiply_argb (image->data, width, height, image->stride);
1425
1426     *image_out = image;
1427     return CAIRO_STATUS_SUCCESS;
1428 }
1429
1430 static cairo_status_t
1431 _vg_surface_acquire_source_image (void *abstract_surface,
1432                                   cairo_image_surface_t **image_out,
1433                                   void                  **image_extra)
1434 {
1435     cairo_vg_surface_t *surface = abstract_surface;
1436
1437     CHECK_VG_ERRORS();
1438     *image_extra = NULL;
1439     return _vg_get_image (surface,
1440                           0, 0, surface->width, surface->height,
1441                           image_out);
1442 }
1443
1444 static void
1445 _vg_surface_release_source_image (void                    *abstract_surface,
1446                                   cairo_image_surface_t   *image,
1447                                   void                    *image_extra)
1448 {
1449     cairo_surface_destroy (&image->base);
1450 }
1451
1452 static cairo_status_t
1453 _vg_surface_finish (void *abstract_surface)
1454 {
1455     cairo_vg_surface_t *surface = abstract_surface;
1456     cairo_vg_context_t *context = _vg_context_lock (surface->context);
1457
1458     if (surface->snapshot_cache_entry.hash) {
1459         _cairo_cache_remove (&context->snapshot_cache,
1460                              &surface->snapshot_cache_entry);
1461
1462         surface->snapshot_cache_entry.hash = 0;
1463     }
1464
1465     _cairo_surface_clipper_reset (&surface->clipper);
1466
1467     if (surface->own_image)
1468         vgDestroyImage (surface->image);
1469
1470     _vg_context_destroy_target (context, surface);
1471
1472     _vg_context_unlock (context);
1473     _vg_context_destroy (context);
1474
1475     CHECK_VG_ERRORS();
1476     return CAIRO_STATUS_SUCCESS;
1477 }
1478
1479 static const cairo_surface_backend_t cairo_vg_surface_backend = {
1480     CAIRO_SURFACE_TYPE_VG,
1481     _vg_surface_finish,
1482
1483     _cairo_default_context_create, /* XXX */
1484
1485     _vg_surface_create_similar,
1486     NULL, /* create similar image */
1487     NULL, /* map to image */
1488     NULL, /* unmap image */
1489
1490     _cairo_surface_default_source,
1491     _vg_surface_acquire_source_image,
1492     _vg_surface_release_source_image,
1493     NULL, /* snapshot */
1494
1495     NULL, /* copy_page */
1496     NULL, /* show_page */
1497
1498     _vg_surface_get_extents,
1499     _vg_surface_get_font_options, /* get_font_options */
1500
1501     NULL, /* flush */
1502     NULL, /* mark dirty */
1503
1504     _vg_surface_paint,
1505     _vg_surface_mask,
1506     _vg_surface_stroke,
1507     _vg_surface_fill,
1508     NULL, /* fill-stroke */
1509     _vg_surface_show_glyphs,
1510 };
1511
1512 static cairo_surface_t *
1513 _vg_surface_create_internal (cairo_vg_context_t *context,
1514                              VGImage image,
1515                              VGImageFormat format,
1516                              int width, int height)
1517 {
1518     cairo_vg_surface_t *surface;
1519
1520     surface = malloc (sizeof (cairo_vg_surface_t));
1521     if (unlikely (surface == NULL))
1522         return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
1523
1524     surface->context = _vg_context_reference (context);
1525
1526     surface->image  = image;
1527     surface->format = format;
1528
1529     _cairo_surface_init (&surface->base,
1530                          &cairo_vg_surface_backend,
1531                          NULL, /* device */
1532                          _vg_format_to_content (format));
1533
1534     surface->width  = width;
1535     surface->height = height;
1536
1537     _cairo_surface_clipper_init (&surface->clipper,
1538                                  _vg_surface_clipper_intersect_clip_path);
1539
1540     surface->snapshot_cache_entry.hash = 0;
1541
1542     surface->target_id = 0;
1543
1544     CHECK_VG_ERRORS();
1545     return &surface->base;
1546 }
1547
1548 cairo_surface_t *
1549 cairo_vg_surface_create_for_image (cairo_vg_context_t *context,
1550                                    VGImage image,
1551                                    VGImageFormat format,
1552                                    int width, int height)
1553 {
1554     cairo_bool_t premult;
1555
1556     if (context->status)
1557         return _cairo_surface_create_in_error (context->status);
1558
1559     if (image == VG_INVALID_HANDLE)
1560         return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
1561     if (_vg_format_to_pixman (format, &premult) == 0)
1562         return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_FORMAT));
1563
1564     return _vg_surface_create_internal (context, image, format, width, height);
1565 }
1566
1567 cairo_surface_t *
1568 cairo_vg_surface_create (cairo_vg_context_t *context,
1569                          cairo_content_t  content,
1570                          int              width,
1571                          int              height)
1572 {
1573     VGImage image;
1574     VGImageFormat format;
1575     cairo_surface_t *surface;
1576
1577     if (context->status)
1578         return _cairo_surface_create_in_error (context->status);
1579
1580     if (! CAIRO_CONTENT_VALID (content))
1581         return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_CONTENT));
1582
1583     if (width > vgGeti (VG_MAX_IMAGE_WIDTH) ||
1584         height > vgGeti (VG_MAX_IMAGE_HEIGHT))
1585     {
1586         return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE));
1587     }
1588
1589
1590     format = _vg_format_for_content (content);
1591     image = vgCreateImage (format, width, height, VG_IMAGE_QUALITY_BETTER);
1592     if (image == VG_INVALID_HANDLE)
1593         return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
1594
1595     surface = _vg_surface_create_internal (context,
1596                                            image, format, width, height);
1597     if (unlikely (surface->status))
1598         return surface;
1599
1600     ((cairo_vg_surface_t *) surface)->own_image = TRUE;
1601     return surface;
1602 }
1603 slim_hidden_def (cairo_vg_surface_create);
1604
1605 VGImage
1606 cairo_vg_surface_get_image (cairo_surface_t *abstract_surface)
1607 {
1608     cairo_vg_surface_t *surface;
1609
1610     if (abstract_surface->backend != &cairo_vg_surface_backend) {
1611         _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
1612         return VG_INVALID_HANDLE;
1613     }
1614
1615     surface = (cairo_vg_surface_t *) abstract_surface;
1616     return surface->image;
1617 }
1618
1619 int
1620 cairo_vg_surface_get_width (cairo_surface_t *abstract_surface)
1621 {
1622     cairo_vg_surface_t *surface;
1623
1624     if (abstract_surface->backend != &cairo_vg_surface_backend) {
1625         _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
1626         return 0;
1627     }
1628
1629     surface = (cairo_vg_surface_t *) abstract_surface;
1630     return surface->width;
1631 }
1632
1633 int
1634 cairo_vg_surface_get_height (cairo_surface_t *abstract_surface)
1635 {
1636     cairo_vg_surface_t *surface;
1637
1638     if (abstract_surface->backend != &cairo_vg_surface_backend) {
1639         _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
1640         return 0;
1641     }
1642
1643     surface = (cairo_vg_surface_t *) abstract_surface;
1644     return surface->height;
1645 }
1646
1647 VGImageFormat
1648 cairo_vg_surface_get_format (cairo_surface_t *abstract_surface)
1649 {
1650     cairo_vg_surface_t *surface;
1651
1652     if (abstract_surface->backend != &cairo_vg_surface_backend) {
1653         _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
1654         return 0;
1655     }
1656
1657     surface = (cairo_vg_surface_t *) abstract_surface;
1658     return surface->format;
1659 }
1660
1661 /* GL specific context support :-(
1662  *
1663  * OpenVG like cairo defers creation of surface (and the necessary
1664  * paraphernalia to the application.
1665  */
1666
1667 static const cairo_vg_context_t _vg_context_nil = {
1668     CAIRO_STATUS_NO_MEMORY,
1669     CAIRO_REFERENCE_COUNT_INVALID
1670 };
1671
1672 static const cairo_vg_context_t _vg_context_nil_invalid_visual = {
1673     CAIRO_STATUS_INVALID_VISUAL,
1674     CAIRO_REFERENCE_COUNT_INVALID
1675 };
1676
1677 #if CAIRO_HAS_GLX_FUNCTIONS
1678 #include <GL/glx.h>
1679
1680 static cairo_status_t
1681 glx_create_target (cairo_vg_context_t *context,
1682                    cairo_vg_surface_t *surface)
1683 {
1684     /* XXX hmm, magic required for creating an FBO points to VGImage! */
1685     return CAIRO_INT_STATUS_UNSUPPORTED;
1686 }
1687
1688 static cairo_status_t
1689 glx_set_target (cairo_vg_context_t *context,
1690                 cairo_vg_surface_t *surface)
1691 {
1692 #if 0
1693     glXMakeContextCurrent (context->display,
1694                            (GLXDrawable) surface->target_id,
1695                            (GLXDrawable) surface->target_id,
1696                            context->context);
1697 #else
1698     return CAIRO_INT_STATUS_UNSUPPORTED;
1699 #endif
1700 }
1701
1702 static void
1703 glx_destroy_target (cairo_vg_context_t *context,
1704                     cairo_vg_surface_t *surface)
1705 {
1706 }
1707
1708 cairo_vg_context_t *
1709 cairo_vg_context_create_for_glx (Display *dpy, GLXContext ctx)
1710 {
1711     cairo_vg_context_t *context;
1712     cairo_status_t status;
1713
1714     context = malloc (sizeof (*context));
1715     if (unlikely (context == NULL))
1716         return (cairo_vg_context_t *) &_vg_context_nil;
1717
1718     context->display = dpy;
1719     context->context = ctx;
1720
1721     context->create_target  = glx_create_target;
1722     context->set_target     = glx_set_target;
1723     context->destroy_target = glx_destroy_target;
1724
1725     status = _vg_context_init (context);
1726     if (unlikely (status)) {
1727         free (context);
1728         return (cairo_vg_context_t *) &_vg_context_nil;
1729     }
1730
1731     return context;
1732 }
1733 #endif
1734
1735 #if CAIRO_HAS_EGL_FUNCTIONS
1736 static cairo_status_t
1737 egl_create_target (cairo_vg_context_t *context,
1738                    cairo_vg_surface_t *surface)
1739 {
1740     EGLSurface *egl_surface;
1741 #define RED 1
1742 #define GREEN 3
1743 #define BLUE 5
1744 #define ALPHA 7
1745     int attribs[] = {
1746         EGL_RED_SIZE, 0,
1747         EGL_GREEN_SIZE, 0,
1748         EGL_BLUE_SIZE, 0,
1749         EGL_ALPHA_SIZE, 0,
1750         EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
1751         EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,
1752         EGL_NONE
1753     };
1754     pixman_format_code_t pixman_format;
1755     EGLConfig config;
1756     int num_configs = 0;
1757     cairo_bool_t needs_premultiply;
1758
1759     pixman_format = _vg_format_to_pixman (surface->format, &needs_premultiply);
1760     if (pixman_format == 0)
1761         return CAIRO_INT_STATUS_UNSUPPORTED;
1762
1763     /* XXX no control over pixel ordering! */
1764     attribs[RED]   = PIXMAN_FORMAT_R (pixman_format);
1765     attribs[GREEN] = PIXMAN_FORMAT_G (pixman_format);
1766     attribs[BLUE]  = PIXMAN_FORMAT_B (pixman_format);
1767     attribs[ALPHA] = PIXMAN_FORMAT_A (pixman_format);
1768
1769     if (! eglChooseConfig (context->display,
1770                            attribs,
1771                            &config, 1, &num_configs) ||
1772         num_configs != 1)
1773     {
1774         fprintf(stderr, "Error: eglChooseConfig() failed.\n");
1775         return CAIRO_INT_STATUS_UNSUPPORTED;
1776     }
1777
1778     egl_surface =
1779         eglCreatePbufferFromClientBuffer (context->display,
1780                                           EGL_OPENVG_IMAGE,
1781                                           (EGLClientBuffer) surface->image,
1782                                           config,
1783                                           NULL);
1784     surface->target_id = (unsigned long) egl_surface;
1785
1786     return CAIRO_STATUS_SUCCESS;
1787 }
1788
1789 static cairo_status_t
1790 egl_set_target (cairo_vg_context_t *context,
1791                 cairo_vg_surface_t *surface)
1792 {
1793     if (! eglMakeCurrent (context->display,
1794                           (EGLSurface *) surface->target_id,
1795                           (EGLSurface *) surface->target_id,
1796                           context->context))
1797     {
1798         return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1799     }
1800
1801     return CAIRO_STATUS_SUCCESS;
1802 }
1803
1804 static void
1805 egl_destroy_target (cairo_vg_context_t *context,
1806                     cairo_vg_surface_t *surface)
1807 {
1808     eglDestroySurface (context->display,
1809                        (EGLSurface *) surface->target_id);
1810 }
1811
1812 cairo_vg_context_t *
1813 cairo_vg_context_create_for_egl (EGLDisplay egl_display,
1814                                  EGLContext egl_context)
1815 {
1816     cairo_vg_context_t *context;
1817     cairo_status_t status;
1818
1819     context = malloc (sizeof (*context));
1820     if (unlikely (context == NULL))
1821         return (cairo_vg_context_t *) &_vg_context_nil;
1822
1823     status = _vg_context_init (context);
1824     if (unlikely (status)) {
1825         free (context);
1826         return (cairo_vg_context_t *) &_vg_context_nil;
1827     }
1828
1829     context->display = egl_display;
1830     context->context = egl_context;
1831
1832     context->create_target  = egl_create_target;
1833     context->set_target     = egl_set_target;
1834     context->destroy_target = egl_destroy_target;
1835
1836     return context;
1837 }
1838 #endif
1839
1840 cairo_status_t
1841 cairo_vg_context_status (cairo_vg_context_t *context)
1842 {
1843     return context->status;
1844 }
1845
1846 void
1847 cairo_vg_context_destroy (cairo_vg_context_t *context)
1848 {
1849     if (context == NULL || CAIRO_REFERENCE_COUNT_IS_INVALID (&context->ref_count))
1850         return;
1851
1852     _vg_context_destroy (context);
1853 }