diff options
225 files changed, 27475 insertions, 17885 deletions
diff --git a/boilerplate/cairo-boilerplate-test-surfaces.c b/boilerplate/cairo-boilerplate-test-surfaces.c index 909475b3..f7a89a72 100644 --- a/boilerplate/cairo-boilerplate-test-surfaces.c +++ b/boilerplate/cairo-boilerplate-test-surfaces.c @@ -30,66 +30,133 @@ #include <cairo-types-private.h> -#include <test-fallback-surface.h> -#include <test-fallback16-surface.h> +#include <test-compositor-surface.h> +#include <test-null-compositor-surface.h> #if CAIRO_HAS_TEST_PAGINATED_SURFACE #include <test-paginated-surface.h> #endif -#if CAIRO_HAS_TEST_NULL_SURFACE -#include <test-null-surface.h> -#endif -#if CAIRO_HAS_TEST_WRAPPING_SURFACE -#include <test-wrapping-surface.h> -#endif static cairo_surface_t * -_cairo_boilerplate_test_fallback_create_surface (const char *name, - cairo_content_t content, - double width, - double height, - double max_width, - double max_height, - cairo_boilerplate_mode_t mode, - int id, - void **closure) +_cairo_boilerplate_test_base_compositor_create_surface (const char *name, + cairo_content_t content, + double width, + double height, + double max_width, + double max_height, + cairo_boilerplate_mode_t mode, + int id, + void **closure) { *closure = NULL; - return _cairo_test_fallback_surface_create (content, - ceil (width), ceil (height)); + return _cairo_test_base_compositor_surface_create (content, ceil (width), ceil (height)); } + static cairo_surface_t * -_cairo_boilerplate_test_fallback16_create_surface (const char *name, - cairo_content_t content, - double width, - double height, - double max_width, - double max_height, - cairo_boilerplate_mode_t mode, - int id, - void **closure) +_cairo_boilerplate_test_fallback_compositor_create_surface (const char *name, + cairo_content_t content, + double width, + double height, + double max_width, + double max_height, + cairo_boilerplate_mode_t mode, + int id, + void **closure) { *closure = NULL; - return _cairo_test_fallback16_surface_create (content, - ceil (width), ceil (height)); + return _cairo_test_fallback_compositor_surface_create (content, ceil (width), ceil (height)); } -#if CAIRO_HAS_TEST_NULL_SURFACE static cairo_surface_t * -_cairo_boilerplate_test_null_create_surface (const char *name, - cairo_content_t content, - double width, - double height, - double max_width, - double max_height, - cairo_boilerplate_mode_t mode, - int id, - void **closure) +_cairo_boilerplate_test_mask_compositor_create_surface (const char *name, + cairo_content_t content, + double width, + double height, + double max_width, + double max_height, + cairo_boilerplate_mode_t mode, + int id, + void **closure) { *closure = NULL; - return _cairo_test_null_surface_create (content); + return _cairo_test_mask_compositor_surface_create (content, ceil (width), ceil (height)); +} + + +static cairo_surface_t * +_cairo_boilerplate_test_traps_compositor_create_surface (const char *name, + cairo_content_t content, + double width, + double height, + double max_width, + double max_height, + cairo_boilerplate_mode_t mode, + int id, + void **closure) +{ + *closure = NULL; + return _cairo_test_traps_compositor_surface_create (content, ceil (width), ceil (height)); +} + +static cairo_surface_t * +_cairo_boilerplate_test_spans_compositor_create_surface (const char *name, + cairo_content_t content, + double width, + double height, + double max_width, + double max_height, + cairo_boilerplate_mode_t mode, + int id, + void **closure) +{ + *closure = NULL; + return _cairo_test_spans_compositor_surface_create (content, ceil (width), ceil (height)); +} + +static cairo_surface_t * +_cairo_boilerplate_test_no_fallback_compositor_create_surface (const char *name, + cairo_content_t content, + double width, + double height, + double max_width, + double max_height, + cairo_boilerplate_mode_t mode, + int id, + void **closure) +{ + *closure = NULL; + return _cairo_test_no_fallback_compositor_surface_create (content, ceil (width), ceil (height)); +} + +static cairo_surface_t * +_cairo_boilerplate_test_no_traps_compositor_create_surface (const char *name, + cairo_content_t content, + double width, + double height, + double max_width, + double max_height, + cairo_boilerplate_mode_t mode, + int id, + void **closure) +{ + *closure = NULL; + return _cairo_test_no_traps_compositor_surface_create (content, ceil (width), ceil (height)); +} + +static cairo_surface_t * +_cairo_boilerplate_test_no_spans_compositor_create_surface (const char *name, + cairo_content_t content, + double width, + double height, + double max_width, + double max_height, + cairo_boilerplate_mode_t mode, + int id, + void **closure) +{ + *closure = NULL; + return _cairo_test_no_spans_compositor_surface_create (content, ceil (width), ceil (height)); } -#endif #if CAIRO_HAS_TEST_PAGINATED_SURFACE static const cairo_user_data_key_t test_paginated_closure_key; @@ -201,40 +268,38 @@ _cairo_boilerplate_test_paginated_cleanup (void *closure) } #endif -#if CAIRO_HAS_TEST_WRAPPING_SURFACE -static cairo_surface_t * -_cairo_boilerplate_test_wrapping_create_surface (const char *name, - cairo_content_t content, - double width, - double height, - double max_width, - double max_height, - cairo_boilerplate_mode_t mode, - int id, - void **closure) -{ - cairo_surface_t *target; - cairo_surface_t *surface; - cairo_format_t format; - - *closure = NULL; - - format = cairo_boilerplate_format_from_content (content); - target = cairo_image_surface_create (format, ceil (width), ceil (height)); - surface = _cairo_test_wrapping_surface_create (target); - cairo_surface_destroy (target); - - return surface; -} -#endif - static const cairo_boilerplate_target_t targets[] = { { + "test-base", "image", NULL, NULL, + CAIRO_SURFACE_TYPE_IMAGE, + CAIRO_CONTENT_COLOR_ALPHA, 0, + "_cairo_test_base_compositor_surface_create", + _cairo_boilerplate_test_base_compositor_create_surface, + cairo_surface_create_similar, + NULL, NULL, + _cairo_boilerplate_get_image_surface, + cairo_surface_write_to_png, + NULL, NULL, NULL, TRUE, FALSE, FALSE + }, + { + "test-base", "image", NULL, NULL, + CAIRO_SURFACE_TYPE_IMAGE, + CAIRO_CONTENT_COLOR, 0, + "_cairo_test_base_compositor_surface_create", + _cairo_boilerplate_test_base_compositor_create_surface, + cairo_surface_create_similar, + NULL, NULL, + _cairo_boilerplate_get_image_surface, + cairo_surface_write_to_png, + NULL, NULL, NULL, FALSE, FALSE, FALSE + }, + + { "test-fallback", "image", NULL, NULL, - CAIRO_INTERNAL_SURFACE_TYPE_TEST_FALLBACK, + CAIRO_SURFACE_TYPE_IMAGE, CAIRO_CONTENT_COLOR_ALPHA, 0, - "_cairo_test_fallback_surface_create", - _cairo_boilerplate_test_fallback_create_surface, + "_cairo_test_fallback_compositor_surface_create", + _cairo_boilerplate_test_fallback_compositor_create_surface, cairo_surface_create_similar, NULL, NULL, _cairo_boilerplate_get_image_surface, @@ -243,40 +308,128 @@ static const cairo_boilerplate_target_t targets[] = { }, { "test-fallback", "image", NULL, NULL, - CAIRO_INTERNAL_SURFACE_TYPE_TEST_FALLBACK, + CAIRO_SURFACE_TYPE_IMAGE, CAIRO_CONTENT_COLOR, 0, - "_cairo_test_fallback_surface_create", - _cairo_boilerplate_test_fallback_create_surface, + "_cairo_test_fallback_compositor_surface_create", + _cairo_boilerplate_test_fallback_compositor_create_surface, cairo_surface_create_similar, NULL, NULL, _cairo_boilerplate_get_image_surface, cairo_surface_write_to_png, NULL, NULL, NULL, FALSE, FALSE, FALSE }, + { - "test-fallback16", "image", NULL, NULL, - CAIRO_INTERNAL_SURFACE_TYPE_TEST_FALLBACK, + "test-mask", "mask", NULL, NULL, + CAIRO_SURFACE_TYPE_IMAGE, CAIRO_CONTENT_COLOR_ALPHA, 0, - "_cairo_test_fallback16_surface_create", - _cairo_boilerplate_test_fallback16_create_surface, + "_cairo_test_traps_compositor_surface_create", + _cairo_boilerplate_test_mask_compositor_create_surface, cairo_surface_create_similar, NULL, NULL, - NULL, /* _cairo_boilerplate_get_image_surface, */ + _cairo_boilerplate_get_image_surface, + cairo_surface_write_to_png, + NULL, NULL, NULL, TRUE, FALSE, FALSE + }, + { + "test-mask", "mask", NULL, NULL, + CAIRO_SURFACE_TYPE_IMAGE, + CAIRO_CONTENT_COLOR, 0, + "_cairo_test_mask_compositor_surface_create", + _cairo_boilerplate_test_mask_compositor_create_surface, + cairo_surface_create_similar, + NULL, NULL, + _cairo_boilerplate_get_image_surface, cairo_surface_write_to_png, NULL, NULL, NULL, FALSE, FALSE, FALSE }, + { - "test-fallback16", "image", NULL, NULL, - CAIRO_INTERNAL_SURFACE_TYPE_TEST_FALLBACK, + "test-traps", "traps", NULL, NULL, + CAIRO_SURFACE_TYPE_IMAGE, + CAIRO_CONTENT_COLOR_ALPHA, 0, + "_cairo_test_traps_compositor_surface_create", + _cairo_boilerplate_test_traps_compositor_create_surface, + cairo_surface_create_similar, + NULL, NULL, + _cairo_boilerplate_get_image_surface, + cairo_surface_write_to_png, + NULL, NULL, NULL, TRUE, FALSE, FALSE + }, + { + "test-traps", "traps", NULL, NULL, + CAIRO_SURFACE_TYPE_IMAGE, CAIRO_CONTENT_COLOR, 0, - "_cairo_test_fallback16_surface_create", - _cairo_boilerplate_test_fallback16_create_surface, + "_cairo_test_traps_compositor_surface_create", + _cairo_boilerplate_test_traps_compositor_create_surface, + cairo_surface_create_similar, + NULL, NULL, + _cairo_boilerplate_get_image_surface, + cairo_surface_write_to_png, + NULL, NULL, NULL, FALSE, FALSE, FALSE + }, + + { + "test-spans", "spans", NULL, NULL, + CAIRO_SURFACE_TYPE_IMAGE, + CAIRO_CONTENT_COLOR_ALPHA, 0, + "_cairo_test_spans_compositor_surface_create", + _cairo_boilerplate_test_spans_compositor_create_surface, + cairo_surface_create_similar, + NULL, NULL, + _cairo_boilerplate_get_image_surface, + cairo_surface_write_to_png, + NULL, NULL, NULL, TRUE, FALSE, FALSE + }, + { + "test-spans", "spans", NULL, NULL, + CAIRO_SURFACE_TYPE_IMAGE, + CAIRO_CONTENT_COLOR, 0, + "_cairo_test_spans_compositor_surface_create", + _cairo_boilerplate_test_spans_compositor_create_surface, + cairo_surface_create_similar, + NULL, NULL, + _cairo_boilerplate_get_image_surface, + cairo_surface_write_to_png, + NULL, NULL, NULL, FALSE, FALSE, FALSE + }, + + { + "no-fallback", "image", NULL, NULL, + CAIRO_SURFACE_TYPE_IMAGE, + CAIRO_CONTENT_COLOR_ALPHA, 0, + "_cairo_test_no_fallback_compositor_surface_create", + _cairo_boilerplate_test_no_fallback_compositor_create_surface, cairo_surface_create_similar, NULL, NULL, - NULL, /* _cairo_boilerplate_get_image_surface, */ + _cairo_boilerplate_get_image_surface, cairo_surface_write_to_png, NULL, NULL, NULL, FALSE, FALSE, FALSE }, + { + "no-traps", "traps", NULL, NULL, + CAIRO_SURFACE_TYPE_IMAGE, + CAIRO_CONTENT_COLOR_ALPHA, 0, + "_cairo_test_no_traps_compositor_surface_create", + _cairo_boilerplate_test_no_traps_compositor_create_surface, + cairo_surface_create_similar, + NULL, NULL, + _cairo_boilerplate_get_image_surface, + cairo_surface_write_to_png, + NULL, NULL, NULL, TRUE, FALSE, FALSE + }, + { + "no-spans", "spans", NULL, NULL, + CAIRO_SURFACE_TYPE_IMAGE, + CAIRO_CONTENT_COLOR_ALPHA, 0, + "_cairo_test_no_spans_compositor_surface_create", + _cairo_boilerplate_test_no_spans_compositor_create_surface, + cairo_surface_create_similar, + NULL, NULL, + _cairo_boilerplate_get_image_surface, + cairo_surface_write_to_png, + NULL, NULL, NULL, TRUE, FALSE, FALSE + }, #if CAIRO_HAS_TEST_PAGINATED_SURFACE { "test-paginated", "image", NULL, NULL, @@ -305,33 +458,5 @@ static const cairo_boilerplate_target_t targets[] = { NULL, NULL, FALSE, TRUE, FALSE }, #endif -#if CAIRO_HAS_TEST_WRAPPING_SURFACE - { - "test-wrapping", "image", NULL, NULL, - CAIRO_INTERNAL_SURFACE_TYPE_TEST_WRAPPING, - CAIRO_CONTENT_COLOR_ALPHA, 0, - "_cairo_test_wrapping_surface_create", - _cairo_boilerplate_test_wrapping_create_surface, - cairo_surface_create_similar, - NULL, NULL, - _cairo_boilerplate_get_image_surface, - cairo_surface_write_to_png, - NULL, NULL, NULL, FALSE, FALSE, FALSE - }, -#endif -#if CAIRO_HAS_TEST_NULL_SURFACE - { - "null", "image", NULL, NULL, - CAIRO_INTERNAL_SURFACE_TYPE_NULL, - CAIRO_CONTENT_COLOR_ALPHA, 0, - "_cairo_test_null_surface_create", - _cairo_boilerplate_test_null_create_surface, - cairo_surface_create_similar, - NULL, NULL, - NULL, NULL, NULL, - NULL, NULL, - TRUE, TRUE, FALSE - }, -#endif }; CAIRO_BOILERPLATE (test, targets) diff --git a/boilerplate/cairo-boilerplate-xlib.c b/boilerplate/cairo-boilerplate-xlib.c index 6818cafd..cad28847 100644 --- a/boilerplate/cairo-boilerplate-xlib.c +++ b/boilerplate/cairo-boilerplate-xlib.c @@ -31,7 +31,6 @@ #if CAIRO_HAS_XLIB_XRENDER_SURFACE #include <cairo-xlib-xrender.h> #endif -#include <cairo-xlib-surface-private.h> #include <X11/Xutil.h> /* for XDestroyImage */ @@ -412,6 +411,7 @@ _cairo_boilerplate_xlib_window_create_surface (const char *name, cairo_status_t cairo_boilerplate_xlib_surface_disable_render (cairo_surface_t *abstract_surface) { +#if 0 /* The following stunt doesn't work with xlib-xcb because it doesn't use * cairo_xlib_surface_t for its surfaces. Sadly, there is no sane * alternative, so we can't disable render with xlib-xcb. @@ -440,6 +440,7 @@ cairo_boilerplate_xlib_surface_disable_render (cairo_surface_t *abstract_surface surface->buggy_repeat = TRUE; #endif #endif +#endif return CAIRO_STATUS_SUCCESS; } diff --git a/boilerplate/cairo-boilerplate.c b/boilerplate/cairo-boilerplate.c index 229c4c77..8e252f52 100644 --- a/boilerplate/cairo-boilerplate.c +++ b/boilerplate/cairo-boilerplate.c @@ -683,16 +683,12 @@ cairo_boilerplate_get_image_target (cairo_content_t content) if (cairo_boilerplate_targets == NULL) _cairo_boilerplate_register_all (); - for (list = cairo_boilerplate_targets; list != NULL; list = list->next) { - const cairo_boilerplate_target_t *target = list->target; - if (target->expected_type == CAIRO_SURFACE_TYPE_IMAGE && - target->content == content) - { - return target; - } + switch (content) { + default: + case CAIRO_CONTENT_ALPHA: return NULL; + case CAIRO_CONTENT_COLOR: return &builtin_targets[1]; + case CAIRO_CONTENT_COLOR_ALPHA: return &builtin_targets[0]; } - - return NULL; } const cairo_boilerplate_target_t * diff --git a/configure.ac b/configure.ac index 4b85c8a7..5879a444 100644 --- a/configure.ac +++ b/configure.ac @@ -202,11 +202,11 @@ CAIRO_ENABLE_SURFACE_BACKEND(skia, Skia, no, [ [skia_DIR="`pwd`/../skia"]) AC_ARG_WITH([skia-bulid], [AS_HELP_STRING([--with-skia-build=(Release|Debug)] - [build of skia to link with, default is Relese])], + [build of skia to link with, default is Release])], [skia_BUILD="$withval"], [skia_BUILD="Release"]) skia_NONPKGCONFIG_CFLAGS="-I$skia_DIR/include/config -I$skia_DIR/include/core -I$skia_DIR/include/effects" - if test "x$(skia_BUILD)" = x"Relese"; then + if test "x$skia_BUILD" = x"Release"; then skia_NONPKGCONFIG_CFLAGS="-DSK_RELEASE -DSK_CAN_USE_FLOAT $skia_NONPKGCONFIG_CFLAGS" fi skia_NONPKGCONFIG_LIBS="--start-group $skia_DIR/out/$skia_BUILD/obj.target/gyp/libeffects.a $skia_DIR/out/$skia_BUILD/obj.target/gyp/libimages.a $skia_DIR/out/$skia_BUILD/obj.target/gyp/libutils.a $skia_DIR/out/$skia_BUILD/obj.target/gyp/libopts.a $skia_DIR/out/$skia_BUILD/obj.target/gyp/libcore.a -end-group" diff --git a/perf/Makefile.sources b/perf/Makefile.sources index b99234b2..1fcf1480 100644 --- a/perf/Makefile.sources +++ b/perf/Makefile.sources @@ -1,5 +1,6 @@ libcairoperf_sources = \ - cairo-perf.c \ + cairo-perf.c \ + cairo-perf-report.c \ cairo-stats.c \ $(NULL) diff --git a/perf/cairo-perf-compare-backends.c b/perf/cairo-perf-compare-backends.c index 16306377..2cbb24c5 100644 --- a/perf/cairo-perf-compare-backends.c +++ b/perf/cairo-perf-compare-backends.c @@ -73,7 +73,7 @@ print_change_bar (double change, double max_change, int use_utf) { - int units_per_cell = (int) ceil (max_change / CHANGE_BAR_WIDTH); + int units_per_cell = ceil (max_change / CHANGE_BAR_WIDTH); static char const *ascii_boxes[8] = { "****","***" ,"***", "**", "**", "*", "*", "" @@ -369,7 +369,7 @@ main (int argc, if (args.num_filenames) { reports = xcalloc (args.num_filenames, sizeof (cairo_perf_report_t)); for (i = 0; i < args.num_filenames; i++) { - cairo_perf_report_load (&reports[i], args.filenames[i], + cairo_perf_report_load (&reports[i], args.filenames[i], i, test_report_cmp_name); printf ("loaded: %s, %d tests\n", args.filenames[i], reports[i].tests_count); @@ -377,7 +377,7 @@ main (int argc, } else { args.num_filenames = 1; reports = xcalloc (args.num_filenames, sizeof (cairo_perf_report_t)); - cairo_perf_report_load (&reports[0], NULL, test_report_cmp_name); + cairo_perf_report_load (&reports[0], NULL, 0, test_report_cmp_name); } cairo_perf_reports_compare (reports, args.num_filenames, &args.options); diff --git a/perf/cairo-perf-diff-files.c b/perf/cairo-perf-diff-files.c index 34311b04..08509271 100644 --- a/perf/cairo-perf-diff-files.c +++ b/perf/cairo-perf-diff-files.c @@ -161,16 +161,14 @@ test_diff_print_binary (test_diff_t *diff, else printf ("%5s %26s", diff->tests[0]->backend, diff->tests[0]->name); - if (diff->tests[0]->size) { - printf (" %6.2f (%.2f %4.2f%%) -> %6.2f (%.2f %4.2f%%): %5.2fx ", - diff->tests[0]->stats.min_ticks / diff->tests[0]->stats.ticks_per_ms, - diff->tests[0]->stats.median_ticks / diff->tests[0]->stats.ticks_per_ms, - diff->tests[0]->stats.std_dev * 100, - diff->tests[1]->stats.min_ticks / diff->tests[1]->stats.ticks_per_ms, - diff->tests[1]->stats.median_ticks / diff->tests[1]->stats.ticks_per_ms, - diff->tests[1]->stats.std_dev * 100, - fabs (diff->change)); - } + printf (" %6.2f (%.2f %4.2f%%) -> %6.2f (%.2f %4.2f%%): %5.2fx ", + diff->tests[0]->stats.min_ticks / diff->tests[0]->stats.ticks_per_ms, + diff->tests[0]->stats.median_ticks / diff->tests[0]->stats.ticks_per_ms, + diff->tests[0]->stats.std_dev * 100, + diff->tests[1]->stats.min_ticks / diff->tests[1]->stats.ticks_per_ms, + diff->tests[1]->stats.median_ticks / diff->tests[1]->stats.ticks_per_ms, + diff->tests[1]->stats.std_dev * 100, + fabs (diff->change)); if (diff->change > 1.0) printf ("speedup\n"); @@ -191,24 +189,32 @@ test_diff_print_multi (test_diff_t *diff, double test_time; double change; - printf ("%s (backend: %s-%s, size: %d)\n", - diff->tests[0]->name, - diff->tests[0]->backend, - diff->tests[0]->content, - diff->tests[0]->size); + if (diff->tests[0]->size) { + printf ("%s (backend: %s-%s, size: %d)\n", + diff->tests[0]->name, + diff->tests[0]->backend, + diff->tests[0]->content, + diff->tests[0]->size); + } else { + printf ("%s (backend: %s)\n", + diff->tests[0]->name, + diff->tests[0]->backend); + } for (i = 0; i < diff->num_tests; i++) { test_time = diff->tests[i]->stats.min_ticks; if (! options->use_ticks) test_time /= diff->tests[i]->stats.ticks_per_ms; change = diff->max / test_time; - printf ("%8s %6.2f: %5.2fx ", - diff->tests[i]->configuration, + printf ("[%d] %6.2f: %5.2fx ", + diff->tests[i]->fileno, diff->tests[i]->stats.min_ticks / diff->tests[i]->stats.ticks_per_ms, change); if (options->print_change_bars) print_change_bar (change, max_change, options->use_utf); + else + printf("\n"); } printf("\n"); @@ -476,8 +482,11 @@ main (int argc, reports = xmalloc (args.num_filenames * sizeof (cairo_perf_report_t)); - for (i = 0; i < args.num_filenames; i++ ) - cairo_perf_report_load (&reports[i], args.filenames[i], NULL); + for (i = 0; i < args.num_filenames; i++ ) { + cairo_perf_report_load (&reports[i], args.filenames[i], i, NULL); + printf ("[%d] %s\n", i, args.filenames[i]); + } + printf ("\n"); cairo_perf_reports_compare (reports, args.num_filenames, &args.options); diff --git a/perf/cairo-perf-micro.c b/perf/cairo-perf-micro.c index 096986bc..f3c6f8d9 100644 --- a/perf/cairo-perf-micro.c +++ b/perf/cairo-perf-micro.c @@ -50,12 +50,13 @@ #define CAIRO_PERF_ITERATIONS_DEFAULT 100 #define CAIRO_PERF_LOW_STD_DEV 0.03 -#define CAIRO_PERF_STABLE_STD_DEV_COUNT 5 -#define CAIRO_PERF_ITERATION_MS_DEFAULT 2000 +#define CAIRO_PERF_STABLE_STD_DEV_COUNT 5 +#define CAIRO_PERF_ITERATION_MS_DEFAULT 2000 #define CAIRO_PERF_ITERATION_MS_FAST 5 typedef struct _cairo_perf_case { - CAIRO_PERF_DECL (*run); + CAIRO_PERF_RUN_DECL (*run); + cairo_bool_t (*enabled) (cairo_perf_t *perf); unsigned int min_size; unsigned int max_size; } cairo_perf_case_t; @@ -251,7 +252,7 @@ cairo_perf_run (cairo_perf_t *perf, cairo_boilerplate_content (perf->target->content)); else cairo_save (perf->cr); - times[i] = perf_func (perf->cr, perf->size, perf->size, loops) / loops; + times[i] = perf_func (perf->cr, perf->size, perf->size, loops) ; if (similar) cairo_pattern_destroy (cairo_pop_group (perf->cr)); else @@ -263,7 +264,7 @@ cairo_perf_run (cairo_perf_t *perf, _content_to_string (perf->target->content, similar), name, perf->size, _cairo_time_to_double (_cairo_time_from_s (1.)) / 1000.); - printf (" %lld", (long long) times[i]); + printf (" %lld", (long long) (times[i] / (double) loops)); } else if (! perf->exact_iterations) { if (i > 0) { _cairo_stats_compute (&stats, times, i+1); @@ -287,18 +288,18 @@ cairo_perf_run (cairo_perf_t *perf, if (count_func != NULL) { double count = count_func (perf->cr, perf->size, perf->size); fprintf (perf->summary, - "%10lld %#8.3f %#8.3f %#5.2f%% %3d: %.2f\n", - (long long) stats.min_ticks, - _cairo_time_to_s (stats.min_ticks) * 1000.0, - _cairo_time_to_s (stats.median_ticks) * 1000.0, + "%10lld/%d %#8.3f %#8.3f %#5.2f%% %3d: %.2f\n", + (long long) stats.min_ticks, loops, + _cairo_time_to_s (stats.min_ticks) * 1000.0 / loops, + _cairo_time_to_s (stats.median_ticks) * 1000.0 / loops, stats.std_dev * 100.0, stats.iterations, count / _cairo_time_to_s (stats.min_ticks)); } else { fprintf (perf->summary, - "%10lld %#8.3f %#8.3f %#5.2f%% %3d\n", - (long long) stats.min_ticks, - _cairo_time_to_s (stats.min_ticks) * 1000.0, - _cairo_time_to_s (stats.median_ticks) * 1000.0, + "%10lld/%d %#8.3f %#8.3f %#5.2f%% %3d\n", + (long long) stats.min_ticks, loops, + _cairo_time_to_s (stats.min_ticks) * 1000.0 / loops, + _cairo_time_to_s (stats.median_ticks) * 1000.0 / loops, stats.std_dev * 100.0, stats.iterations); } fflush (perf->summary); @@ -491,6 +492,9 @@ main (int argc, for (j = 0; perf_cases[j].run; j++) { const cairo_perf_case_t *perf_case = &perf_cases[j]; + if (! perf_case->enabled (&perf)) + continue; + for (perf.size = perf_case->min_size; perf.size <= perf_case->max_size; perf.size *= 2) @@ -536,42 +540,48 @@ main (int argc, return 0; } +#define FUNC(f) f, f##_enabled const cairo_perf_case_t perf_cases[] = { - { paint, 64, 512}, - { paint_with_alpha, 64, 512}, - { fill, 64, 512}, - { stroke, 64, 512}, - { text, 64, 512}, - { glyphs, 64, 512}, - { mask, 64, 512}, - { line, 32, 512}, - { curve, 32, 512}, - { disjoint, 64, 512}, - { hatching, 64, 512}, - { tessellate, 100, 100}, - { subimage_copy, 16, 512}, - { hash_table, 16, 16}, - { pattern_create_radial, 16, 16}, - { zrusin, 415, 415}, - { world_map, 800, 800}, - { box_outline, 100, 100}, - { mosaic, 800, 800 }, - { long_lines, 100, 100}, - { unaligned_clip, 100, 100}, - { rectangles, 512, 512}, - { rounded_rectangles, 512, 512}, - { long_dashed_lines, 512, 512}, - { composite_checker, 16, 512}, - { twin, 800, 800}, - { dragon, 1024, 1024 }, - { pythagoras_tree, 768, 768 }, - { intersections, 512, 512 }, - { many_strokes, 32, 512 }, - { wide_strokes, 32, 512 }, - { many_fills, 32, 512 }, - { wide_fills, 32, 512 }, - { many_curves, 32, 512 }, - { spiral, 512, 512 }, - { wave, 500, 500 }, + { FUNC(pixel), 1, 1 }, + { FUNC(paint), 64, 512}, + { FUNC(paint_with_alpha), 64, 512}, + { FUNC(fill), 64, 512}, + { FUNC(stroke), 64, 512}, + { FUNC(text), 64, 512}, + { FUNC(glyphs), 64, 512}, + { FUNC(mask), 64, 512}, + { FUNC(line), 32, 512}, + { FUNC(a1_line), 32, 512}, + { FUNC(curve), 32, 512}, + { FUNC(a1_curve), 32, 512}, + { FUNC(disjoint), 64, 512}, + { FUNC(hatching), 64, 512}, + { FUNC(tessellate), 100, 100}, + { FUNC(subimage_copy), 16, 512}, + { FUNC(hash_table), 16, 16}, + { FUNC(pattern_create_radial), 16, 16}, + { FUNC(zrusin), 415, 415}, + { FUNC(world_map), 800, 800}, + { FUNC(box_outline), 100, 100}, + { FUNC(mosaic), 800, 800 }, + { FUNC(long_lines), 100, 100}, + { FUNC(unaligned_clip), 100, 100}, + { FUNC(rectangles), 512, 512}, + { FUNC(rounded_rectangles), 512, 512}, + { FUNC(long_dashed_lines), 512, 512}, + { FUNC(composite_checker), 16, 512}, + { FUNC(twin), 800, 800}, + { FUNC(dragon), 1024, 1024 }, + { FUNC(sierpinski), 32, 1024 }, + { FUNC(pythagoras_tree), 768, 768 }, + { FUNC(intersections), 512, 512 }, + { FUNC(many_strokes), 32, 512 }, + { FUNC(wide_strokes), 32, 512 }, + { FUNC(many_fills), 32, 512 }, + { FUNC(wide_fills), 32, 512 }, + { FUNC(many_curves), 32, 512 }, + { FUNC(spiral), 512, 512 }, + { FUNC(wave), 500, 500 }, + { FUNC(fill_clip), 16, 512 }, { NULL } }; diff --git a/perf/cairo-perf-report.c b/perf/cairo-perf-report.c index fcce0e03..8df78c64 100644 --- a/perf/cairo-perf-report.c +++ b/perf/cairo-perf-report.c @@ -110,6 +110,7 @@ do { \ static test_report_status_t test_report_parse (test_report_t *report, + int fileno, char *line, char *configuration) { @@ -137,6 +138,7 @@ test_report_parse (test_report_t *report, skip_space (); + report->fileno = fileno; report->configuration = configuration; parse_string (report->backend); end = strrchr (report->backend, '.'); @@ -369,7 +371,7 @@ cairo_perf_report_sort_and_compute_stats (cairo_perf_report_t *report, void cairo_perf_report_load (cairo_perf_report_t *report, - const char *filename, + const char *filename, int id, int (*cmp) (const void *, const void *)) { FILE *file; @@ -401,6 +403,7 @@ cairo_perf_report_load (cairo_perf_report_t *report, report->tests_size = 16; report->tests = xmalloc (report->tests_size * sizeof (test_report_t)); report->tests_count = 0; + report->fileno = id; if (filename == NULL) { file = stdin; @@ -425,7 +428,7 @@ cairo_perf_report_load (cairo_perf_report_t *report, break; status = test_report_parse (&report->tests[report->tests_count], - line, report->configuration); + id, line, report->configuration); if (status == TEST_REPORT_STATUS_ERROR) fprintf (stderr, "Ignoring unrecognized line %d of %s:\n%s", line_number, filename, line); diff --git a/perf/cairo-perf-trace.c b/perf/cairo-perf-trace.c index 2cef2b14..8e637a7d 100644 --- a/perf/cairo-perf-trace.c +++ b/perf/cairo-perf-trace.c @@ -79,7 +79,7 @@ basename_no_ext (char *path) name = basename (path); - dot = strchr (name, '.'); + dot = strrchr (name, '.'); if (dot) *dot = '\0'; @@ -108,6 +108,7 @@ struct trace { void *closure; cairo_surface_t *surface; cairo_bool_t observe; + int tile_size; }; cairo_bool_t @@ -132,7 +133,7 @@ cairo_perf_can_run (cairo_perf_t *perf, return TRUE; copy = xstrdup (name); - dot = strchr (copy, '.'); + dot = strrchr (copy, '.'); if (dot != NULL) *dot = '\0'; @@ -435,6 +436,7 @@ parse_options (cairo_perf_t *perf, perf->raw = FALSE; perf->observe = FALSE; perf->list_only = FALSE; + perf->tile_size = 0; perf->names = NULL; perf->num_names = 0; perf->summary = stdout; @@ -443,7 +445,7 @@ parse_options (cairo_perf_t *perf, perf->num_exclude_names = 0; while (1) { - c = _cairo_getopt (argc, argv, "i:x:lsrvc"); + c = _cairo_getopt (argc, argv, "t:i:x:lsrvc"); if (c == -1) break; @@ -457,6 +459,14 @@ parse_options (cairo_perf_t *perf, exit (1); } break; + case 't': + perf->tile_size = strtoul (optarg, &end, 10); + if (*end != '\0') { + fprintf (stderr, "Invalid argument for -t (not an integer): %s\n", + optarg); + exit (1); + } + break; case 'l': perf->list_only = TRUE; break; @@ -489,6 +499,11 @@ parse_options (cairo_perf_t *perf, } } + if (perf->observe && perf->tile_size) { + fprintf (stderr, "Can't mix observer and tiling. Sorry.\n"); + exit (1); + } + if (verbose && perf->summary == NULL) perf->summary = stderr; #if HAVE_UNISTD_H @@ -536,6 +551,79 @@ have_trace_filenames (cairo_perf_t *perf) } static void +_tiling_surface_finish (cairo_surface_t *observer, + cairo_surface_t *target, + void *closure) +{ + struct trace *args = closure; + cairo_surface_t *surface; + cairo_content_t content; + cairo_rectangle_t r; + int width, height; + int x, y, w, h; + + cairo_recording_surface_get_extents (target, &r); + w = r.width; + h = r.height; + + content = cairo_surface_get_content (target); + + for (y = 0; y < h; y += args->tile_size) { + height = args->tile_size; + if (y + height > h) + height = h - y; + + for (x = 0; x < w; x += args->tile_size) { + cairo_t *cr; + + width = args->tile_size; + if (x + width > w) + width = w - x; + + /* XXX to correctly observe the playback we would need + * to replay the target onto the observer directly. + */ + surface = args->target->create_similar (args->surface, + content, width, height); + + cr = cairo_create (surface); + cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); + cairo_set_source_surface (cr, target, -x, -y); + cairo_paint (cr); + cairo_destroy (cr); + + cairo_surface_destroy (surface); + } + } +} + +static cairo_surface_t * +_tiling_surface_create (void *closure, + cairo_content_t content, + double width, + double height, + long uid) +{ + cairo_rectangle_t r; + cairo_surface_t *surface, *observer; + + r.x = r.y = 0; + r.width = width; + r.height = height; + + surface = cairo_recording_surface_create (content, &r); + observer = cairo_surface_create_observer (surface, + CAIRO_SURFACE_OBSERVER_NORMAL); + cairo_surface_destroy (surface); + + cairo_surface_observer_add_finish_callback (observer, + _tiling_surface_finish, + closure); + + return observer; +} + +static void cairo_perf_trace (cairo_perf_t *perf, const cairo_boilerplate_target_t *target, const char *trace) @@ -549,7 +637,7 @@ cairo_perf_trace (cairo_perf_t *perf, char *trace_cpy, *name; const cairo_script_interpreter_hooks_t hooks = { &args, - _similar_surface_create, + perf->tile_size ? _tiling_surface_create : _similar_surface_create, NULL, /* surface_destroy */ _context_create, NULL, /* context_destroy */ @@ -557,6 +645,7 @@ cairo_perf_trace (cairo_perf_t *perf, NULL /* copy_page */ }; + args.tile_size = perf->tile_size; args.observe = perf->observe; trace_cpy = xstrdup (trace); @@ -648,26 +737,30 @@ cairo_perf_trace (cairo_perf_t *perf, } cairo_script_interpreter_run (csi, trace); + line_no = cairo_script_interpreter_get_line_number (csi); + + /* Finish before querying timings in case we are using an intermediate + * target and so need to destroy all surfaces before rendering + * commences. + */ + cairo_script_interpreter_finish (csi); if (perf->observe) { cairo_device_t *observer = cairo_surface_get_device (args.surface); - times[i] = _cairo_time_from_s (1.e9 * cairo_device_observer_elapsed (observer)); - paint[i] = _cairo_time_from_s (1.e9 * cairo_device_observer_paint_elapsed (observer)); - mask[i] = _cairo_time_from_s (1.e9 * cairo_device_observer_mask_elapsed (observer)); - stroke[i] = _cairo_time_from_s (1.e9 * cairo_device_observer_stroke_elapsed (observer)); - fill[i] = _cairo_time_from_s (1.e9 * cairo_device_observer_fill_elapsed (observer)); - glyphs[i] = _cairo_time_from_s (1.e9 * cairo_device_observer_glyphs_elapsed (observer)); + times[i] = _cairo_time_from_s (1.e-9 * cairo_device_observer_elapsed (observer)); + paint[i] = _cairo_time_from_s (1.e-9 * cairo_device_observer_paint_elapsed (observer)); + mask[i] = _cairo_time_from_s (1.e-9 * cairo_device_observer_mask_elapsed (observer)); + stroke[i] = _cairo_time_from_s (1.e-9 * cairo_device_observer_stroke_elapsed (observer)); + fill[i] = _cairo_time_from_s (1.e-9 * cairo_device_observer_fill_elapsed (observer)); + glyphs[i] = _cairo_time_from_s (1.e-9 * cairo_device_observer_glyphs_elapsed (observer)); } else { clear_surface (args.surface); /* queue a write to the sync'ed surface */ cairo_perf_timer_stop (); times[i] = cairo_perf_timer_elapsed (); } - cairo_script_interpreter_finish (csi); scache_clear (); - line_no = cairo_script_interpreter_get_line_number (csi); - cairo_surface_destroy (args.surface); if (target->cleanup) @@ -766,28 +859,28 @@ cairo_perf_trace (cairo_perf_t *perf, fprintf (perf->summary, " %#9.3f", _cairo_time_to_s (stats.median_ticks)); - _cairo_stats_compute (&stats, paint, i+1); + _cairo_stats_compute (&stats, paint, i); fprintf (perf->summary, " %#9.3f", _cairo_time_to_s (stats.median_ticks)); - _cairo_stats_compute (&stats, mask, i+1); + _cairo_stats_compute (&stats, mask, i); fprintf (perf->summary, " %#9.3f", _cairo_time_to_s (stats.median_ticks)); - _cairo_stats_compute (&stats, fill, i+1); + _cairo_stats_compute (&stats, fill, i); fprintf (perf->summary, " %#9.3f", _cairo_time_to_s (stats.median_ticks)); - _cairo_stats_compute (&stats, stroke, i+1); + _cairo_stats_compute (&stats, stroke, i); fprintf (perf->summary, " %#9.3f", _cairo_time_to_s (stats.median_ticks)); - _cairo_stats_compute (&stats, glyphs, i+1); + _cairo_stats_compute (&stats, glyphs, i); fprintf (perf->summary, " %#9.3f", _cairo_time_to_s (stats.median_ticks)); fprintf (perf->summary, - " %5d\n", i+1); + " %5d\n", i); } else { fprintf (perf->summary, "%#8.3f %#8.3f %#6.2f%% %4d/%d\n", @@ -807,11 +900,6 @@ out: perf->test_number++; free (trace_cpy); - - cairo_debug_reset_static_data (); -#if HAVE_FCFINI - FcFini (); -#endif } static void diff --git a/perf/cairo-perf.h b/perf/cairo-perf.h index 11c03f75..d6a71ccb 100644 --- a/perf/cairo-perf.h +++ b/perf/cairo-perf.h @@ -83,6 +83,8 @@ typedef struct _cairo_perf { double ms_per_iteration; cairo_bool_t fast_and_sloppy; + unsigned int tile_size; + /* Stuff used internally */ cairo_time_t *times; const cairo_boilerplate_target_t **targets; @@ -121,6 +123,7 @@ cairo_perf_cover_sources_and_operators (cairo_perf_t *perf, typedef struct _test_report { int id; + int fileno; const char *configuration; char *backend; char *content; @@ -149,6 +152,7 @@ typedef struct _test_diff { typedef struct _cairo_perf_report { char *configuration; const char *name; + int fileno; test_report_t *tests; int tests_size; int tests_count; @@ -162,7 +166,7 @@ typedef enum { void cairo_perf_report_load (cairo_perf_report_t *report, - const char *filename, + const char *filename, int id, int (*cmp) (const void *, const void *)); void @@ -177,7 +181,10 @@ int test_report_cmp_name (const void *a, const void *b); -#define CAIRO_PERF_DECL(func) void (func) (cairo_perf_t *perf, cairo_t *cr, int width, int height) +#define CAIRO_PERF_ENABLED_DECL(func) cairo_bool_t (func ## _enabled) (cairo_perf_t *perf) +#define CAIRO_PERF_RUN_DECL(func) void (func) (cairo_perf_t *perf, cairo_t *cr, int width, int height) + +#define CAIRO_PERF_DECL(func) CAIRO_PERF_RUN_DECL(func); CAIRO_PERF_ENABLED_DECL(func) CAIRO_PERF_DECL (fill); CAIRO_PERF_DECL (paint); @@ -214,6 +221,11 @@ CAIRO_PERF_DECL (many_fills); CAIRO_PERF_DECL (wide_fills); CAIRO_PERF_DECL (many_curves); CAIRO_PERF_DECL (curve); +CAIRO_PERF_DECL (a1_curve); CAIRO_PERF_DECL (line); +CAIRO_PERF_DECL (a1_line); +CAIRO_PERF_DECL (pixel); +CAIRO_PERF_DECL (sierpinski); +CAIRO_PERF_DECL (fill_clip); #endif diff --git a/perf/cairo-stats.c b/perf/cairo-stats.c index e088e198..c422d6cc 100644 --- a/perf/cairo-stats.c +++ b/perf/cairo-stats.c @@ -25,16 +25,25 @@ #include "cairo-stats.h" +#include <assert.h> + void _cairo_stats_compute (cairo_stats_t *stats, cairo_time_t *values, int num_values) { - int i; - cairo_time_t sumtime; - double sum, mean, delta, q1, q3, iqr; - double outlier_min, outlier_max; - int min_valid, num_valid; + cairo_time_t sum, mean, delta, q1, q3, iqr; + cairo_time_t outlier_min, outlier_max; + int i, min_valid, num_valid; + + assert (num_values > 0); + + if (num_values == 1) { + stats->min_ticks = stats->median_ticks = values[0]; + stats->std_dev = 0; + stats->iterations = 1; + return; + } /* First, identify any outliers, using the definition of "mild * outliers" from: @@ -48,44 +57,35 @@ _cairo_stats_compute (cairo_stats_t *stats, */ qsort (values, num_values, sizeof (cairo_time_t), _cairo_time_cmp); - q1 = _cairo_time_to_s (values[(1*num_values)/4]); - q3 = _cairo_time_to_s (values[(3*num_values)/4]); + q1 = values[1*num_values/4]; + q3 = values[3*num_values/4]; + /* XXX assumes we have native uint64_t */ iqr = q3 - q1; + outlier_min = q1 - 3 * iqr / 2; + outlier_max = q3 + 3 * iqr / 2; - outlier_min = _cairo_time_from_s (q1 - 1.5 * iqr); - outlier_max = _cairo_time_from_s (q3 + 1.5 * iqr); - - min_valid = 0; - while (min_valid < num_values && - _cairo_time_to_s (values[min_valid]) < outlier_min) - { - min_valid++; - } + for (i = 0; i < num_values && values[i] < outlier_min; i++) + ; + min_valid = i; - i = min_valid; - num_valid = 0; - while (i + num_valid < num_values && - _cairo_time_to_s (values[i+num_valid]) <= outlier_max) - { - num_valid++; - } + for (i = 0; i < num_values && values[i] <= outlier_max; i++) + ; + num_valid = i - min_valid; + assert(num_valid); stats->iterations = num_valid; stats->min_ticks = values[min_valid]; - - sumtime = _cairo_time_from_s (0); - for (i = min_valid; i < min_valid + num_valid; i++) { - sumtime = _cairo_time_add (sumtime, values[i]); - stats->min_ticks = _cairo_time_min (stats->min_ticks, values[i]); - } - - mean = _cairo_time_to_s (sumtime) / num_valid; stats->median_ticks = values[min_valid + num_valid / 2]; - sum = 0.0; + sum = 0; + for (i = min_valid; i < min_valid + num_valid; i++) + sum = _cairo_time_add (sum, values[i]); + mean = sum / num_valid; + + sum = 0; for (i = min_valid; i < min_valid + num_valid; i++) { - delta = _cairo_time_to_s (values[i]) - mean; + delta = values[i] - mean; sum += delta * delta; } diff --git a/perf/micro/Makefile.sources b/perf/micro/Makefile.sources index 0c2bca08..e72d44ad 100644 --- a/perf/micro/Makefile.sources +++ b/perf/micro/Makefile.sources @@ -7,6 +7,7 @@ libcairo_perf_micro_sources = \ hatching.c \ hash-table.c \ line.c \ + a1-line.c \ long-lines.c \ mosaic.c \ paint.c \ @@ -35,7 +36,11 @@ libcairo_perf_micro_sources = \ wide-fills.c \ many-curves.c \ curve.c \ + a1-curve.c \ spiral.c \ + pixel.c \ + sierpinski.c \ + fill-clip.c \ $(NULL) libcairo_perf_micro_headers = \ diff --git a/perf/micro/a1-curve.c b/perf/micro/a1-curve.c new file mode 100644 index 00000000..594c46d5 --- /dev/null +++ b/perf/micro/a1-curve.c @@ -0,0 +1,112 @@ +/* + * Copyright © 2011 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * Author: Chris Wilson <chris@chris-wilson.co.uk> + */ + +#include "cairo-perf.h" + +static uint32_t state; + +static double +uniform_random (double minval, double maxval) +{ + static uint32_t const poly = 0x9a795537U; + uint32_t n = 32; + while (n-->0) + state = 2*state < state ? (2*state ^ poly) : 2*state; + return minval + state * (maxval - minval) / 4294967296.0; +} + +static cairo_time_t +do_curve_stroke (cairo_t *cr, int width, int height, int loops) +{ + state = 0xc0ffee; + cairo_set_line_width (cr, 2.); + cairo_perf_timer_start (); + + while (loops--) { + double x1 = uniform_random (0, width); + double x2 = uniform_random (0, width); + double x3 = uniform_random (0, width); + double y1 = uniform_random (0, height); + double y2 = uniform_random (0, height); + double y3 = uniform_random (0, height); + cairo_move_to (cr, uniform_random (0, width), uniform_random (0, height)); + cairo_curve_to (cr, x1, y1, x2, y2, x3, y3); + cairo_stroke(cr); + } + + cairo_perf_timer_stop (); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +do_curve_fill (cairo_t *cr, int width, int height, int loops) +{ + state = 0xc0ffee; + cairo_perf_timer_start (); + + while (loops--) { + double x0 = uniform_random (0, width); + double x1 = uniform_random (0, width); + double x2 = uniform_random (0, width); + double x3 = uniform_random (0, width); + double xm = uniform_random (0, width); + double xn = uniform_random (0, width); + double y0 = uniform_random (0, height); + double y1 = uniform_random (0, height); + double y2 = uniform_random (0, height); + double y3 = uniform_random (0, height); + double ym = uniform_random (0, height); + double yn = uniform_random (0, height); + + cairo_move_to (cr, xm, ym); + cairo_curve_to (cr, x1, y1, x2, y2, xn, yn); + cairo_curve_to (cr, x3, y3, x0, y0, xm, ym); + cairo_close_path (cr); + + cairo_fill(cr); + } + + cairo_perf_timer_stop (); + + return cairo_perf_timer_elapsed (); +} + +cairo_bool_t +a1_curve_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "a1-curve", NULL); +} + +void +a1_curve (cairo_perf_t *perf, cairo_t *cr, int width, int height) +{ + cairo_set_source_rgb (cr, 1., 1., 1.); + cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE); + + cairo_perf_run (perf, "a1-curve-stroked", do_curve_stroke, NULL); + cairo_perf_run (perf, "a1-curve-filled", do_curve_fill, NULL); +} diff --git a/perf/micro/a1-line.c b/perf/micro/a1-line.c new file mode 100644 index 00000000..ae866021 --- /dev/null +++ b/perf/micro/a1-line.c @@ -0,0 +1,223 @@ +/* + * Copyright © 2011 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * Author: Chris Wilson <chris@chris-wilson.co.uk> + */ + +#include "cairo-perf.h" + +static cairo_time_t +horizontal (cairo_t *cr, int width, int height, int loops) +{ + double h = height/2 + .5; + + cairo_move_to (cr, 0, h); + cairo_line_to (cr, width, h); + + cairo_perf_timer_start (); + + while (loops--) + cairo_stroke_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +horizontal_hair (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_line_width (cr, 1.); + return horizontal (cr, width, height, loops); +} + +static cairo_time_t +horizontal_wide (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_line_width (cr, 5.); + return horizontal (cr, width, height, loops); +} + +static cairo_time_t +nearly_horizontal (cairo_t *cr, int width, int height, int loops) +{ + double h = height/2; + + cairo_move_to (cr, 0, h); + cairo_line_to (cr, width, h+1); + + cairo_perf_timer_start (); + + while (loops--) + cairo_stroke_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +nearly_horizontal_hair (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_line_width (cr, 1.); + return nearly_horizontal (cr, width, height, loops); +} + +static cairo_time_t +nearly_horizontal_wide (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_line_width (cr, 5.); + return nearly_horizontal (cr, width, height, loops); +} + + +static cairo_time_t +vertical (cairo_t *cr, int width, int height, int loops) +{ + double w = width/2 + .5; + + cairo_move_to (cr, w, 0); + cairo_line_to (cr, w, height); + + cairo_perf_timer_start (); + + while (loops--) + cairo_stroke_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +vertical_hair (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_line_width (cr, 1.); + return vertical (cr, width, height, loops); +} + +static cairo_time_t +vertical_wide (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_line_width (cr, 5.); + return vertical (cr, width, height, loops); +} + +static cairo_time_t +nearly_vertical (cairo_t *cr, int width, int height, int loops) +{ + double w = width/2; + + cairo_move_to (cr, w, 0); + cairo_line_to (cr, w+1, height); + + cairo_perf_timer_start (); + + while (loops--) + cairo_stroke_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +nearly_vertical_hair (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_line_width (cr, 1.); + return nearly_vertical (cr, width, height, loops); +} + +static cairo_time_t +nearly_vertical_wide (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_line_width (cr, 5.); + return nearly_vertical (cr, width, height, loops); +} + + +static cairo_time_t +diagonal (cairo_t *cr, int width, int height, int loops) +{ + cairo_move_to (cr, 0, 0); + cairo_line_to (cr, width, height); + + cairo_perf_timer_start (); + + while (loops--) + cairo_stroke_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +diagonal_hair (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_line_width (cr, 1.); + return diagonal (cr, width, height, loops); +} + +static cairo_time_t +diagonal_wide (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_line_width (cr, 5.); + return diagonal (cr, width, height, loops); +} + +cairo_bool_t +a1_line_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "a1-line", NULL); +} + +void +a1_line (cairo_perf_t *perf, cairo_t *cr, int width, int height) +{ + cairo_set_source_rgb (cr, 1., 1., 1.); + cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE); + + cairo_perf_run (perf, "a1-line-hh", horizontal_hair, NULL); + cairo_perf_run (perf, "a1-line-hw", horizontal_wide, NULL); + cairo_perf_run (perf, "a1-line-nhh", nearly_horizontal_hair, NULL); + cairo_perf_run (perf, "a1-line-nhw", nearly_horizontal_wide, NULL); + + cairo_perf_run (perf, "a1-line-vh", vertical_hair, NULL); + cairo_perf_run (perf, "a1-line-vw", vertical_wide, NULL); + cairo_perf_run (perf, "a1-line-nvh", nearly_vertical_hair, NULL); + cairo_perf_run (perf, "a1-line-nvw", nearly_vertical_wide, NULL); + + cairo_perf_run (perf, "a1-line-dh", diagonal_hair, NULL); + cairo_perf_run (perf, "a1-line-dw", diagonal_wide, NULL); +} diff --git a/perf/micro/box-outline.c b/perf/micro/box-outline.c index a0c47f77..1e654eb9 100644 --- a/perf/micro/box-outline.c +++ b/perf/micro/box-outline.c @@ -65,6 +65,55 @@ box_outline_stroke (cairo_t *cr, int width, int height, int loops) } static cairo_time_t +box_outline_alpha_stroke (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_source_rgb (cr, 0, 0, 1); /* blue */ + cairo_paint (cr); + + cairo_rectangle (cr, + 1.5, 1.5, + width - 3, height - 3); + cairo_set_line_width (cr, 1.0); + cairo_set_source_rgba (cr, 1, 0, 0, .5); /* red */ + + cairo_perf_timer_start (); + + while (loops--) + cairo_stroke_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +box_outline_aa_stroke (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_source_rgb (cr, 0, 0, 1); /* blue */ + cairo_paint (cr); + + cairo_translate (cr, .5, .5); + cairo_rectangle (cr, + 1.5, 1.5, + width - 3, height - 3); + cairo_set_line_width (cr, 1.0); + cairo_set_source_rgb (cr, 1, 0, 0); /* red */ + + cairo_perf_timer_start (); + + while (loops--) + cairo_stroke_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t box_outline_fill (cairo_t *cr, int width, int height, int loops) { cairo_set_source_rgb (cr, 0, 0, 1); /* blue */ @@ -91,12 +140,76 @@ box_outline_fill (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +static cairo_time_t +box_outline_alpha_fill (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_source_rgb (cr, 0, 0, 1); /* blue */ + cairo_paint (cr); + + cairo_rectangle (cr, + 1.0, 1.0, + width - 2, height - 2); + cairo_rectangle (cr, + 2.0, 2.0, + width - 4, height - 4); + cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD); + cairo_set_source_rgba (cr, 0, 1, 0, .5); /* green */ + + cairo_perf_timer_start (); + + while (loops--) + cairo_fill_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +box_outline_aa_fill (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_source_rgb (cr, 0, 0, 1); /* blue */ + cairo_paint (cr); + + cairo_translate (cr, .5, .5); + cairo_rectangle (cr, + 1.0, 1.0, + width - 2, height - 2); + cairo_rectangle (cr, + 2.0, 2.0, + width - 4, height - 4); + cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD); + cairo_set_source_rgb (cr, 0, 1, 0); /* green */ + + cairo_perf_timer_start (); + + while (loops--) + cairo_fill_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + + return cairo_perf_timer_elapsed (); +} + +cairo_bool_t +box_outline_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "box-outline", NULL); +} + void box_outline (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "box-outline", NULL)) - return; - cairo_perf_run (perf, "box-outline-stroke", box_outline_stroke, NULL); cairo_perf_run (perf, "box-outline-fill", box_outline_fill, NULL); + + cairo_perf_run (perf, "box-outline-alpha-stroke", box_outline_alpha_stroke, NULL); + cairo_perf_run (perf, "box-outline-alpha-fill", box_outline_alpha_fill, NULL); + + cairo_perf_run (perf, "box-outline-aa-stroke", box_outline_aa_stroke, NULL); + cairo_perf_run (perf, "box-outline-aa-fill", box_outline_aa_fill, NULL); } diff --git a/perf/micro/composite-checker.c b/perf/micro/composite-checker.c index 0d7af0c8..d6d17ab6 100644 --- a/perf/micro/composite-checker.c +++ b/perf/micro/composite-checker.c @@ -75,6 +75,12 @@ do_composite_checker (cairo_t *cr, return cairo_perf_timer_elapsed (); } +cairo_bool_t +composite_checker_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "composite-checker", NULL); +} + void composite_checker (cairo_perf_t *perf, cairo_t *cr, @@ -83,9 +89,6 @@ composite_checker (cairo_perf_t *perf, { cairo_surface_t *image; - if (! cairo_perf_can_run (perf, "composite-checker", NULL)) - return; - /* Create the checker pattern. We don't actually need to draw * anything on it since that wouldn't affect performance. */ diff --git a/perf/micro/curve.c b/perf/micro/curve.c index 7def326e..3b5a1634 100644 --- a/perf/micro/curve.c +++ b/perf/micro/curve.c @@ -95,12 +95,15 @@ do_curve_fill (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +curve_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "curve", NULL); +} + void curve (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "curve", NULL)) - return; - cairo_set_source_rgb (cr, 1., 1., 1.); cairo_perf_run (perf, "curve-stroked", do_curve_stroke, NULL); diff --git a/perf/micro/disjoint.c b/perf/micro/disjoint.c index d7f50260..623eb6f4 100644 --- a/perf/micro/disjoint.c +++ b/perf/micro/disjoint.c @@ -85,6 +85,12 @@ draw (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +disjoint_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "disjoint", NULL); +} + void disjoint (cairo_perf_t *perf, cairo_t *cr, int width, int height) { diff --git a/perf/micro/dragon.c b/perf/micro/dragon.c index 5bc8d26f..e215eacc 100644 --- a/perf/micro/dragon.c +++ b/perf/micro/dragon.c @@ -265,12 +265,15 @@ do_dragon_solid_circle_clip (cairo_t *cr, int width, int height, int loops) return do_dragon_solid (cr, width, height, loops); } +cairo_bool_t +dragon_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "dragon", NULL); +} + void dragon (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "dragon", NULL)) - return; - cairo_perf_run (perf, "dragon-solid", do_dragon_solid, NULL); cairo_perf_run (perf, "dragon-unaligned-solid", do_dragon_solid_unaligned, NULL); cairo_perf_run (perf, "dragon-solid-aligned-clip", do_dragon_solid_aligned_clip, NULL); diff --git a/perf/micro/fill-clip.c b/perf/micro/fill-clip.c new file mode 100644 index 00000000..2d014aca --- /dev/null +++ b/perf/micro/fill-clip.c @@ -0,0 +1,126 @@ +/* + * Copyright © 2011 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * Author: Chris Wilson <chris@chris-wilson.co.uk> + */ + +/* Compares the overhead for WebKit's drawRect() */ + +#include "cairo-perf.h" + +#include <pixman.h> + +static cairo_time_t +clip_paint (cairo_t *cr, int width, int height, int loops) +{ + int x = width/4, w = width/2; + int y = height/4, h = height/2; + + cairo_perf_timer_start (); + + while (loops--) { + cairo_reset_clip (cr); + cairo_rectangle (cr, x, y, w, h); + cairo_clip (cr); + cairo_paint (cr); + } + + cairo_perf_timer_stop (); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +rect_fill (cairo_t *cr, int width, int height, int loops) +{ + int x = width/4, w = width/2; + int y = height/4, h = height/2; + + cairo_perf_timer_start (); + + while (loops--) { + cairo_rectangle (cr, x, y, w, h); + cairo_fill (cr); + } + + cairo_perf_timer_stop (); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +direct (cairo_t *cr, int width, int height, int loops) +{ + int x = width/4, w = width/2; + int y = height/4, h = height/2; + cairo_surface_t *surface, *image; + uint8_t *data; + int stride, bpp; + + + surface = cairo_get_target (cr); + image = cairo_surface_map_to_image (surface, NULL); + data = cairo_image_surface_get_data (image); + stride = cairo_image_surface_get_stride (image); + + switch (cairo_image_surface_get_format (image)) { + default: + case CAIRO_FORMAT_INVALID: + case CAIRO_FORMAT_A1: bpp = 0; break; + case CAIRO_FORMAT_A8: bpp = 8; break; + case CAIRO_FORMAT_RGB16_565: bpp = 16; break; + case CAIRO_FORMAT_RGB24: + case CAIRO_FORMAT_RGB30: + case CAIRO_FORMAT_ARGB32: bpp = 32; break; + } + + cairo_perf_timer_start (); + + while (loops--) { + pixman_fill ((uint32_t *)data, stride / sizeof(uint32_t), bpp, + x, y, w, h, + -1); + } + + cairo_perf_timer_stop (); + + cairo_surface_unmap_image (surface, image); + + return cairo_perf_timer_elapsed (); +} + +cairo_bool_t +fill_clip_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "fillclip", NULL); +} + +void +fill_clip (cairo_perf_t *perf, cairo_t *cr, int width, int height) +{ + cairo_set_source_rgb (cr, 1., 1., 1.); + + cairo_perf_run (perf, "fillclip-clip", clip_paint, NULL); + cairo_perf_run (perf, "fillclip-fill", rect_fill, NULL); + cairo_perf_run (perf, "fillclip-direct", direct, NULL); +} diff --git a/perf/micro/fill.c b/perf/micro/fill.c index 07952271..d356c26d 100644 --- a/perf/micro/fill.c +++ b/perf/micro/fill.c @@ -107,12 +107,15 @@ do_fill_eo_noaa (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +fill_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "fill", NULL); +} + void fill (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "fill", NULL)) - return; - cairo_perf_cover_sources_and_operators (perf, "fill", do_fill, NULL); cairo_perf_cover_sources_and_operators (perf, "fill-annuli", do_fill_annuli, NULL); cairo_perf_cover_sources_and_operators (perf, "fill-eo-noaa", do_fill_eo_noaa, NULL); diff --git a/perf/micro/glyphs.c b/perf/micro/glyphs.c index 74c67eee..5f088b29 100644 --- a/perf/micro/glyphs.c +++ b/perf/micro/glyphs.c @@ -170,12 +170,15 @@ DECL(48ca, 48, CAIRO_ANTIALIAS_SUBPIXEL) DECL(8mono, 8, CAIRO_ANTIALIAS_NONE) DECL(48mono, 48, CAIRO_ANTIALIAS_NONE) +cairo_bool_t +glyphs_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "glyphs", NULL); +} + void glyphs (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "glyphs", NULL)) - return; - cairo_perf_cover_sources_and_operators (perf, "glyphs8mono", do_glyphs8mono, count_glyphs8mono); cairo_perf_cover_sources_and_operators (perf, "glyphs8", do_glyphs8, count_glyphs8); cairo_perf_cover_sources_and_operators (perf, "glyphs8ca", do_glyphs8ca, count_glyphs8ca); diff --git a/perf/micro/hash-table.c b/perf/micro/hash-table.c index a0266381..d1629177 100644 --- a/perf/micro/hash-table.c +++ b/perf/micro/hash-table.c @@ -101,12 +101,15 @@ do_hash_table (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +hash_table_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "hash-table", NULL); +} + void hash_table (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "hash-table", NULL)) - return; - cairo_perf_cover_sources_and_operators (perf, "hash-table", do_hash_table, NULL); } diff --git a/perf/micro/hatching.c b/perf/micro/hatching.c index e31d3010..b51acec5 100644 --- a/perf/micro/hatching.c +++ b/perf/micro/hatching.c @@ -170,12 +170,15 @@ F(clip_alpha_aligned_mono, clip_alpha, aligned, mono) F(clip_alpha_misaligned_mono, clip_alpha, misaligned, mono) F(clip_alpha_rotated_mono, clip_alpha, rotated, mono) +cairo_bool_t +hatching_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "hatching", NULL); +} + void hatching (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "hatching", NULL)) - return; - cairo_perf_run (perf, "hatching-aligned-aa", draw_aligned_aa, NULL); cairo_perf_run (perf, "hatching-misaligned-aa", draw_misaligned_aa, NULL); cairo_perf_run (perf, "hatching-rotated-aa", draw_rotated_aa, NULL); diff --git a/perf/micro/intersections.c b/perf/micro/intersections.c index 9a81eee8..57931faf 100644 --- a/perf/micro/intersections.c +++ b/perf/micro/intersections.c @@ -143,12 +143,15 @@ random_curve_nz (cairo_t *cr, int width, int height, int loops) return draw_random_curve (cr, CAIRO_FILL_RULE_WINDING, width, height, loops); } +cairo_bool_t +intersections_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "intersections", NULL); +} + void intersections (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "intersections", NULL)) - return; - cairo_perf_run (perf, "intersections-nz-fill", random_nz, NULL); cairo_perf_run (perf, "intersections-eo-fill", random_eo, NULL); diff --git a/perf/micro/line.c b/perf/micro/line.c index 7ba9f904..3ed5f8da 100644 --- a/perf/micro/line.c +++ b/perf/micro/line.c @@ -196,12 +196,15 @@ diagonal_wide (cairo_t *cr, int width, int height, int loops) return diagonal (cr, width, height, loops); } +cairo_bool_t +line_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "line", NULL); +} + void line (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "line", NULL)) - return; - cairo_set_source_rgb (cr, 1., 1., 1.); cairo_perf_run (perf, "line-hh", horizontal_hair, NULL); diff --git a/perf/micro/long-dashed-lines.c b/perf/micro/long-dashed-lines.c index fa99b200..ba66a4af 100644 --- a/perf/micro/long-dashed-lines.c +++ b/perf/micro/long-dashed-lines.c @@ -61,11 +61,14 @@ do_long_dashed_lines (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +long_dashed_lines_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "long-dashed-lines", NULL); +} + void long_dashed_lines (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "long-dashed-lines", NULL)) - return; - cairo_perf_run (perf, "long-dashed-lines", do_long_dashed_lines, NULL); } diff --git a/perf/micro/long-lines.c b/perf/micro/long-lines.c index b3a94585..a0d134c2 100644 --- a/perf/micro/long-lines.c +++ b/perf/micro/long-lines.c @@ -132,12 +132,15 @@ long_lines_cropped_once (cairo_t *cr, int width, int height, int loops) return do_long_lines (cr, width, height, loops, LONG_LINES_CROPPED | LONG_LINES_ONCE); } +cairo_bool_t +long_lines_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "long-lines", NULL); +} + void long_lines (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "long-lines", NULL)) - return; - cairo_perf_run (perf, "long-lines-uncropped", long_lines_uncropped, NULL); cairo_perf_run (perf, "long-lines-uncropped-once", long_lines_uncropped_once, NULL); cairo_perf_run (perf, "long-lines-cropped", long_lines_cropped, NULL); diff --git a/perf/micro/many-curves.c b/perf/micro/many-curves.c index dc7cdf9f..f985d349 100644 --- a/perf/micro/many-curves.c +++ b/perf/micro/many-curves.c @@ -118,12 +118,15 @@ do_many_curves_filled (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +many_curves_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "many-curves", NULL); +} + void many_curves (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "many-curves", NULL)) - return; - cairo_set_source_rgb (cr, 1., 1., 1.); cairo_perf_run (perf, "many-curves-hair-stroked", do_many_curves_hair_stroked, NULL); diff --git a/perf/micro/many-fills.c b/perf/micro/many-fills.c index eb56e8b9..9d3fd643 100644 --- a/perf/micro/many-fills.c +++ b/perf/micro/many-fills.c @@ -170,12 +170,15 @@ do_many_fills (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +many_fills_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "many-fills", NULL); +} + void many_fills (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "many-fills", NULL)) - return; - cairo_perf_run (perf, "many-fills-halign", do_many_fills_ha, NULL); cairo_perf_run (perf, "many-fills-valign", do_many_fills_va, NULL); cairo_perf_run (perf, "many-fills-horizontal", do_many_fills_h, NULL); diff --git a/perf/micro/many-strokes.c b/perf/micro/many-strokes.c index f0339457..9aeb393d 100644 --- a/perf/micro/many-strokes.c +++ b/perf/micro/many-strokes.c @@ -45,7 +45,7 @@ do_many_strokes_ha (cairo_t *cr, int width, int height, int loops) state = 0xc0ffee; for (count = 0; count < 1000; count++) { - double h = floor (uniform_random (0, height)); + double h = floor (uniform_random (0, height)) + .5; cairo_move_to (cr, floor (uniform_random (0, width)), h); cairo_line_to (cr, ceil (uniform_random (0, width)), h); } @@ -97,7 +97,7 @@ do_many_strokes_va (cairo_t *cr, int width, int height, int loops) state = 0xc0ffee; for (count = 0; count < 1000; count++) { - double v = floor (uniform_random (0, width)); + double v = floor (uniform_random (0, width)) + .5; cairo_move_to (cr, v, floor (uniform_random (0, height))); cairo_line_to (cr, v, ceil (uniform_random (0, height))); } @@ -169,12 +169,15 @@ do_many_strokes (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +many_strokes_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "many-strokes", NULL); +} + void many_strokes (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "many-strokes", NULL)) - return; - cairo_perf_run (perf, "many-strokes-halign", do_many_strokes_ha, NULL); cairo_perf_run (perf, "many-strokes-valign", do_many_strokes_va, NULL); cairo_perf_run (perf, "many-strokes-horizontal", do_many_strokes_h, NULL); diff --git a/perf/micro/mask.c b/perf/micro/mask.c index 79092e85..11a3ba73 100644 --- a/perf/micro/mask.c +++ b/perf/micro/mask.c @@ -272,6 +272,12 @@ do_mask_radial (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +mask_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "mask", NULL); +} + void mask (cairo_perf_t *perf, cairo_t *cr, int width, int height) { diff --git a/perf/micro/mosaic.c b/perf/micro/mosaic.c index d76b8400..ed30ae55 100644 --- a/perf/micro/mosaic.c +++ b/perf/micro/mosaic.c @@ -160,12 +160,15 @@ mosaic_tessellate_curves (cairo_t *cr, int width, int height, int loops) return mosaic_perform (cr, MOSAIC_TESSELLATE | MOSAIC_CURVE_TO, width, height, loops); } +cairo_bool_t +mosaic_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "mosaic", NULL); +} + void mosaic (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "mosaic", NULL)) - return; - cairo_perf_run (perf, "mosaic-fill-curves", mosaic_fill_curves, NULL); cairo_perf_run (perf, "mosaic-fill-lines", mosaic_fill_lines, NULL); cairo_perf_run (perf, "mosaic-tessellate-curves", mosaic_tessellate_curves, NULL); diff --git a/perf/micro/paint-with-alpha.c b/perf/micro/paint-with-alpha.c index 3c1f69ee..047e35c4 100644 --- a/perf/micro/paint-with-alpha.c +++ b/perf/micro/paint-with-alpha.c @@ -44,12 +44,15 @@ count_paint_with_alpha (cairo_t *cr, int width, int height) return width * height / 1e6; /* Mpix/s */ } +cairo_bool_t +paint_with_alpha_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "paint-with-alpha", NULL); +} + void paint_with_alpha (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "paint-with-alpha", NULL)) - return; - cairo_perf_cover_sources_and_operators (perf, "paint-with-alpha", do_paint_with_alpha, count_paint_with_alpha); diff --git a/perf/micro/paint.c b/perf/micro/paint.c index dc7e0a0f..2a59a45e 100644 --- a/perf/micro/paint.c +++ b/perf/micro/paint.c @@ -44,11 +44,14 @@ count_paint (cairo_t *cr, int width, int height) return width * height / 1e6; /* Mpix/s */ } +cairo_bool_t +paint_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "paint", NULL); +} + void paint (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "paint", NULL)) - return; - cairo_perf_cover_sources_and_operators (perf, "paint", do_paint, count_paint); } diff --git a/perf/micro/pattern_create_radial.c b/perf/micro/pattern_create_radial.c index 13260bb5..f236ef54 100644 --- a/perf/micro/pattern_create_radial.c +++ b/perf/micro/pattern_create_radial.c @@ -79,14 +79,17 @@ do_pattern_create_radial (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +pattern_create_radial_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "pattern-create-radial", NULL); +} + void pattern_create_radial (cairo_perf_t *perf, cairo_t *cr, int width, int height) { int i; - if (! cairo_perf_can_run (perf, "pattern-create-radial", NULL)) - return; - srand (time (0)); for (i = 0; i < RADIALS_COUNT; i++) { diff --git a/perf/micro/pixel.c b/perf/micro/pixel.c new file mode 100644 index 00000000..12b8f47b --- /dev/null +++ b/perf/micro/pixel.c @@ -0,0 +1,177 @@ +/* + * Copyright © 2011 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * Author: Chris Wilson <chris@chris-wilson.co.uk> + */ + +/* Measure the overhead in setting a single pixel */ + +#include "cairo-perf.h" + +static cairo_time_t +pixel_paint (cairo_t *cr, int width, int height, int loops) +{ + cairo_perf_timer_start (); + + while (loops--) + cairo_paint (cr); + + cairo_perf_timer_stop (); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +pixel_mask (cairo_t *cr, int width, int height, int loops) +{ + cairo_surface_t *mask; + cairo_t *cr2; + + mask = cairo_surface_create_similar (cairo_get_target (cr), + CAIRO_CONTENT_ALPHA, + 1, 1); + cr2 = cairo_create (mask); + cairo_set_source_rgb (cr2, 1,1,1); + cairo_paint (cr2); + cairo_destroy (cr2); + + cairo_perf_timer_start (); + + while (loops--) + cairo_mask_surface (cr, mask, 0, 0); + + cairo_perf_timer_stop (); + + cairo_surface_destroy (mask); + + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +pixel_rectangle (cairo_t *cr, int width, int height, int loops) +{ + cairo_new_path (cr); + cairo_rectangle (cr, 0, 0, 1, 1); + + cairo_perf_timer_start (); + + while (loops--) + cairo_fill_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +pixel_subrectangle (cairo_t *cr, int width, int height, int loops) +{ + cairo_new_path (cr); + cairo_rectangle (cr, 0.1, 0.1, .8, .8); + + cairo_perf_timer_start (); + + while (loops--) + cairo_fill_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +pixel_triangle (cairo_t *cr, int width, int height, int loops) +{ + cairo_new_path (cr); + cairo_move_to (cr, 0, 0); + cairo_line_to (cr, 1, 1); + cairo_line_to (cr, 0, 1); + + cairo_perf_timer_start (); + + while (loops--) + cairo_fill_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +pixel_circle (cairo_t *cr, int width, int height, int loops) +{ + cairo_new_path (cr); + cairo_arc (cr, 0.5, 0.5, 0.5, 0, 2 * M_PI); + + cairo_perf_timer_start (); + + while (loops--) + cairo_fill_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + return cairo_perf_timer_elapsed (); +} + +static cairo_time_t +pixel_stroke (cairo_t *cr, int width, int height, int loops) +{ + cairo_set_line_width (cr, 1.); + cairo_new_path (cr); + cairo_move_to (cr, 0, 0.5); + cairo_line_to (cr, 1, 0.5); + + cairo_perf_timer_start (); + + while (loops--) + cairo_stroke_preserve (cr); + + cairo_perf_timer_stop (); + + cairo_new_path (cr); + return cairo_perf_timer_elapsed (); +} + +cairo_bool_t +pixel_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "pixel", NULL); +} + +void +pixel (cairo_perf_t *perf, cairo_t *cr, int width, int height) +{ + cairo_set_source_rgb (cr, 1., 1., 1.); + + cairo_perf_run (perf, "pixel-paint", pixel_paint, NULL); + cairo_perf_run (perf, "pixel-mask", pixel_mask, NULL); + cairo_perf_run (perf, "pixel-rectangle", pixel_rectangle, NULL); + cairo_perf_run (perf, "pixel-subrectangle", pixel_subrectangle, NULL); + cairo_perf_run (perf, "pixel-triangle", pixel_triangle, NULL); + cairo_perf_run (perf, "pixel-circle", pixel_circle, NULL); + cairo_perf_run (perf, "pixel-stroke", pixel_stroke, NULL); +} diff --git a/perf/micro/pythagoras-tree.c b/perf/micro/pythagoras-tree.c index 6e823a8f..9d3ca115 100644 --- a/perf/micro/pythagoras-tree.c +++ b/perf/micro/pythagoras-tree.c @@ -82,11 +82,14 @@ do_pythagoras_tree (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +pythagoras_tree_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "pythagoras-tree", NULL); +} + void pythagoras_tree (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "pythagoras-tree", NULL)) - return; - cairo_perf_run (perf, "pythagoras-tree", do_pythagoras_tree, NULL); } diff --git a/perf/micro/rectangles.c b/perf/micro/rectangles.c index 891572b6..9228a4ef 100644 --- a/perf/micro/rectangles.c +++ b/perf/micro/rectangles.c @@ -95,14 +95,17 @@ do_rectangle (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +rectangles_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "rectangles", NULL); +} + void rectangles (cairo_perf_t *perf, cairo_t *cr, int width, int height) { int i; - if (! cairo_perf_can_run (perf, "rectangles", NULL)) - return; - srand (8478232); for (i = 0; i < RECTANGLE_COUNT; i++) { diff --git a/perf/micro/rounded-rectangles.c b/perf/micro/rounded-rectangles.c index 59852492..1e432dd1 100644 --- a/perf/micro/rounded-rectangles.c +++ b/perf/micro/rounded-rectangles.c @@ -119,14 +119,17 @@ do_rectangles_once (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +rounded_rectangles_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "rounded-rectangles", NULL); +} + void rounded_rectangles (cairo_perf_t *perf, cairo_t *cr, int width, int height) { int i; - if (! cairo_perf_can_run (perf, "rounded-rectangles", NULL)) - return; - srand (8478232); for (i = 0; i < RECTANGLE_COUNT; i++) { rects[i].x = rand () % width; diff --git a/perf/micro/sierpinski.c b/perf/micro/sierpinski.c new file mode 100644 index 00000000..c6f5fadc --- /dev/null +++ b/perf/micro/sierpinski.c @@ -0,0 +1,94 @@ +/* + * Copyright © 2011 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * Author: Chris Wilson <chris@chris-wilson.co.uk> + */ + +#include "cairo-perf.h" + +static const double m_1_sqrt_3 = 0.577359269; + +static void +T (cairo_t *cr, int size) +{ + cairo_move_to (cr, 0, 0); + cairo_line_to (cr, size, 0); + cairo_line_to (cr, size/2, size*m_1_sqrt_3); + + size /= 2; + if (size >= 4) { + T (cr, size); + cairo_save (cr); { + cairo_translate (cr, size, 0); + T (cr, size); + } cairo_restore (cr); + cairo_save (cr); { + cairo_translate (cr, size/2, size*m_1_sqrt_3); + T (cr, size); + } cairo_restore (cr); + } +} + +static cairo_time_t +draw (cairo_t *cr, int width, int height, int loops) +{ + int t_height = height/2; + int t_width = t_height / m_1_sqrt_3; + + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_paint (cr); + + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_set_line_width (cr, 1.); + + cairo_perf_timer_start (); + + while (loops--) { + cairo_save (cr); + T (cr, t_width); + + cairo_translate (cr, 0, height); + cairo_scale (cr, 1, -1); + + T (cr, t_width); + + cairo_stroke (cr); + cairo_restore (cr); + } + + cairo_perf_timer_stop (); + + return cairo_perf_timer_elapsed (); +} + +cairo_bool_t +sierpinski_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "sierpinski", NULL); +} + +void +sierpinski (cairo_perf_t *perf, cairo_t *cr, int width, int height) +{ + cairo_perf_run (perf, "sierpinski", draw, NULL); +} diff --git a/perf/micro/spiral.c b/perf/micro/spiral.c index 85d05801..87dbcb52 100644 --- a/perf/micro/spiral.c +++ b/perf/micro/spiral.c @@ -326,12 +326,15 @@ draw_spiral_stroke_na (cairo_t *cr, int width, int height, int loops) width, height, loops); } +cairo_bool_t +spiral_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "spiral", NULL); +} + void spiral (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "spiral", NULL)) - return; - cairo_perf_run (perf, "spiral-box-nonalign-evenodd-fill", draw_spiral_eo_na_box, NULL); cairo_perf_run (perf, "spiral-box-nonalign-nonzero-fill", draw_spiral_nz_na_box, NULL); cairo_perf_run (perf, "spiral-box-pixalign-evenodd-fill", draw_spiral_eo_pa_box, NULL); diff --git a/perf/micro/stroke.c b/perf/micro/stroke.c index 8d7dc527..4b295477 100644 --- a/perf/micro/stroke.c +++ b/perf/micro/stroke.c @@ -86,12 +86,15 @@ do_strokes (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +stroke_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "stroke", NULL); +} + void stroke (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "stroke", NULL)) - return; - cairo_perf_cover_sources_and_operators (perf, "stroke", do_stroke, NULL); cairo_perf_cover_sources_and_operators (perf, "strokes", do_strokes, NULL); } diff --git a/perf/micro/subimage_copy.c b/perf/micro/subimage_copy.c index eb04154a..e749c062 100644 --- a/perf/micro/subimage_copy.c +++ b/perf/micro/subimage_copy.c @@ -52,15 +52,18 @@ do_subimage_copy (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +subimage_copy_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "subimage-copy", NULL); +} + void subimage_copy (cairo_perf_t *perf, cairo_t *cr, int width, int height) { cairo_surface_t *image; cairo_t *cr2; - if (! cairo_perf_can_run (perf, "subimage-copy", NULL)) - return; - cairo_set_source_rgb (cr, 0, 0, 1); /* blue */ cairo_paint (cr); diff --git a/perf/micro/tessellate.c b/perf/micro/tessellate.c index 38c8b86f..b6277fe6 100644 --- a/perf/micro/tessellate.c +++ b/perf/micro/tessellate.c @@ -141,12 +141,15 @@ tessellate_256 (cairo_t *cr, int width, int height, int loops) return do_tessellate (cr, 256, loops); } +cairo_bool_t +tessellate_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "tessellate", NULL); +} + void tessellate (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "tessellate", NULL)) - return; - cairo_perf_run (perf, "tessellate-16", tessellate_16, NULL); cairo_perf_run (perf, "tessellate-64", tessellate_64, NULL); cairo_perf_run (perf, "tessellate-256", tessellate_256, NULL); diff --git a/perf/micro/text.c b/perf/micro/text.c index bd2ca7b4..cdb31993 100644 --- a/perf/micro/text.c +++ b/perf/micro/text.c @@ -56,11 +56,14 @@ do_text (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +text_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "text", NULL); +} + void text (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "text", NULL)) - return; - cairo_perf_cover_sources_and_operators (perf, "text", do_text, NULL); } diff --git a/perf/micro/twin.c b/perf/micro/twin.c index cc6f0204..99433bd6 100644 --- a/perf/micro/twin.c +++ b/perf/micro/twin.c @@ -43,14 +43,17 @@ do_twin (cairo_t *cr, return cairo_perf_timer_elapsed (); } +cairo_bool_t +twin_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "twin", NULL); +} + void twin (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "twin", NULL)) - return; - cairo_perf_run (perf, "twin", do_twin, NULL); } diff --git a/perf/micro/unaligned-clip.c b/perf/micro/unaligned-clip.c index d71549cc..41e327f1 100644 --- a/perf/micro/unaligned-clip.c +++ b/perf/micro/unaligned-clip.c @@ -60,11 +60,14 @@ do_unaligned_clip (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +unaligned_clip_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "unaligned-clip", NULL); +} + void unaligned_clip (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "unaligned-clip", NULL)) - return; - cairo_perf_run (perf, "unaligned-clip", do_unaligned_clip, NULL); } diff --git a/perf/micro/wave.c b/perf/micro/wave.c index 88029f8c..f6e6f74a 100644 --- a/perf/micro/wave.c +++ b/perf/micro/wave.c @@ -102,11 +102,14 @@ do_wave (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +wave_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "wave", NULL); +} + void wave (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "wave", NULL)) - return; - cairo_perf_run (perf, "wave", do_wave, NULL); } diff --git a/perf/micro/wide-fills.c b/perf/micro/wide-fills.c index a9beeeb1..0747e6e6 100644 --- a/perf/micro/wide-fills.c +++ b/perf/micro/wide-fills.c @@ -170,12 +170,15 @@ do_wide_fills (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +wide_fills_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "wide-fills", NULL); +} + void wide_fills (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "wide-fills", NULL)) - return; - cairo_perf_run (perf, "wide-fills-halign", do_wide_fills_ha, NULL); cairo_perf_run (perf, "wide-fills-valign", do_wide_fills_va, NULL); cairo_perf_run (perf, "wide-fills-horizontal", do_wide_fills_h, NULL); diff --git a/perf/micro/wide-strokes.c b/perf/micro/wide-strokes.c index e6c27dab..14130914 100644 --- a/perf/micro/wide-strokes.c +++ b/perf/micro/wide-strokes.c @@ -169,12 +169,15 @@ do_wide_strokes (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +wide_strokes_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "wide-strokes", NULL); +} + void wide_strokes (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "wide-strokes", NULL)) - return; - cairo_set_source_rgb (cr, 1., 1., 1.); cairo_perf_run (perf, "wide-strokes-halign", do_wide_strokes_ha, NULL); diff --git a/perf/micro/world-map.c b/perf/micro/world-map.c index cb0aeee6..ff22eebf 100644 --- a/perf/micro/world-map.c +++ b/perf/micro/world-map.c @@ -134,12 +134,15 @@ do_world_map_both (cairo_t *cr, int width, int height, int loops) return do_world_map (cr, width, height, loops, FILL | STROKE); } +cairo_bool_t +world_map_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "world-map", NULL); +} + void world_map (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "world-map", NULL)) - return; - cairo_perf_run (perf, "world-map-stroke", do_world_map_stroke, NULL); cairo_perf_run (perf, "world-map-fill", do_world_map_fill, NULL); cairo_perf_run (perf, "world-map", do_world_map_both, NULL); diff --git a/perf/micro/zrusin.c b/perf/micro/zrusin.c index c4dccbfa..7d8b004b 100644 --- a/perf/micro/zrusin.c +++ b/perf/micro/zrusin.c @@ -84,11 +84,15 @@ zrusin_another_fill (cairo_t *cr, int width, int height, int loops) return cairo_perf_timer_elapsed (); } +cairo_bool_t +zrusin_enabled (cairo_perf_t *perf) +{ + return cairo_perf_can_run (perf, "zrusin", NULL); +} + void zrusin (cairo_perf_t *perf, cairo_t *cr, int width, int height) { - if (! cairo_perf_can_run (perf, "zrusin", NULL)) - return; cairo_perf_run (perf, "zrusin-another-tessellate", zrusin_another_tessellate, NULL); cairo_perf_run (perf, "zrusin-another-fill", zrusin_another_fill, NULL); diff --git a/src/Makefile.sources b/src/Makefile.sources index 0b820f8f..d23d504f 100644 --- a/src/Makefile.sources +++ b/src/Makefile.sources @@ -54,6 +54,7 @@ cairo_private = \ cairoint.h \ cairo-analysis-surface-private.h \ cairo-arc-private.h \ + cairo-array-private.h \ cairo-atomic-private.h \ cairo-backend-private.h \ cairo-box-private.h \ @@ -62,6 +63,7 @@ cairo_private = \ cairo-clip-private.h \ cairo-combsort-private.h \ cairo-compiler-private.h \ + cairo-compositor-private.h \ cairo-contour-private.h \ cairo-composite-rectangles-private.h \ cairo-default-context-private.h \ @@ -97,10 +99,11 @@ cairo_private = \ cairo-scaled-font-private.h \ cairo-slope-private.h \ cairo-spans-private.h \ + cairo-spans-compositor-private.h \ cairo-stroke-dash-private.h \ - cairo-surface-fallback-private.h \ cairo-surface-private.h \ cairo-surface-clipper-private.h \ + cairo-surface-fallback-private.h \ cairo-surface-observer-private.h \ cairo-surface-offset-private.h \ cairo-surface-subsurface-private.h \ @@ -108,6 +111,8 @@ cairo_private = \ cairo-surface-wrapper-private.h \ cairo-time-private.h \ cairo-types-private.h \ + cairo-traps-private.h \ + cairo-tristrip-private.h \ cairo-user-font-private.h \ cairo-wideint-private.h \ cairo-wideint-type-private.h \ @@ -134,11 +139,13 @@ cairo_sources = \ cairo-clip-surface.c \ cairo-color.c \ cairo-composite-rectangles.c \ + cairo-compositor.c \ cairo-contour.c \ cairo-debug.c \ cairo-default-context.c \ cairo-device.c \ cairo-error.c \ + cairo-fallback-compositor.c \ cairo-fixed.c \ cairo-font-face.c \ cairo-font-face-twin.c \ @@ -149,14 +156,19 @@ cairo_sources = \ cairo-gstate.c \ cairo-hash.c \ cairo-hull.c \ + cairo-image-compositor.c \ cairo-image-info.c \ + cairo-image-source.c \ cairo-image-surface.c \ cairo-lzw.c \ cairo-matrix.c \ + cairo-mask-compositor.c \ cairo-mesh-pattern-rasterizer.c \ cairo-mime-surface.c \ cairo-misc.c \ + cairo-mono-scan-converter.c \ cairo-mutex.c \ + cairo-no-compositor.c \ cairo-observer.c \ cairo-output-stream.c \ cairo-paginated-surface.c \ @@ -168,6 +180,7 @@ cairo_sources = \ cairo-path-stroke.c \ cairo-path-stroke-boxes.c \ cairo-path-stroke-polygon.c \ + cairo-path-stroke-tristrip.c \ cairo-pattern.c \ cairo-pen.c \ cairo-polygon.c \ @@ -181,12 +194,13 @@ cairo_sources = \ cairo-scaled-font.c \ cairo-slope.c \ cairo-spans.c \ + cairo-spans-compositor.c \ cairo-spline.c \ cairo-stroke-dash.c \ cairo-stroke-style.c \ cairo-surface.c \ - cairo-surface-fallback.c \ cairo-surface-clipper.c \ + cairo-surface-fallback.c \ cairo-surface-observer.c \ cairo-surface-offset.c \ cairo-surface-snapshot.c \ @@ -195,8 +209,12 @@ cairo_sources = \ cairo-system.c \ cairo-time.c \ cairo-tor-scan-converter.c \ + cairo-tor22-scan-converter.c \ + cairo-clip-tor-scan-converter.c \ cairo-toy-font-face.c \ cairo-traps.c \ + cairo-tristrip.c \ + cairo-traps-compositor.c \ cairo-unicode.c \ cairo-user-font.c \ cairo-version.c \ @@ -253,18 +271,15 @@ cairo_ft_sources = cairo-ft-font.c # These are private, even though they look like public headers cairo_test_surfaces_private = \ - test-fallback-surface.h \ - test-fallback16-surface.h \ - test-null-surface.h \ + test-compositor-surface.h \ + test-null-compositor-surface.h \ test-paginated-surface.h \ - test-wrapping-surface.h \ $(NULL) cairo_test_surfaces_sources = \ - test-fallback-surface.c \ - test-fallback16-surface.c \ - test-null-surface.c \ + test-compositor-surface.c \ + test-null-compositor-surface.c \ + test-base-compositor-surface.c \ test-paginated-surface.c \ - test-wrapping-surface.c \ $(NULL) cairo_xlib_headers = cairo-xlib.h @@ -275,7 +290,11 @@ cairo_xlib_private = \ $(NULL) cairo_xlib_sources = \ cairo-xlib-display.c \ + cairo-xlib-core-compositor.c \ + cairo-xlib-fallback-compositor.c \ + cairo-xlib-render-compositor.c \ cairo-xlib-screen.c \ + cairo-xlib-source.c \ cairo-xlib-surface.c \ cairo-xlib-visual.c \ cairo-xlib-xcb-surface.c \ @@ -343,7 +362,10 @@ cairo_gl_sources = cairo-gl-composite.c \ cairo-gl-glyphs.c \ cairo-gl-gradient.c \ cairo-gl-info.c \ + cairo-gl-operand.c \ cairo-gl-shaders.c \ + cairo-gl-spans-compositor.c \ + cairo-gl-traps-compositor.c \ cairo-gl-surface.c cairo_glesv2_headers = $(cairo_gl_headers) diff --git a/src/cairo-analysis-surface.c b/src/cairo-analysis-surface.c index beb9a07b..e1c28b65 100644 --- a/src/cairo-analysis-surface.c +++ b/src/cairo-analysis-surface.c @@ -144,7 +144,7 @@ _analyze_recording_surface_pattern (cairo_analysis_surface_t *surface, cairo_analysis_surface_t *tmp; cairo_surface_t *source, *proxy; cairo_matrix_t p2d; - cairo_status_t status; + cairo_status_t status, analysis_status; assert (pattern->type == CAIRO_PATTERN_TYPE_SURFACE); surface_pattern = (const cairo_surface_pattern_t *) pattern; @@ -175,11 +175,16 @@ _analyze_recording_surface_pattern (cairo_analysis_surface_t *surface, if (_cairo_surface_is_subsurface (source)) source = _cairo_surface_subsurface_get_target (source); - status = _cairo_recording_surface_replay_and_create_regions (source, &tmp->base); + status = _cairo_recording_surface_replay_and_create_regions (source, + &tmp->base); + analysis_status = tmp->has_unsupported ? CAIRO_INT_STATUS_IMAGE_FALLBACK : CAIRO_INT_STATUS_SUCCESS; detach_proxy (proxy); cairo_surface_destroy (&tmp->base); - return status; + if (unlikely (status)) + return status; + + return analysis_status; } static cairo_int_status_t @@ -548,8 +553,7 @@ _cairo_analysis_surface_show_glyphs (void *abstract_surface, cairo_glyph_t *glyphs, int num_glyphs, cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip, - int *remaining_glyphs) + const cairo_clip_t *clip) { cairo_analysis_surface_t *surface = abstract_surface; cairo_int_status_t status, backend_status; @@ -562,8 +566,7 @@ _cairo_analysis_surface_show_glyphs (void *abstract_surface, source, glyphs, num_glyphs, scaled_font, - clip, - remaining_glyphs); + clip); if (_cairo_int_status_is_error (backend_status)) return backend_status; } @@ -652,21 +655,14 @@ _cairo_analysis_surface_show_text_glyphs (void *abstract_surface, if (backend_status == CAIRO_INT_STATUS_UNSUPPORTED && surface->target->backend->show_glyphs != NULL) { - int remaining_glyphs = num_glyphs; backend_status = surface->target->backend->show_glyphs (surface->target, op, source, glyphs, num_glyphs, scaled_font, - clip, - &remaining_glyphs); + clip); if (_cairo_int_status_is_error (backend_status)) return backend_status; - - glyphs += num_glyphs - remaining_glyphs; - num_glyphs = remaining_glyphs; - if (remaining_glyphs == 0) - backend_status = CAIRO_STATUS_SUCCESS; } if (backend_status == CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN) @@ -701,35 +697,26 @@ static const cairo_surface_backend_t cairo_analysis_surface_backend = { NULL, /* create_similar_image */ NULL, /* map_to_image */ NULL, /* unmap */ + NULL, /* acquire_source_image */ NULL, /* release_source_image */ - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + NULL, /* snapshot */ + NULL, /* copy_page */ NULL, /* show_page */ + _cairo_analysis_surface_get_extents, - NULL, /* old_show_glyphs */ NULL, /* get_font_options */ + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ + _cairo_analysis_surface_paint, _cairo_analysis_surface_mask, _cairo_analysis_surface_stroke, _cairo_analysis_surface_fill, - _cairo_analysis_surface_show_glyphs, - NULL, /* snapshot */ - NULL, /* is_similar */ NULL, /* fill_stroke */ - NULL, /* create_solid_pattern_surface */ - NULL, /* can_repaint_solid_pattern_surface */ + _cairo_analysis_surface_show_glyphs, _cairo_analysis_surface_has_show_text_glyphs, _cairo_analysis_surface_show_text_glyphs }; @@ -891,48 +878,38 @@ typedef cairo_int_status_t cairo_glyph_t *glyphs, int num_glyphs, cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip, - int *remaining_glyphs); + const cairo_clip_t *clip); static const cairo_surface_backend_t cairo_null_surface_backend = { CAIRO_INTERNAL_SURFACE_TYPE_NULL, NULL, /* finish */ - _cairo_default_context_create, /* XXX */ + NULL, /* only accessed through the surface functions */ NULL, /* create_similar */ NULL, /* create similar image */ NULL, /* map to image */ NULL, /* unmap image*/ + NULL, /* acquire_source_image */ NULL, /* release_source_image */ - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + NULL, /* snapshot */ + NULL, /* copy_page */ NULL, /* show_page */ + NULL, /* get_extents */ - NULL, /* old_show_glyphs */ NULL, /* get_font_options */ + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ + (_paint_func) _return_success, /* paint */ (_mask_func) _return_success, /* mask */ (_stroke_func) _return_success, /* stroke */ (_fill_func) _return_success, /* fill */ - (_show_glyphs_func) _return_success, /* show_glyphs */ - NULL, /* snapshot */ - NULL, /* is_similar */ NULL, /* fill_stroke */ - NULL, /* create_solid_pattern_surface */ - NULL, /* can_repaint_solid_pattern_surface */ + (_show_glyphs_func) _return_success, /* show_glyphs */ NULL, /* has_show_text_glyphs */ NULL /* show_text_glyphs */ }; diff --git a/src/cairo-array-private.h b/src/cairo-array-private.h new file mode 100644 index 00000000..35b29e5f --- /dev/null +++ b/src/cairo-array-private.h @@ -0,0 +1,90 @@ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it either under the terms of the GNU Lesser General Public + * License version 2.1 as published by the Free Software Foundation + * (the "LGPL") or, at your option, under the terms of the Mozilla + * Public License Version 1.1 (the "MPL"). If you do not alter this + * notice, a recipient may use your version of this file under either + * the MPL or the LGPL. + * + * You should have received a copy of the LGPL along with this library + * in the file COPYING-LGPL-2.1; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA + * You should have received a copy of the MPL along with this library + * in the file COPYING-MPL-1.1 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + */ + +#ifndef CAIRO_ARRAY_PRIVATE_H +#define CAIRO_ARRAY_PRIVATE_H + +#include "cairo-compiler-private.h" +#include "cairo-types-private.h" + +CAIRO_BEGIN_DECLS + +/* cairo-array.c structures and functions */ + +cairo_private void +_cairo_array_init (cairo_array_t *array, unsigned int element_size); + +cairo_private void +_cairo_array_fini (cairo_array_t *array); + +cairo_private cairo_status_t +_cairo_array_grow_by (cairo_array_t *array, unsigned int additional); + +cairo_private void +_cairo_array_truncate (cairo_array_t *array, unsigned int num_elements); + +cairo_private cairo_status_t +_cairo_array_append (cairo_array_t *array, const void *element); + +cairo_private cairo_status_t +_cairo_array_append_multiple (cairo_array_t *array, + const void *elements, + unsigned int num_elements); + +cairo_private cairo_status_t +_cairo_array_allocate (cairo_array_t *array, + unsigned int num_elements, + void **elements); + +cairo_private void * +_cairo_array_index (cairo_array_t *array, unsigned int index); + +cairo_private const void * +_cairo_array_index_const (const cairo_array_t *array, unsigned int index); + +cairo_private void +_cairo_array_copy_element (const cairo_array_t *array, unsigned int index, void *dst); + +cairo_private unsigned int +_cairo_array_num_elements (const cairo_array_t *array); + +cairo_private unsigned int +_cairo_array_size (const cairo_array_t *array); + +CAIRO_END_DECLS + +#endif /* CAIRO_ARRAY_PRIVATE_H */ diff --git a/src/cairo-array.c b/src/cairo-array.c index 52b283ff..4f3c082f 100644 --- a/src/cairo-array.c +++ b/src/cairo-array.c @@ -37,6 +37,7 @@ */ #include "cairoint.h" +#include "cairo-array-private.h" #include "cairo-error-private.h" /** @@ -385,11 +386,11 @@ _cairo_user_data_array_fini (cairo_user_data_array_t *array) cairo_user_data_slot_t *slots; slots = _cairo_array_index (array, 0); - do { - if (slots->user_data != NULL && slots->destroy != NULL) - slots->destroy (slots->user_data); - slots++; - } while (--num_slots); + while (num_slots--) { + cairo_user_data_slot_t *s = &slots[num_slots]; + if (s->user_data != NULL && s->destroy != NULL) + s->destroy (s->user_data); + } } _cairo_array_fini (array); diff --git a/src/cairo-atomic-private.h b/src/cairo-atomic-private.h index 9f5888ca..327fed1d 100644 --- a/src/cairo-atomic-private.h +++ b/src/cairo-atomic-private.h @@ -79,6 +79,7 @@ _cairo_atomic_ptr_get (void **x) #endif # define _cairo_atomic_int_inc(x) ((void) __sync_fetch_and_add(x, 1)) +# define _cairo_atomic_int_dec(x) ((void) __sync_fetch_and_add(x, -1)) # define _cairo_atomic_int_dec_and_test(x) (__sync_fetch_and_add(x, -1) == 1) # define _cairo_atomic_int_cmpxchg(x, oldv, newv) __sync_bool_compare_and_swap (x, oldv, newv) # define _cairo_atomic_int_cmpxchg_return_old(x, oldv, newv) __sync_val_compare_and_swap (x, oldv, newv) @@ -111,6 +112,7 @@ typedef AO_t cairo_atomic_int_t; # define _cairo_atomic_int_get(x) (AO_load_full (x)) # define _cairo_atomic_int_inc(x) ((void) AO_fetch_and_add1_full(x)) +# define _cairo_atomic_int_dec(x) ((void) AO_fetch_and_sub1_full(x)) # define _cairo_atomic_int_dec_and_test(x) (AO_fetch_and_sub1_full(x) == 1) # define _cairo_atomic_int_cmpxchg(x, oldv, newv) AO_compare_and_swap_full(x, oldv, newv) @@ -140,6 +142,7 @@ typedef int32_t cairo_atomic_int_t; # define _cairo_atomic_int_get(x) (OSMemoryBarrier(), *(x)) # define _cairo_atomic_int_inc(x) ((void) OSAtomicIncrement32Barrier (x)) +# define _cairo_atomic_int_dec(x) ((void) OSAtomicDecrement32Barrier (x)) # define _cairo_atomic_int_dec_and_test(x) (OSAtomicDecrement32Barrier (x) == 0) # define _cairo_atomic_int_cmpxchg(x, oldv, newv) OSAtomicCompareAndSwap32Barrier(oldv, newv, x) @@ -178,6 +181,8 @@ typedef cairo_atomic_intptr_t cairo_atomic_int_t; cairo_private void _cairo_atomic_int_inc (cairo_atomic_int_t *x); +#define _cairo_atomic_int_dec(x) _cairo_atomic_int_dec_and_test(x) + cairo_private cairo_bool_t _cairo_atomic_int_dec_and_test (cairo_atomic_int_t *x); diff --git a/src/cairo-bentley-ottmann-rectangular.c b/src/cairo-bentley-ottmann-rectangular.c index 51911786..aec7ae41 100644 --- a/src/cairo-bentley-ottmann-rectangular.c +++ b/src/cairo-bentley-ottmann-rectangular.c @@ -42,6 +42,7 @@ #include "cairo-error-private.h" #include "cairo-combsort-private.h" #include "cairo-list-private.h" +#include "cairo-traps-private.h" #include <setjmp.h> @@ -740,7 +741,7 @@ _cairo_bentley_ottmann_tessellate_boxes (const cairo_boxes_t *in, rectangle_t *stack_rectangles_ptrs[ARRAY_LENGTH (stack_rectangles) + 3]; rectangle_t *rectangles, **rectangles_ptrs; rectangle_t *stack_rectangles_chain[CAIRO_STACK_ARRAY_LENGTH (rectangle_t *) ]; - rectangle_t **rectangles_chain; + rectangle_t **rectangles_chain = NULL; const struct _cairo_boxes_chunk *chunk; cairo_status_t status; int i, j, y_min, y_max; @@ -789,13 +790,15 @@ _cairo_bentley_ottmann_tessellate_boxes (const cairo_boxes_t *in, y_max = _cairo_fixed_integer_floor (y_max) + 1; y_max -= y_min; - rectangles_chain = stack_rectangles_chain; - if (y_max > ARRAY_LENGTH (stack_rectangles_chain)) { - rectangles_chain = _cairo_malloc_ab (y_max, sizeof (rectangle_t *)); - if (unlikely (rectangles_chain == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); + if (y_max < in->num_boxes) { + rectangles_chain = stack_rectangles_chain; + if (y_max > ARRAY_LENGTH (stack_rectangles_chain)) { + rectangles_chain = _cairo_malloc_ab (y_max, sizeof (rectangle_t *)); + if (unlikely (rectangles_chain == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + memset (rectangles_chain, 0, y_max * sizeof (rectangle_t*)); } - memset (rectangles_chain, 0, y_max * sizeof (rectangle_t*)); rectangles = stack_rectangles; rectangles_ptrs = stack_rectangles_ptrs; @@ -839,28 +842,38 @@ _cairo_bentley_ottmann_tessellate_boxes (const cairo_boxes_t *in, rectangles[j].top = box[i].p1.y; rectangles[j].bottom = box[i].p2.y; - h = _cairo_fixed_integer_floor (box[i].p1.y) - y_min; - rectangles[j].left.next = (edge_t *)rectangles_chain[h]; - rectangles_chain[h] = &rectangles[j]; + if (rectangles_chain) { + h = _cairo_fixed_integer_floor (box[i].p1.y) - y_min; + rectangles[j].left.next = (edge_t *)rectangles_chain[h]; + rectangles_chain[h] = &rectangles[j]; + } else { + rectangles_ptrs[j+2] = &rectangles[j]; + } j++; } } - j = 2; - for (y_min = 0; y_min < y_max; y_min++) { - rectangle_t *r; - int start = j; - for (r = rectangles_chain[y_min]; r; r = (rectangle_t *)r->left.next) - rectangles_ptrs[j++] = r; - if (j > start + 1) + if (rectangles_chain) { + j = 2; + for (y_min = 0; y_min < y_max; y_min++) { + rectangle_t *r; + int start = j; + for (r = rectangles_chain[y_min]; r; r = (rectangle_t *)r->left.next) + rectangles_ptrs[j++] = r; + if (j > start + 1) _rectangle_sort (rectangles_ptrs + start, j - start); - } + } + + if (rectangles_chain != stack_rectangles_chain) + free (rectangles_chain); - if (rectangles_chain != stack_rectangles_chain) - free (rectangles_chain); + j -= 2; + } else { + _rectangle_sort (rectangles_ptrs + 2, j); + } _cairo_boxes_clear (out); - status = _cairo_bentley_ottmann_tessellate_rectangular (rectangles_ptrs+2, j-2, + status = _cairo_bentley_ottmann_tessellate_rectangular (rectangles_ptrs+2, j, fill_rule, FALSE, out); if (rectangles != stack_rectangles) diff --git a/src/cairo-bentley-ottmann-rectilinear.c b/src/cairo-bentley-ottmann-rectilinear.c index a3eb4901..1edeeb52 100644 --- a/src/cairo-bentley-ottmann-rectilinear.c +++ b/src/cairo-bentley-ottmann-rectilinear.c @@ -41,6 +41,7 @@ #include "cairo-boxes-private.h" #include "cairo-combsort-private.h" #include "cairo-error-private.h" +#include "cairo-traps-private.h" typedef struct _cairo_bo_edge cairo_bo_edge_t; typedef struct _cairo_bo_trap cairo_bo_trap_t; @@ -437,74 +438,6 @@ _cairo_bentley_ottmann_tessellate_rectilinear (cairo_bo_event_t **start_events } cairo_status_t -_cairo_bentley_ottmann_tessellate_rectilinear_polygon (cairo_traps_t *traps, - const cairo_polygon_t *polygon, - cairo_fill_rule_t fill_rule) -{ - cairo_status_t status; - cairo_bo_event_t stack_events[CAIRO_STACK_ARRAY_LENGTH (cairo_bo_event_t)]; - cairo_bo_event_t *events; - cairo_bo_event_t *stack_event_ptrs[ARRAY_LENGTH (stack_events) + 1]; - cairo_bo_event_t **event_ptrs; - cairo_bo_edge_t stack_edges[ARRAY_LENGTH (stack_events)]; - cairo_bo_edge_t *edges; - int num_events; - int i, j; - - if (unlikely (polygon->num_edges == 0)) - return CAIRO_STATUS_SUCCESS; - - num_events = 2 * polygon->num_edges; - - events = stack_events; - event_ptrs = stack_event_ptrs; - edges = stack_edges; - if (num_events > ARRAY_LENGTH (stack_events)) { - events = _cairo_malloc_ab_plus_c (num_events, - sizeof (cairo_bo_event_t) + - sizeof (cairo_bo_edge_t) + - sizeof (cairo_bo_event_t *), - sizeof (cairo_bo_event_t *)); - if (unlikely (events == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - event_ptrs = (cairo_bo_event_t **) (events + num_events); - edges = (cairo_bo_edge_t *) (event_ptrs + num_events + 1); - } - - for (i = j = 0; i < polygon->num_edges; i++) { - edges[i].edge = polygon->edges[i]; - edges[i].deferred_trap.right = NULL; - edges[i].prev = NULL; - edges[i].next = NULL; - - event_ptrs[j] = &events[j]; - events[j].type = CAIRO_BO_EVENT_TYPE_START; - events[j].point.y = polygon->edges[i].top; - events[j].point.x = polygon->edges[i].line.p1.x; - events[j].edge = &edges[i]; - j++; - - event_ptrs[j] = &events[j]; - events[j].type = CAIRO_BO_EVENT_TYPE_STOP; - events[j].point.y = polygon->edges[i].bottom; - events[j].point.x = polygon->edges[i].line.p1.x; - events[j].edge = &edges[i]; - j++; - } - - status = _cairo_bentley_ottmann_tessellate_rectilinear (event_ptrs, j, - fill_rule, - TRUE, traps); - if (events != stack_events) - free (events); - - traps->is_rectilinear = TRUE; - - return status; -} - -cairo_status_t _cairo_bentley_ottmann_tessellate_rectilinear_polygon_to_boxes (const cairo_polygon_t *polygon, cairo_fill_rule_t fill_rule, cairo_boxes_t *boxes) diff --git a/src/cairo-bentley-ottmann.c b/src/cairo-bentley-ottmann.c index 70d4482f..634da6f1 100644 --- a/src/cairo-bentley-ottmann.c +++ b/src/cairo-bentley-ottmann.c @@ -41,6 +41,7 @@ #include "cairo-error-private.h" #include "cairo-freelist-private.h" #include "cairo-combsort-private.h" +#include "cairo-traps-private.h" #define DEBUG_PRINT_STATE 0 #define DEBUG_EVENTS 0 @@ -1301,7 +1302,14 @@ event_log (const char *fmt, ...) static inline cairo_bool_t edges_colinear (const cairo_bo_edge_t *a, const cairo_bo_edge_t *b) { - if (_line_equal (&a->edge.line, &b->edge.line)) + unsigned p; + + p = 0; + p |= (a->edge.line.p1.x == b->edge.line.p1.x) << 0; + p |= (a->edge.line.p1.y == b->edge.line.p1.y) << 1; + p |= (a->edge.line.p2.x == b->edge.line.p2.x) << 3; + p |= (a->edge.line.p2.y == b->edge.line.p2.y) << 4; + if (p == ((1 << 0) | (1 << 1) | (1 << 3) | (1 << 4))) return TRUE; if (_slope_compare (a, b)) @@ -1310,8 +1318,9 @@ edges_colinear (const cairo_bo_edge_t *a, const cairo_bo_edge_t *b) /* The choice of y is not truly arbitrary since we must guarantee that it * is greater than the start of either line. */ - if (a->edge.line.p1.y == b->edge.line.p1.y) { - return a->edge.line.p1.x == b->edge.line.p1.x; + if (p != 0) { + /* colinear if either end-point are coincident */ + return ((p >> 1) & p) != 0; } else if (a->edge.line.p1.y < b->edge.line.p1.y) { return edge_compare_for_y_against_x (b, a->edge.line.p1.y, @@ -1377,8 +1386,9 @@ _cairo_bo_edge_start_or_continue_trap (cairo_bo_edge_t *left, if (left->deferred_trap.right == right) return CAIRO_STATUS_SUCCESS; + assert (right); if (left->deferred_trap.right != NULL) { - if (right != NULL && edges_colinear (left->deferred_trap.right, right)) + if (edges_colinear (left->deferred_trap.right, right)) { /* continuation on right, so just swap edges */ left->deferred_trap.right = right; @@ -1390,7 +1400,7 @@ _cairo_bo_edge_start_or_continue_trap (cairo_bo_edge_t *left, return status; } - if (right != NULL && ! edges_colinear (left, right)) { + if (! edges_colinear (left, right)) { left->deferred_trap.top = top; left->deferred_trap.right = right; @@ -1406,112 +1416,50 @@ _cairo_bo_edge_start_or_continue_trap (cairo_bo_edge_t *left, } static inline cairo_status_t -_active_edges_to_traps (cairo_bo_edge_t *left, - int32_t top, - cairo_fill_rule_t fill_rule, - cairo_traps_t *traps) +_active_edges_to_traps (cairo_bo_edge_t *pos, + int32_t top, + unsigned mask, + cairo_traps_t *traps) { - cairo_bo_edge_t *right; + cairo_bo_edge_t *left; cairo_status_t status; + int in_out; + #if DEBUG_PRINT_STATE printf ("Processing active edges for %x\n", top); #endif - if (fill_rule == CAIRO_FILL_RULE_WINDING) { - while (left != NULL) { - int in_out; - - /* Greedily search for the closing edge, so that we generate the - * maximal span width with the minimal number of trapezoids. - */ - in_out = left->edge.dir; - - /* Check if there is a co-linear edge with an existing trap */ - right = left->next; - if (left->deferred_trap.right == NULL) { - while (right != NULL && right->deferred_trap.right == NULL) - right = right->next; - - if (right != NULL && edges_colinear (left, right)) { - /* continuation on left */ - left->deferred_trap = right->deferred_trap; - right->deferred_trap.right = NULL; - } - } - - /* End all subsumed traps */ - right = left->next; - while (right != NULL) { - if (right->deferred_trap.right != NULL) { - status = _cairo_bo_edge_end_trap (right, top, traps); - if (unlikely (status)) - return status; - } - - in_out += right->edge.dir; - if (in_out == 0) { - cairo_bo_edge_t *next; - cairo_bool_t skip = FALSE; - - /* skip co-linear edges */ - next = right->next; - if (next != NULL) - skip = edges_colinear (right, next); - - if (! skip) - break; - } - - right = right->next; + in_out = 0; + left = pos; + while (pos != NULL) { + if (pos != left && pos->deferred_trap.right) { + if (edges_colinear (left, pos)) { + /* continuation on left */ + assert (left->deferred_trap.right == NULL); + left->deferred_trap = pos->deferred_trap; + pos->deferred_trap.right = NULL; + } else { + status = _cairo_bo_edge_end_trap (pos, top, traps); + if (unlikely (status)) + return status; } - - status = _cairo_bo_edge_start_or_continue_trap (left, right, - top, traps); - if (unlikely (status)) - return status; - - left = right; - if (left != NULL) - left = left->next; } - } else { - while (left != NULL) { - int in_out = 0; - - right = left->next; - while (right != NULL) { - if (right->deferred_trap.right != NULL) { - status = _cairo_bo_edge_end_trap (right, top, traps); - if (unlikely (status)) - return status; - } - - if ((in_out++ & 1) == 0) { - cairo_bo_edge_t *next; - cairo_bool_t skip = FALSE; - /* skip co-linear edges */ - next = right->next; - if (next != NULL) - skip = edges_colinear (right, next); - - if (! skip) - break; - } + in_out += pos->edge.dir; + if ((in_out & mask) == 0) { + /* skip co-linear edges */ + if (pos->next == NULL || ! edges_colinear (pos, pos->next)) { + status = _cairo_bo_edge_start_or_continue_trap (left, pos, + top, traps); + if (unlikely (status)) + return status; - right = right->next; + left = pos->next; } - - status = _cairo_bo_edge_start_or_continue_trap (left, right, - top, traps); - if (unlikely (status)) - return status; - - left = right; - if (left != NULL) - left = left->next; } + + pos = pos->next; } return CAIRO_STATUS_SUCCESS; @@ -1524,7 +1472,7 @@ _active_edges_to_traps (cairo_bo_edge_t *left, static cairo_status_t _cairo_bentley_ottmann_tessellate_bo_edges (cairo_bo_event_t **start_events, int num_events, - cairo_fill_rule_t fill_rule, + unsigned fill_rule, cairo_traps_t *traps, int *num_intersections) { @@ -1536,6 +1484,12 @@ _cairo_bentley_ottmann_tessellate_bo_edges (cairo_bo_event_t **start_events, cairo_bo_edge_t *left, *right; cairo_bo_edge_t *e1, *e2; + /* convert the fill_rule into a winding mask */ + if (fill_rule == CAIRO_FILL_RULE_WINDING) + fill_rule = (unsigned) -1; + else + fill_rule = 1; + #if DEBUG_EVENTS { int i; @@ -1781,7 +1735,7 @@ _cairo_bentley_ottmann_tessellate_polygon (cairo_traps_t *traps, for (y = i = 0; y < ymax && i < num_events; y++) { cairo_bo_start_event_t *e; int j = i; - for (e = event_y[y]; e; e = (cairo_bo_start_event_t *)e->edge.next) + for (e = event_y[y]; e; e = (cairo_bo_start_event_t *)e->edge.next) event_ptrs[i++] = (cairo_bo_event_t *) e; if (i > j + 1) _cairo_bo_event_queue_sort (event_ptrs+j, i-j); diff --git a/src/cairo-botor-scan-converter.c b/src/cairo-botor-scan-converter.c index 0778a5dc..cbb752f0 100644 --- a/src/cairo-botor-scan-converter.c +++ b/src/cairo-botor-scan-converter.c @@ -1397,6 +1397,7 @@ render_rows (cairo_botor_scan_converter_t *self, if (x > prev_x) { spans[num_spans].x = prev_x; + spans[num_spans].inverse = 0; spans[num_spans].coverage = AREA_TO_ALPHA (cover); ++num_spans; } @@ -1413,12 +1414,14 @@ render_rows (cairo_botor_scan_converter_t *self, if (prev_x <= self->xmax) { spans[num_spans].x = prev_x; + spans[num_spans].inverse = 0; spans[num_spans].coverage = AREA_TO_ALPHA (cover); ++num_spans; } if (cover && prev_x < self->xmax) { spans[num_spans].x = self->xmax; + spans[num_spans].inverse = 1; spans[num_spans].coverage = 0; ++num_spans; } @@ -2179,8 +2182,6 @@ _cairo_botor_scan_converter_init (cairo_botor_scan_converter_t *self, cairo_fill_rule_t fill_rule) { self->base.destroy = _cairo_botor_scan_converter_destroy; - self->base.add_edge = _cairo_botor_scan_converter_add_edge; - self->base.add_polygon = _cairo_botor_scan_converter_add_polygon; self->base.generate = _cairo_botor_scan_converter_generate; self->extents = *extents; diff --git a/src/cairo-box-private.h b/src/cairo-box-private.h index 3bced996..d6b99412 100644 --- a/src/cairo-box-private.h +++ b/src/cairo-box-private.h @@ -37,6 +37,7 @@ #include "cairo-types-private.h" #include "cairo-compiler-private.h" +#include "cairo-fixed-private.h" static inline void _cairo_box_set (cairo_box_t *box, @@ -47,6 +48,15 @@ _cairo_box_set (cairo_box_t *box, box->p2 = *p2; } +static inline void +_cairo_box_from_integers (cairo_box_t *box, int x, int y, int w, int h) +{ + box->p1.x = _cairo_fixed_from_int (x); + box->p1.y = _cairo_fixed_from_int (y); + box->p2.x = _cairo_fixed_from_int (x + w); + box->p2.y = _cairo_fixed_from_int (y + h); +} + /* assumes box->p1 is top-left, p2 bottom-right */ static inline void _cairo_box_add_point (cairo_box_t *box, @@ -63,13 +73,49 @@ _cairo_box_add_point (cairo_box_t *box, box->p2.y = point->y; } +static inline void +_cairo_box_add_box (cairo_box_t *box, + const cairo_box_t *add) +{ + if (add->p1.x < box->p1.x) + box->p1.x = add->p1.x; + if (add->p2.x > box->p2.x) + box->p2.x = add->p2.x; + + if (add->p1.y < box->p1.y) + box->p1.y = add->p1.y; + if (add->p2.y > box->p2.y) + box->p2.y = add->p2.y; +} + /* assumes box->p1 is top-left, p2 bottom-right */ static inline cairo_bool_t -_cairo_box_contains_point (cairo_box_t *box, +_cairo_box_contains_point (const cairo_box_t *box, const cairo_point_t *point) { return box->p1.x <= point->x && point->x <= box->p2.x && box->p1.y <= point->y && point->y <= box->p2.y; } +static inline cairo_bool_t +_cairo_box_is_pixel_aligned (const cairo_box_t *box) +{ +#if CAIRO_FIXED_FRAC_BITS <= 8 && 0 + return ((box->p1.x & CAIRO_FIXED_FRAC_MASK) << 24 | + (box->p1.y & CAIRO_FIXED_FRAC_MASK) << 16 | + (box->p2.x & CAIRO_FIXED_FRAC_MASK) << 8 | + (box->p2.y & CAIRO_FIXED_FRAC_MASK) << 0) == 0; +#else /* GCC on i7 prefers this variant (bizarrely according to the profiler) */ + cairo_fixed_t f; + + f = 0; + f |= box->p1.x & CAIRO_FIXED_FRAC_MASK; + f |= box->p1.y & CAIRO_FIXED_FRAC_MASK; + f |= box->p2.x & CAIRO_FIXED_FRAC_MASK; + f |= box->p2.y & CAIRO_FIXED_FRAC_MASK; + + return f == 0; +#endif +} + #endif /* CAIRO_BOX_H */ diff --git a/src/cairo-boxes-intersect.c b/src/cairo-boxes-intersect.c index 230c6f01..dd4c2410 100644 --- a/src/cairo-boxes-intersect.c +++ b/src/cairo-boxes-intersect.c @@ -535,19 +535,44 @@ _cairo_boxes_intersect_with_box (const cairo_boxes_t *boxes, const cairo_box_t *box, cairo_boxes_t *out) { - const struct _cairo_boxes_chunk *chunk; cairo_status_t status; - int i; + int i, j; + + if (out == boxes) { /* inplace update */ + struct _cairo_boxes_chunk *chunk; + + out->num_boxes = 0; + for (chunk = &out->chunks; chunk != NULL; chunk = chunk->next) { + for (i = j = 0; i < chunk->count; i++) { + cairo_box_t *b = &chunk->base[i]; + + b->p1.x = MAX (b->p1.x, box->p1.x); + b->p1.y = MAX (b->p1.y, box->p1.y); + b->p2.x = MIN (b->p2.x, box->p2.x); + b->p2.y = MIN (b->p2.y, box->p2.y); + if (b->p1.x < b->p2.x && b->p1.y < b->p2.y) { + if (i != j) + chunk->base[j] = *b; + j++; + } + } + /* XXX unlink empty chains? */ + chunk->count = j; + out->num_boxes += j; + } + } else { + const struct _cairo_boxes_chunk *chunk; - _cairo_boxes_clear (out); - _cairo_boxes_limit (out, box, 1); - for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { - for (i = 0; i < chunk->count; i++) { - status = _cairo_boxes_add (out, - CAIRO_ANTIALIAS_DEFAULT, - &chunk->base[i]); - if (unlikely (status)) - return status; + _cairo_boxes_clear (out); + _cairo_boxes_limit (out, box, 1); + for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + status = _cairo_boxes_add (out, + CAIRO_ANTIALIAS_DEFAULT, + &chunk->base[i]); + if (unlikely (status)) + return status; + } } } diff --git a/src/cairo-boxes-private.h b/src/cairo-boxes-private.h index 890d1b2d..57d1228b 100644 --- a/src/cairo-boxes-private.h +++ b/src/cairo-boxes-private.h @@ -42,11 +42,14 @@ struct _cairo_boxes_t { cairo_status_t status; + cairo_box_t limit; const cairo_box_t *limits; int num_limits; + int num_boxes; - unsigned int is_pixel_aligned : 1; + + unsigned int is_pixel_aligned; struct _cairo_boxes_chunk { struct _cairo_boxes_chunk *next; @@ -70,6 +73,10 @@ _cairo_boxes_init_for_array (cairo_boxes_t *boxes, int num_boxes); cairo_private void +_cairo_boxes_init_from_rectangle (cairo_boxes_t *boxes, + int x, int y, int w, int h); + +cairo_private void _cairo_boxes_limit (cairo_boxes_t *boxes, const cairo_box_t *limits, int num_limits); @@ -81,7 +88,7 @@ _cairo_boxes_add (cairo_boxes_t *boxes, cairo_private void _cairo_boxes_extents (const cairo_boxes_t *boxes, - cairo_rectangle_int_t *extents); + cairo_box_t *box); cairo_private cairo_box_t * _cairo_boxes_to_array (const cairo_boxes_t *boxes, @@ -104,6 +111,11 @@ _cairo_boxes_intersect (const cairo_boxes_t *a, cairo_private void _cairo_boxes_clear (cairo_boxes_t *boxes); +cairo_private_no_warn cairo_bool_t +_cairo_boxes_for_each_box (cairo_boxes_t *boxes, + cairo_bool_t (*func) (cairo_box_t *box, void *data), + void *data); + cairo_private void _cairo_boxes_fini (cairo_boxes_t *boxes); diff --git a/src/cairo-boxes.c b/src/cairo-boxes.c index 130a44c7..182601a7 100644 --- a/src/cairo-boxes.c +++ b/src/cairo-boxes.c @@ -33,6 +33,7 @@ #include "cairoint.h" +#include "cairo-box-private.h" #include "cairo-boxes-private.h" #include "cairo-error-private.h" @@ -53,6 +54,16 @@ _cairo_boxes_init (cairo_boxes_t *boxes) } void +_cairo_boxes_init_from_rectangle (cairo_boxes_t *boxes, + int x, int y, int w, int h) +{ + _cairo_boxes_init (boxes); + + _cairo_box_from_integers (&boxes->chunks.base[0], x, y, w, h); + boxes->num_boxes = 1; +} + +void _cairo_boxes_init_with_clip (cairo_boxes_t *boxes, cairo_clip_t *clip) { @@ -154,13 +165,8 @@ _cairo_boxes_add_internal (cairo_boxes_t *boxes, chunk->base[chunk->count++] = *box; boxes->num_boxes++; - if (boxes->is_pixel_aligned) { - boxes->is_pixel_aligned = - _cairo_fixed_is_integer (box->p1.x) && - _cairo_fixed_is_integer (box->p1.y) && - _cairo_fixed_is_integer (box->p2.x) && - _cairo_fixed_is_integer (box->p2.y); - } + if (boxes->is_pixel_aligned) + boxes->is_pixel_aligned = _cairo_box_is_pixel_aligned (box); } cairo_status_t @@ -261,38 +267,34 @@ _cairo_boxes_add (cairo_boxes_t *boxes, void _cairo_boxes_extents (const cairo_boxes_t *boxes, - cairo_rectangle_int_t *extents) + cairo_box_t *box) { const struct _cairo_boxes_chunk *chunk; - cairo_box_t box; + cairo_box_t b; int i; if (boxes->num_boxes == 0) { - extents->x = extents->y = extents->width = extents->height = 0; + box->p1.x = box->p1.y = box->p2.x = box->p2.y = 0; return; } - box.p1.y = box.p1.x = INT_MAX; - box.p2.y = box.p2.x = INT_MIN; - + b = boxes->chunks.base[0]; for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { - const cairo_box_t *b = chunk->base; for (i = 0; i < chunk->count; i++) { - if (b[i].p1.x < box.p1.x) - box.p1.x = b[i].p1.x; + if (chunk->base[i].p1.x < b.p1.x) + b.p1.x = chunk->base[i].p1.x; - if (b[i].p1.y < box.p1.y) - box.p1.y = b[i].p1.y; + if (chunk->base[i].p1.y < b.p1.y) + b.p1.y = chunk->base[i].p1.y; - if (b[i].p2.x > box.p2.x) - box.p2.x = b[i].p2.x; + if (chunk->base[i].p2.x > b.p2.x) + b.p2.x = chunk->base[i].p2.x; - if (b[i].p2.y > box.p2.y) - box.p2.y = b[i].p2.y; + if (chunk->base[i].p2.y > b.p2.y) + b.p2.y = chunk->base[i].p2.y; } } - - _cairo_box_round_to_rectangle (&box, extents); + *box = b; } void @@ -354,17 +356,38 @@ _cairo_boxes_fini (cairo_boxes_t *boxes) } } +cairo_bool_t +_cairo_boxes_for_each_box (cairo_boxes_t *boxes, + cairo_bool_t (*func) (cairo_box_t *box, void *data), + void *data) +{ + struct _cairo_boxes_chunk *chunk; + int i; + + for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) + if (! func (&chunk->base[i], data)) + return FALSE; + } + + return TRUE; +} + + void _cairo_debug_print_boxes (FILE *stream, const cairo_boxes_t *boxes) { - cairo_rectangle_int_t extents; const struct _cairo_boxes_chunk *chunk; + cairo_box_t extents; int i; _cairo_boxes_extents (boxes, &extents); - fprintf (stream, "boxes x %d: (%d, %d) x (%d, %d)\n", + fprintf (stream, "boxes x %d: (%f, %f) x (%f, %f)\n", boxes->num_boxes, - extents.x, extents.y, extents.width, extents.height); + _cairo_fixed_to_double (extents.p1.x), + _cairo_fixed_to_double (extents.p1.y), + _cairo_fixed_to_double (extents.p2.x), + _cairo_fixed_to_double (extents.p2.y)); for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { for (i = 0; i < chunk->count; i++) { diff --git a/src/cairo-cff-subset.c b/src/cairo-cff-subset.c index 6c717958..3ee3ef39 100644 --- a/src/cairo-cff-subset.c +++ b/src/cairo-cff-subset.c @@ -42,6 +42,8 @@ #define _BSD_SOURCE /* for snprintf(), strdup() */ #include "cairoint.h" + +#include "cairo-array-private.h" #include "cairo-error-private.h" #if CAIRO_HAS_FONT_SUBSET @@ -2897,7 +2899,7 @@ cairo_bool_t _cairo_cff_scaled_font_is_cid_cff (cairo_scaled_font_t *scaled_font) { const cairo_scaled_font_backend_t *backend; - cairo_status_t status; + cairo_int_status_t status; unsigned char *data; unsigned long data_length; unsigned char *current_ptr; @@ -2916,7 +2918,7 @@ _cairo_cff_scaled_font_is_cid_cff (cairo_scaled_font_t *scaled_font) /* Try to load an OpenType/CFF font */ if (backend->load_truetype_table && (status = backend->load_truetype_table (scaled_font, TT_TAG_CFF, - 0, NULL, &data_length)) == CAIRO_STATUS_SUCCESS) + 0, NULL, &data_length)) == CAIRO_INT_STATUS_SUCCESS) { data = malloc (data_length); if (unlikely (data == NULL)) { @@ -2933,7 +2935,7 @@ _cairo_cff_scaled_font_is_cid_cff (cairo_scaled_font_t *scaled_font) if (status == CAIRO_INT_STATUS_UNSUPPORTED && backend->load_type1_data && (status = backend->load_type1_data (scaled_font, - 0, NULL, &data_length)) == CAIRO_STATUS_SUCCESS) + 0, NULL, &data_length)) == CAIRO_INT_STATUS_SUCCESS) { data = malloc (data_length); if (unlikely (data == NULL)) { diff --git a/src/cairo-clip-boxes.c b/src/cairo-clip-boxes.c index e18c2f8e..3b8265b9 100644 --- a/src/cairo-clip-boxes.c +++ b/src/cairo-clip-boxes.c @@ -40,6 +40,8 @@ */ #include "cairoint.h" + +#include "cairo-box-private.h" #include "cairo-clip-private.h" #include "cairo-error-private.h" #include "cairo-freed-pool-private.h" @@ -62,7 +64,6 @@ pot (int v) return v; } - static cairo_bool_t _cairo_clip_contains_rectangle_box (const cairo_clip_t *clip, const cairo_rectangle_int_t *rect, @@ -90,7 +91,6 @@ _cairo_clip_contains_rectangle_box (const cairo_clip_t *clip, } /* Check for a clip-box that wholly contains the rectangle */ - assert (clip->num_boxes); for (i = 0; i < clip->num_boxes; i++) { if (box->p1.x >= clip->boxes[i].p1.x && box->p1.y >= clip->boxes[i].p1.y && @@ -176,6 +176,8 @@ _cairo_clip_intersect_rectangle_box (cairo_clip_t *clip, if (! _cairo_rectangle_intersect (&clip->extents, r)) clip = _cairo_clip_set_all_clipped (clip); } + if (clip->path == NULL) + clip->is_region = _cairo_box_is_pixel_aligned (box); return clip; } @@ -269,6 +271,7 @@ _cairo_clip_intersect_boxes (cairo_clip_t *clip, const cairo_boxes_t *boxes) { cairo_boxes_t clip_boxes; + cairo_box_t limits; cairo_rectangle_int_t extents; if (_cairo_clip_is_all_clipped (clip)) @@ -301,10 +304,11 @@ _cairo_clip_intersect_boxes (cairo_clip_t *clip, } else { clip->boxes = _cairo_boxes_to_array (boxes, &clip->num_boxes, TRUE); } - _cairo_boxes_extents (boxes, &extents); + _cairo_boxes_extents (boxes, &limits); if (boxes == &clip_boxes) _cairo_boxes_fini (&clip_boxes); + _cairo_box_round_to_rectangle (&limits, &extents); if (clip->path == NULL) clip->extents = extents; else if (! _cairo_rectangle_intersect (&clip->extents, &extents)) @@ -557,37 +561,10 @@ _cairo_clip_reduce_for_composite (const cairo_clip_t *clip, return _cairo_clip_reduce_to_rectangle (clip, r); } -cairo_status_t -_cairo_clip_to_boxes (cairo_clip_t *clip, - cairo_boxes_t *boxes) -{ - _cairo_boxes_init_for_array (boxes, clip->boxes, clip->num_boxes); - - if (clip->path == NULL) { - cairo_box_t *src = clip->boxes; - int i; - - clip->boxes = _cairo_malloc_ab (clip->num_boxes, sizeof (cairo_box_t)); - if (clip->boxes == NULL) { - clip->boxes = src; - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - for (i = 0; i < clip->num_boxes; i++) { - clip->boxes[i].p1.x = _cairo_fixed_floor (src[i].p1.x); - clip->boxes[i].p1.y = _cairo_fixed_floor (src[i].p1.y); - clip->boxes[i].p2.x = _cairo_fixed_ceil (src[i].p2.x); - clip->boxes[i].p2.y = _cairo_fixed_ceil (src[i].p2.y); - } - } - - return CAIRO_STATUS_SUCCESS; - -} - cairo_clip_t * _cairo_clip_from_boxes (const cairo_boxes_t *boxes) { + cairo_box_t extents; cairo_clip_t *clip = _cairo_clip_create (); if (clip == NULL) return _cairo_clip_set_all_clipped (clip); @@ -603,7 +580,8 @@ _cairo_clip_from_boxes (const cairo_boxes_t *boxes) return _cairo_clip_set_all_clipped (clip); } - _cairo_boxes_extents (boxes, &clip->extents); + _cairo_boxes_extents (boxes, &extents); + _cairo_box_round_to_rectangle (&extents, &clip->extents); return clip; } diff --git a/src/cairo-clip-private.h b/src/cairo-clip-private.h index 3ebcb0e2..7cbef24a 100644 --- a/src/cairo-clip-private.h +++ b/src/cairo-clip-private.h @@ -40,6 +40,7 @@ #include "cairo-types-private.h" #include "cairo-boxes-private.h" +#include "cairo-error-private.h" #include "cairo-compiler-private.h" #include "cairo-error-private.h" #include "cairo-path-fixed-private.h" @@ -160,14 +161,30 @@ _cairo_clip_get_extents (const cairo_clip_t *clip); cairo_private cairo_surface_t * _cairo_clip_get_surface (const cairo_clip_t *clip, cairo_surface_t *dst, int *tx, int *ty); +cairo_private cairo_surface_t * +_cairo_clip_get_image (const cairo_clip_t *clip, + cairo_surface_t *target, + const cairo_rectangle_int_t *extents); + cairo_private cairo_status_t _cairo_clip_combine_with_surface (const cairo_clip_t *clip, cairo_surface_t *dst, int dst_x, int dst_y); -cairo_private cairo_status_t -_cairo_clip_to_boxes (cairo_clip_t *clip, - cairo_boxes_t *boxes); +static inline void +_cairo_clip_steal_boxes (cairo_clip_t *clip, cairo_boxes_t *boxes) +{ + _cairo_boxes_init_for_array (boxes, clip->boxes, clip->num_boxes); + clip->boxes = NULL; + clip->num_boxes = 0; +} + +static inline void +_cairo_clip_unsteal_boxes (cairo_clip_t *clip, cairo_boxes_t *boxes) +{ + clip->boxes = boxes->chunks.base; + clip->num_boxes = boxes->num_boxes; +} cairo_private cairo_clip_t * _cairo_clip_from_boxes (const cairo_boxes_t *boxes); diff --git a/src/cairo-clip-region.c b/src/cairo-clip-region.c index 28a0d4bb..e3f4891e 100644 --- a/src/cairo-clip-region.c +++ b/src/cairo-clip-region.c @@ -105,10 +105,16 @@ _cairo_clip_is_region (const cairo_clip_t *clip) if (clip == NULL) return TRUE; + if (clip->is_region) + return TRUE; + /* XXX Geometric reduction? */ if (clip->path) - return FALSE; + return FALSE; + + if (clip->num_boxes == 0) + return TRUE; if (clip->region == NULL) _cairo_clip_extract_region ((cairo_clip_t *) clip); diff --git a/src/cairo-clip-surface.c b/src/cairo-clip-surface.c index 79e6a627..e1e93129 100644 --- a/src/cairo-clip-surface.c +++ b/src/cairo-clip-surface.c @@ -103,8 +103,7 @@ _cairo_clip_get_surface (const cairo_clip_t *clip, CAIRO_CONTENT_ALPHA, clip->extents.width, clip->extents.height, - CAIRO_COLOR_TRANSPARENT, - TRUE); + CAIRO_COLOR_WHITE); if (unlikely (surface->status)) return surface; @@ -114,12 +113,7 @@ _cairo_clip_get_surface (const cairo_clip_t *clip, copy_path = copy->path; copy->path = NULL; - assert (copy->num_boxes); - status = _cairo_surface_paint (surface, - CAIRO_OPERATOR_ADD, - &_cairo_pattern_white.base, - copy); - + status = CAIRO_STATUS_SUCCESS; clip_path = copy_path; while (status == CAIRO_STATUS_SUCCESS && clip_path) { status = _cairo_surface_fill (surface, @@ -140,3 +134,32 @@ _cairo_clip_get_surface (const cairo_clip_t *clip, *ty = clip->extents.y; return surface; } + +cairo_surface_t * +_cairo_clip_get_image (const cairo_clip_t *clip, + cairo_surface_t *target, + const cairo_rectangle_int_t *extents) +{ + cairo_surface_t *surface; + cairo_status_t status; + + surface = cairo_surface_create_similar_image (target, + CAIRO_FORMAT_A8, + extents->width, + extents->height); + if (unlikely (surface->status)) + return surface; + + status = _cairo_surface_paint (surface, CAIRO_OPERATOR_SOURCE, + &_cairo_pattern_white.base, NULL); + if (likely (status == CAIRO_STATUS_SUCCESS)) + status = _cairo_clip_combine_with_surface (clip, surface, + extents->x, extents->y); + + if (unlikely (status)) { + cairo_surface_destroy (surface); + surface = _cairo_surface_create_in_error (status); + } + + return surface; +} diff --git a/src/cairo-clip-tor-scan-converter.c b/src/cairo-clip-tor-scan-converter.c new file mode 100644 index 00000000..e32a5a9d --- /dev/null +++ b/src/cairo-clip-tor-scan-converter.c @@ -0,0 +1,1845 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* glitter-paths - polygon scan converter + * + * Copyright (c) 2008 M Joonas Pihlaja + * Copyright (c) 2007 David Turner + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + */ +/* This is the Glitter paths scan converter incorporated into cairo. + * The source is from commit 734c53237a867a773640bd5b64816249fa1730f8 + * of + * + * http://gitweb.freedesktop.org/?p=users/joonas/glitter-paths + */ +/* Glitter-paths is a stand alone polygon rasteriser derived from + * David Turner's reimplementation of Tor Anderssons's 15x17 + * supersampling rasteriser from the Apparition graphics library. The + * main new feature here is cheaply choosing per-scan line between + * doing fully analytical coverage computation for an entire row at a + * time vs. using a supersampling approach. + * + * David Turner's code can be found at + * + * http://david.freetype.org/rasterizer-shootout/raster-comparison-20070813.tar.bz2 + * + * In particular this file incorporates large parts of ftgrays_tor10.h + * from raster-comparison-20070813.tar.bz2 + */ +/* Overview + * + * A scan converter's basic purpose to take polygon edges and convert + * them into an RLE compressed A8 mask. This one works in two phases: + * gathering edges and generating spans. + * + * 1) As the user feeds the scan converter edges they are vertically + * clipped and bucketted into a _polygon_ data structure. The edges + * are also snapped from the user's coordinates to the subpixel grid + * coordinates used during scan conversion. + * + * user + * | + * | edges + * V + * polygon buckets + * + * 2) Generating spans works by performing a vertical sweep of pixel + * rows from top to bottom and maintaining an _active_list_ of edges + * that intersect the row. From the active list the fill rule + * determines which edges are the left and right edges of the start of + * each span, and their contribution is then accumulated into a pixel + * coverage list (_cell_list_) as coverage deltas. Once the coverage + * deltas of all edges are known we can form spans of constant pixel + * coverage by summing the deltas during a traversal of the cell list. + * At the end of a pixel row the cell list is sent to a coverage + * blitter for rendering to some target surface. + * + * The pixel coverages are computed by either supersampling the row + * and box filtering a mono rasterisation, or by computing the exact + * coverages of edges in the active list. The supersampling method is + * used whenever some edge starts or stops within the row or there are + * edge intersections in the row. + * + * polygon bucket for \ + * current pixel row | + * | | + * | activate new edges | Repeat GRID_Y times if we + * V \ are supersampling this row, + * active list / or just once if we're computing + * | | analytical coverage. + * | coverage deltas | + * V | + * pixel coverage list / + * | + * V + * coverage blitter + */ +#include "cairoint.h" +#include "cairo-spans-private.h" +#include "cairo-error-private.h" + +#include <assert.h> +#include <stdlib.h> +#include <string.h> +#include <limits.h> +#include <setjmp.h> + +/* The input coordinate scale and the rasterisation grid scales. */ +#define GLITTER_INPUT_BITS CAIRO_FIXED_FRAC_BITS +#define GRID_X_BITS CAIRO_FIXED_FRAC_BITS +#define GRID_Y 15 + +/* Set glitter up to use a cairo span renderer to do the coverage + * blitting. */ +struct pool; +struct cell_list; + +/*------------------------------------------------------------------------- + * glitter-paths.h + */ + +/* "Input scaled" numbers are fixed precision reals with multiplier + * 2**GLITTER_INPUT_BITS. Input coordinates are given to glitter as + * pixel scaled numbers. These get converted to the internal grid + * scaled numbers as soon as possible. Internal overflow is possible + * if GRID_X/Y inside glitter-paths.c is larger than + * 1<<GLITTER_INPUT_BITS. */ +#ifndef GLITTER_INPUT_BITS +# define GLITTER_INPUT_BITS 8 +#endif +#define GLITTER_INPUT_SCALE (1<<GLITTER_INPUT_BITS) +typedef int glitter_input_scaled_t; + +/* Opaque type for scan converting. */ +typedef struct glitter_scan_converter glitter_scan_converter_t; + +/*------------------------------------------------------------------------- + * glitter-paths.c: Implementation internal types + */ +#include <stdlib.h> +#include <string.h> +#include <limits.h> + +/* All polygon coordinates are snapped onto a subsample grid. "Grid + * scaled" numbers are fixed precision reals with multiplier GRID_X or + * GRID_Y. */ +typedef int grid_scaled_t; +typedef int grid_scaled_x_t; +typedef int grid_scaled_y_t; + +/* Default x/y scale factors. + * You can either define GRID_X/Y_BITS to get a power-of-two scale + * or define GRID_X/Y separately. */ +#if !defined(GRID_X) && !defined(GRID_X_BITS) +# define GRID_X_BITS 8 +#endif +#if !defined(GRID_Y) && !defined(GRID_Y_BITS) +# define GRID_Y 15 +#endif + +/* Use GRID_X/Y_BITS to define GRID_X/Y if they're available. */ +#ifdef GRID_X_BITS +# define GRID_X (1 << GRID_X_BITS) +#endif +#ifdef GRID_Y_BITS +# define GRID_Y (1 << GRID_Y_BITS) +#endif + +/* The GRID_X_TO_INT_FRAC macro splits a grid scaled coordinate into + * integer and fractional parts. The integer part is floored. */ +#if defined(GRID_X_TO_INT_FRAC) + /* do nothing */ +#elif defined(GRID_X_BITS) +# define GRID_X_TO_INT_FRAC(x, i, f) \ + _GRID_TO_INT_FRAC_shift(x, i, f, GRID_X_BITS) +#else +# define GRID_X_TO_INT_FRAC(x, i, f) \ + _GRID_TO_INT_FRAC_general(x, i, f, GRID_X) +#endif + +#define _GRID_TO_INT_FRAC_general(t, i, f, m) do { \ + (i) = (t) / (m); \ + (f) = (t) % (m); \ + if ((f) < 0) { \ + --(i); \ + (f) += (m); \ + } \ +} while (0) + +#define _GRID_TO_INT_FRAC_shift(t, i, f, b) do { \ + (f) = (t) & ((1 << (b)) - 1); \ + (i) = (t) >> (b); \ +} while (0) + +/* A grid area is a real in [0,1] scaled by 2*GRID_X*GRID_Y. We want + * to be able to represent exactly areas of subpixel trapezoids whose + * vertices are given in grid scaled coordinates. The scale factor + * comes from needing to accurately represent the area 0.5*dx*dy of a + * triangle with base dx and height dy in grid scaled numbers. */ +typedef int grid_area_t; +#define GRID_XY (2*GRID_X*GRID_Y) /* Unit area on the grid. */ + +/* GRID_AREA_TO_ALPHA(area): map [0,GRID_XY] to [0,255]. */ +#if GRID_XY == 510 +# define GRID_AREA_TO_ALPHA(c) (((c)+1) >> 1) +#elif GRID_XY == 255 +# define GRID_AREA_TO_ALPHA(c) (c) +#elif GRID_XY == 64 +# define GRID_AREA_TO_ALPHA(c) (((c) << 2) | -(((c) & 0x40) >> 6)) +#elif GRID_XY == 128 +# define GRID_AREA_TO_ALPHA(c) ((((c) << 1) | -((c) >> 7)) & 255) +#elif GRID_XY == 256 +# define GRID_AREA_TO_ALPHA(c) (((c) | -((c) >> 8)) & 255) +#elif GRID_XY == 15 +# define GRID_AREA_TO_ALPHA(c) (((c) << 4) + (c)) +#elif GRID_XY == 2*256*15 +# define GRID_AREA_TO_ALPHA(c) (((c) + ((c)<<4) + 256) >> 9) +#else +# define GRID_AREA_TO_ALPHA(c) (((c)*255 + GRID_XY/2) / GRID_XY) +#endif + +#define UNROLL3(x) x x x + +struct quorem { + int32_t quo; + int32_t rem; +}; + +/* Header for a chunk of memory in a memory pool. */ +struct _pool_chunk { + /* # bytes used in this chunk. */ + size_t size; + + /* # bytes total in this chunk */ + size_t capacity; + + /* Pointer to the previous chunk or %NULL if this is the sentinel + * chunk in the pool header. */ + struct _pool_chunk *prev_chunk; + + /* Actual data starts here. Well aligned for pointers. */ +}; + +/* A memory pool. This is supposed to be embedded on the stack or + * within some other structure. It may optionally be followed by an + * embedded array from which requests are fulfilled until + * malloc needs to be called to allocate a first real chunk. */ +struct pool { + /* Chunk we're allocating from. */ + struct _pool_chunk *current; + + jmp_buf *jmp; + + /* Free list of previously allocated chunks. All have >= default + * capacity. */ + struct _pool_chunk *first_free; + + /* The default capacity of a chunk. */ + size_t default_capacity; + + /* Header for the sentinel chunk. Directly following the pool + * struct should be some space for embedded elements from which + * the sentinel chunk allocates from. */ + struct _pool_chunk sentinel[1]; +}; + +/* A polygon edge. */ +struct edge { + /* Next in y-bucket or active list. */ + struct edge *next; + + /* Current x coordinate while the edge is on the active + * list. Initialised to the x coordinate of the top of the + * edge. The quotient is in grid_scaled_x_t units and the + * remainder is mod dy in grid_scaled_y_t units.*/ + struct quorem x; + + /* Advance of the current x when moving down a subsample line. */ + struct quorem dxdy; + + /* Advance of the current x when moving down a full pixel + * row. Only initialised when the height of the edge is large + * enough that there's a chance the edge could be stepped by a + * full row's worth of subsample rows at a time. */ + struct quorem dxdy_full; + + /* The clipped y of the top of the edge. */ + grid_scaled_y_t ytop; + + /* y2-y1 after orienting the edge downwards. */ + grid_scaled_y_t dy; + + /* Number of subsample rows remaining to scan convert of this + * edge. */ + grid_scaled_y_t height_left; + + /* Original sign of the edge: +1 for downwards, -1 for upwards + * edges. */ + int dir; + int vertical; + int clip; +}; + +/* Number of subsample rows per y-bucket. Must be GRID_Y. */ +#define EDGE_Y_BUCKET_HEIGHT GRID_Y + +#define EDGE_Y_BUCKET_INDEX(y, ymin) (((y) - (ymin))/EDGE_Y_BUCKET_HEIGHT) + +/* A collection of sorted and vertically clipped edges of the polygon. + * Edges are moved from the polygon to an active list while scan + * converting. */ +struct polygon { + /* The vertical clip extents. */ + grid_scaled_y_t ymin, ymax; + + /* Array of edges all starting in the same bucket. An edge is put + * into bucket EDGE_BUCKET_INDEX(edge->ytop, polygon->ymin) when + * it is added to the polygon. */ + struct edge **y_buckets; + struct edge *y_buckets_embedded[64]; + + struct { + struct pool base[1]; + struct edge embedded[32]; + } edge_pool; +}; + +/* A cell records the effect on pixel coverage of polygon edges + * passing through a pixel. It contains two accumulators of pixel + * coverage. + * + * Consider the effects of a polygon edge on the coverage of a pixel + * it intersects and that of the following one. The coverage of the + * following pixel is the height of the edge multiplied by the width + * of the pixel, and the coverage of the pixel itself is the area of + * the trapezoid formed by the edge and the right side of the pixel. + * + * +-----------------------+-----------------------+ + * | | | + * | | | + * |_______________________|_______________________| + * | \...................|.......................|\ + * | \..................|.......................| | + * | \.................|.......................| | + * | \....covered.....|.......................| | + * | \....area.......|.......................| } covered height + * | \..............|.......................| | + * |uncovered\.............|.......................| | + * | area \............|.......................| | + * |___________\...........|.......................|/ + * | | | + * | | | + * | | | + * +-----------------------+-----------------------+ + * + * Since the coverage of the following pixel will always be a multiple + * of the width of the pixel, we can store the height of the covered + * area instead. The coverage of the pixel itself is the total + * coverage minus the area of the uncovered area to the left of the + * edge. As it's faster to compute the uncovered area we only store + * that and subtract it from the total coverage later when forming + * spans to blit. + * + * The heights and areas are signed, with left edges of the polygon + * having positive sign and right edges having negative sign. When + * two edges intersect they swap their left/rightness so their + * contribution above and below the intersection point must be + * computed separately. */ +struct cell { + struct cell *next; + int x; + grid_area_t uncovered_area; + grid_scaled_y_t covered_height; + grid_scaled_y_t clipped_height; +}; + +/* A cell list represents the scan line sparsely as cells ordered by + * ascending x. It is geared towards scanning the cells in order + * using an internal cursor. */ +struct cell_list { + /* Sentinel nodes */ + struct cell head, tail; + + /* Cursor state for iterating through the cell list. */ + struct cell *cursor; + + /* Cells in the cell list are owned by the cell list and are + * allocated from this pool. */ + struct { + struct pool base[1]; + struct cell embedded[32]; + } cell_pool; +}; + +struct cell_pair { + struct cell *cell1; + struct cell *cell2; +}; + +/* The active list contains edges in the current scan line ordered by + * the x-coordinate of the intercept of the edge and the scan line. */ +struct active_list { + /* Leftmost edge on the current scan line. */ + struct edge *head; + + /* A lower bound on the height of the active edges is used to + * estimate how soon some active edge ends. We can't advance the + * scan conversion by a full pixel row if an edge ends somewhere + * within it. */ + grid_scaled_y_t min_height; +}; + +struct glitter_scan_converter { + struct polygon polygon[1]; + struct active_list active[1]; + struct cell_list coverages[1]; + + /* Clip box. */ + grid_scaled_y_t ymin, ymax; +}; + +/* Compute the floored division a/b. Assumes / and % perform symmetric + * division. */ +inline static struct quorem +floored_divrem(int a, int b) +{ + struct quorem qr; + qr.quo = a/b; + qr.rem = a%b; + if ((a^b)<0 && qr.rem) { + qr.quo -= 1; + qr.rem += b; + } + return qr; +} + +/* Compute the floored division (x*a)/b. Assumes / and % perform symmetric + * division. */ +static struct quorem +floored_muldivrem(int x, int a, int b) +{ + struct quorem qr; + long long xa = (long long)x*a; + qr.quo = xa/b; + qr.rem = xa%b; + if ((xa>=0) != (b>=0) && qr.rem) { + qr.quo -= 1; + qr.rem += b; + } + return qr; +} + +static struct _pool_chunk * +_pool_chunk_init( + struct _pool_chunk *p, + struct _pool_chunk *prev_chunk, + size_t capacity) +{ + p->prev_chunk = prev_chunk; + p->size = 0; + p->capacity = capacity; + return p; +} + +static struct _pool_chunk * +_pool_chunk_create(struct pool *pool, size_t size) +{ + struct _pool_chunk *p; + + p = malloc(size + sizeof(struct _pool_chunk)); + if (unlikely (NULL == p)) + longjmp (*pool->jmp, _cairo_error (CAIRO_STATUS_NO_MEMORY)); + + return _pool_chunk_init(p, pool->current, size); +} + +static void +pool_init(struct pool *pool, + jmp_buf *jmp, + size_t default_capacity, + size_t embedded_capacity) +{ + pool->jmp = jmp; + pool->current = pool->sentinel; + pool->first_free = NULL; + pool->default_capacity = default_capacity; + _pool_chunk_init(pool->sentinel, NULL, embedded_capacity); +} + +static void +pool_fini(struct pool *pool) +{ + struct _pool_chunk *p = pool->current; + do { + while (NULL != p) { + struct _pool_chunk *prev = p->prev_chunk; + if (p != pool->sentinel) + free(p); + p = prev; + } + p = pool->first_free; + pool->first_free = NULL; + } while (NULL != p); +} + +/* Satisfy an allocation by first allocating a new large enough chunk + * and adding it to the head of the pool's chunk list. This function + * is called as a fallback if pool_alloc() couldn't do a quick + * allocation from the current chunk in the pool. */ +static void * +_pool_alloc_from_new_chunk( + struct pool *pool, + size_t size) +{ + struct _pool_chunk *chunk; + void *obj; + size_t capacity; + + /* If the allocation is smaller than the default chunk size then + * try getting a chunk off the free list. Force alloc of a new + * chunk for large requests. */ + capacity = size; + chunk = NULL; + if (size < pool->default_capacity) { + capacity = pool->default_capacity; + chunk = pool->first_free; + if (chunk) { + pool->first_free = chunk->prev_chunk; + _pool_chunk_init(chunk, pool->current, chunk->capacity); + } + } + + if (NULL == chunk) + chunk = _pool_chunk_create (pool, capacity); + pool->current = chunk; + + obj = ((unsigned char*)chunk + sizeof(*chunk) + chunk->size); + chunk->size += size; + return obj; +} + +/* Allocate size bytes from the pool. The first allocated address + * returned from a pool is aligned to sizeof(void*). Subsequent + * addresses will maintain alignment as long as multiples of void* are + * allocated. Returns the address of a new memory area or %NULL on + * allocation failures. The pool retains ownership of the returned + * memory. */ +inline static void * +pool_alloc (struct pool *pool, size_t size) +{ + struct _pool_chunk *chunk = pool->current; + + if (size <= chunk->capacity - chunk->size) { + void *obj = ((unsigned char*)chunk + sizeof(*chunk) + chunk->size); + chunk->size += size; + return obj; + } else { + return _pool_alloc_from_new_chunk(pool, size); + } +} + +/* Relinquish all pool_alloced memory back to the pool. */ +static void +pool_reset (struct pool *pool) +{ + /* Transfer all used chunks to the chunk free list. */ + struct _pool_chunk *chunk = pool->current; + if (chunk != pool->sentinel) { + while (chunk->prev_chunk != pool->sentinel) { + chunk = chunk->prev_chunk; + } + chunk->prev_chunk = pool->first_free; + pool->first_free = pool->current; + } + /* Reset the sentinel as the current chunk. */ + pool->current = pool->sentinel; + pool->sentinel->size = 0; +} + +/* Rewinds the cell list's cursor to the beginning. After rewinding + * we're good to cell_list_find() the cell any x coordinate. */ +inline static void +cell_list_rewind (struct cell_list *cells) +{ + cells->cursor = &cells->head; +} + +/* Rewind the cell list if its cursor has been advanced past x. */ +inline static void +cell_list_maybe_rewind (struct cell_list *cells, int x) +{ + struct cell *tail = cells->cursor; + if (tail->x > x) + cell_list_rewind (cells); +} + +static void +cell_list_init(struct cell_list *cells, jmp_buf *jmp) +{ + pool_init(cells->cell_pool.base, jmp, + 256*sizeof(struct cell), + sizeof(cells->cell_pool.embedded)); + cells->tail.next = NULL; + cells->tail.x = INT_MAX; + cells->head.x = INT_MIN; + cells->head.next = &cells->tail; + cell_list_rewind (cells); +} + +static void +cell_list_fini(struct cell_list *cells) +{ + pool_fini (cells->cell_pool.base); +} + +/* Empty the cell list. This is called at the start of every pixel + * row. */ +inline static void +cell_list_reset (struct cell_list *cells) +{ + cell_list_rewind (cells); + cells->head.next = &cells->tail; + pool_reset (cells->cell_pool.base); +} + +static struct cell * +cell_list_alloc (struct cell_list *cells, + struct cell *tail, + int x) +{ + struct cell *cell; + + cell = pool_alloc (cells->cell_pool.base, sizeof (struct cell)); + cell->next = tail->next; + tail->next = cell; + cell->x = x; + cell->uncovered_area = 0; + cell->covered_height = 0; + cell->clipped_height = 0; + return cell; +} + +/* Find a cell at the given x-coordinate. Returns %NULL if a new cell + * needed to be allocated but couldn't be. Cells must be found with + * non-decreasing x-coordinate until the cell list is rewound using + * cell_list_rewind(). Ownership of the returned cell is retained by + * the cell list. */ +inline static struct cell * +cell_list_find (struct cell_list *cells, int x) +{ + struct cell *tail = cells->cursor; + + while (1) { + UNROLL3({ + if (tail->next->x > x) + break; + tail = tail->next; + }); + } + + if (tail->x != x) + tail = cell_list_alloc (cells, tail, x); + return cells->cursor = tail; + +} + +/* Find two cells at x1 and x2. This is exactly equivalent + * to + * + * pair.cell1 = cell_list_find(cells, x1); + * pair.cell2 = cell_list_find(cells, x2); + * + * except with less function call overhead. */ +inline static struct cell_pair +cell_list_find_pair(struct cell_list *cells, int x1, int x2) +{ + struct cell_pair pair; + + pair.cell1 = cells->cursor; + while (1) { + UNROLL3({ + if (pair.cell1->next->x > x1) + break; + pair.cell1 = pair.cell1->next; + }); + } + if (pair.cell1->x != x1) { + struct cell *cell = pool_alloc (cells->cell_pool.base, + sizeof (struct cell)); + cell->x = x1; + cell->uncovered_area = 0; + cell->covered_height = 0; + cell->clipped_height = 0; + cell->next = pair.cell1->next; + pair.cell1->next = cell; + pair.cell1 = cell; + } + + pair.cell2 = pair.cell1; + while (1) { + UNROLL3({ + if (pair.cell2->next->x > x2) + break; + pair.cell2 = pair.cell2->next; + }); + } + if (pair.cell2->x != x2) { + struct cell *cell = pool_alloc (cells->cell_pool.base, + sizeof (struct cell)); + cell->uncovered_area = 0; + cell->covered_height = 0; + cell->clipped_height = 0; + cell->x = x2; + cell->next = pair.cell2->next; + pair.cell2->next = cell; + pair.cell2 = cell; + } + + cells->cursor = pair.cell2; + return pair; +} + +/* Add a subpixel span covering [x1, x2) to the coverage cells. */ +inline static void +cell_list_add_subspan(struct cell_list *cells, + grid_scaled_x_t x1, + grid_scaled_x_t x2) +{ + int ix1, fx1; + int ix2, fx2; + + GRID_X_TO_INT_FRAC(x1, ix1, fx1); + GRID_X_TO_INT_FRAC(x2, ix2, fx2); + + if (ix1 != ix2) { + struct cell_pair p; + p = cell_list_find_pair(cells, ix1, ix2); + p.cell1->uncovered_area += 2*fx1; + ++p.cell1->covered_height; + p.cell2->uncovered_area -= 2*fx2; + --p.cell2->covered_height; + } else { + struct cell *cell = cell_list_find(cells, ix1); + cell->uncovered_area += 2*(fx1-fx2); + } +} + +/* Adds the analytical coverage of an edge crossing the current pixel + * row to the coverage cells and advances the edge's x position to the + * following row. + * + * This function is only called when we know that during this pixel row: + * + * 1) The relative order of all edges on the active list doesn't + * change. In particular, no edges intersect within this row to pixel + * precision. + * + * 2) No new edges start in this row. + * + * 3) No existing edges end mid-row. + * + * This function depends on being called with all edges from the + * active list in the order they appear on the list (i.e. with + * non-decreasing x-coordinate.) */ +static void +cell_list_render_edge( + struct cell_list *cells, + struct edge *edge, + int sign) +{ + grid_scaled_y_t y1, y2, dy; + grid_scaled_x_t dx; + int ix1, ix2; + grid_scaled_x_t fx1, fx2; + + struct quorem x1 = edge->x; + struct quorem x2 = x1; + + if (! edge->vertical) { + x2.quo += edge->dxdy_full.quo; + x2.rem += edge->dxdy_full.rem; + if (x2.rem >= 0) { + ++x2.quo; + x2.rem -= edge->dy; + } + + edge->x = x2; + } + + GRID_X_TO_INT_FRAC(x1.quo, ix1, fx1); + GRID_X_TO_INT_FRAC(x2.quo, ix2, fx2); + + /* Edge is entirely within a column? */ + if (ix1 == ix2) { + /* We always know that ix1 is >= the cell list cursor in this + * case due to the no-intersections precondition. */ + struct cell *cell = cell_list_find(cells, ix1); + cell->covered_height += sign*GRID_Y; + cell->uncovered_area += sign*(fx1 + fx2)*GRID_Y; + return; + } + + /* Orient the edge left-to-right. */ + dx = x2.quo - x1.quo; + if (dx >= 0) { + y1 = 0; + y2 = GRID_Y; + } else { + int tmp; + tmp = ix1; ix1 = ix2; ix2 = tmp; + tmp = fx1; fx1 = fx2; fx2 = tmp; + dx = -dx; + sign = -sign; + y1 = GRID_Y; + y2 = 0; + } + dy = y2 - y1; + + /* Add coverage for all pixels [ix1,ix2] on this row crossed + * by the edge. */ + { + struct cell_pair pair; + struct quorem y = floored_divrem((GRID_X - fx1)*dy, dx); + + /* When rendering a previous edge on the active list we may + * advance the cell list cursor past the leftmost pixel of the + * current edge even though the two edges don't intersect. + * e.g. consider two edges going down and rightwards: + * + * --\_+---\_+-----+-----+---- + * \_ \_ | | + * | \_ | \_ | | + * | \_| \_| | + * | \_ \_ | + * ----+-----+-\---+-\---+---- + * + * The left edge touches cells past the starting cell of the + * right edge. Fortunately such cases are rare. + * + * The rewinding is never necessary if the current edge stays + * within a single column because we've checked before calling + * this function that the active list order won't change. */ + cell_list_maybe_rewind(cells, ix1); + + pair = cell_list_find_pair(cells, ix1, ix1+1); + pair.cell1->uncovered_area += sign*y.quo*(GRID_X + fx1); + pair.cell1->covered_height += sign*y.quo; + y.quo += y1; + + if (ix1+1 < ix2) { + struct quorem dydx_full = floored_divrem(GRID_X*dy, dx); + struct cell *cell = pair.cell2; + + ++ix1; + do { + grid_scaled_y_t y_skip = dydx_full.quo; + y.rem += dydx_full.rem; + if (y.rem >= dx) { + ++y_skip; + y.rem -= dx; + } + + y.quo += y_skip; + + y_skip *= sign; + cell->uncovered_area += y_skip*GRID_X; + cell->covered_height += y_skip; + + ++ix1; + cell = cell_list_find(cells, ix1); + } while (ix1 != ix2); + + pair.cell2 = cell; + } + pair.cell2->uncovered_area += sign*(y2 - y.quo)*fx2; + pair.cell2->covered_height += sign*(y2 - y.quo); + } +} + +static void +polygon_init (struct polygon *polygon, jmp_buf *jmp) +{ + polygon->ymin = polygon->ymax = 0; + polygon->y_buckets = polygon->y_buckets_embedded; + pool_init (polygon->edge_pool.base, jmp, + 8192 - sizeof (struct _pool_chunk), + sizeof (polygon->edge_pool.embedded)); +} + +static void +polygon_fini (struct polygon *polygon) +{ + if (polygon->y_buckets != polygon->y_buckets_embedded) + free (polygon->y_buckets); + + pool_fini (polygon->edge_pool.base); +} + +/* Empties the polygon of all edges. The polygon is then prepared to + * receive new edges and clip them to the vertical range + * [ymin,ymax). */ +static cairo_status_t +polygon_reset (struct polygon *polygon, + grid_scaled_y_t ymin, + grid_scaled_y_t ymax) +{ + unsigned h = ymax - ymin; + unsigned num_buckets = EDGE_Y_BUCKET_INDEX(ymax + EDGE_Y_BUCKET_HEIGHT-1, + ymin); + + pool_reset(polygon->edge_pool.base); + + if (unlikely (h > 0x7FFFFFFFU - EDGE_Y_BUCKET_HEIGHT)) + goto bail_no_mem; /* even if you could, you wouldn't want to. */ + + if (polygon->y_buckets != polygon->y_buckets_embedded) + free (polygon->y_buckets); + + polygon->y_buckets = polygon->y_buckets_embedded; + if (num_buckets > ARRAY_LENGTH (polygon->y_buckets_embedded)) { + polygon->y_buckets = _cairo_malloc_ab (num_buckets, + sizeof (struct edge *)); + if (unlikely (NULL == polygon->y_buckets)) + goto bail_no_mem; + } + memset (polygon->y_buckets, 0, num_buckets * sizeof (struct edge *)); + + polygon->ymin = ymin; + polygon->ymax = ymax; + return CAIRO_STATUS_SUCCESS; + + bail_no_mem: + polygon->ymin = 0; + polygon->ymax = 0; + return CAIRO_STATUS_NO_MEMORY; +} + +static void +_polygon_insert_edge_into_its_y_bucket( + struct polygon *polygon, + struct edge *e) +{ + unsigned ix = EDGE_Y_BUCKET_INDEX(e->ytop, polygon->ymin); + struct edge **ptail = &polygon->y_buckets[ix]; + e->next = *ptail; + *ptail = e; +} + +inline static void +polygon_add_edge (struct polygon *polygon, + const cairo_edge_t *edge, + int clip) +{ + struct edge *e; + grid_scaled_x_t dx; + grid_scaled_y_t dy; + grid_scaled_y_t ytop, ybot; + grid_scaled_y_t ymin = polygon->ymin; + grid_scaled_y_t ymax = polygon->ymax; + + assert (edge->bottom > edge->top); + + if (unlikely (edge->top >= ymax || edge->bottom <= ymin)) + return; + + e = pool_alloc (polygon->edge_pool.base, sizeof (struct edge)); + + dx = edge->line.p2.x - edge->line.p1.x; + dy = edge->line.p2.y - edge->line.p1.y; + e->dy = dy; + e->dir = edge->dir; + e->clip = clip; + + ytop = edge->top >= ymin ? edge->top : ymin; + ybot = edge->bottom <= ymax ? edge->bottom : ymax; + e->ytop = ytop; + e->height_left = ybot - ytop; + + if (dx == 0) { + e->vertical = TRUE; + e->x.quo = edge->line.p1.x; + e->x.rem = 0; + e->dxdy.quo = 0; + e->dxdy.rem = 0; + e->dxdy_full.quo = 0; + e->dxdy_full.rem = 0; + } else { + e->vertical = FALSE; + e->dxdy = floored_divrem (dx, dy); + if (ytop == edge->line.p1.y) { + e->x.quo = edge->line.p1.x; + e->x.rem = 0; + } else { + e->x = floored_muldivrem (ytop - edge->line.p1.y, dx, dy); + e->x.quo += edge->line.p1.x; + } + + if (e->height_left >= GRID_Y) { + e->dxdy_full = floored_muldivrem (GRID_Y, dx, dy); + } else { + e->dxdy_full.quo = 0; + e->dxdy_full.rem = 0; + } + } + + _polygon_insert_edge_into_its_y_bucket (polygon, e); + + e->x.rem -= dy; /* Bias the remainder for faster + * edge advancement. */ +} + +static void +active_list_reset (struct active_list *active) +{ + active->head = NULL; + active->min_height = 0; +} + +static void +active_list_init(struct active_list *active) +{ + active_list_reset(active); +} + +/* + * Merge two sorted edge lists. + * Input: + * - head_a: The head of the first list. + * - head_b: The head of the second list; head_b cannot be NULL. + * Output: + * Returns the head of the merged list. + * + * Implementation notes: + * To make it fast (in particular, to reduce to an insertion sort whenever + * one of the two input lists only has a single element) we iterate through + * a list until its head becomes greater than the head of the other list, + * then we switch their roles. As soon as one of the two lists is empty, we + * just attach the other one to the current list and exit. + * Writes to memory are only needed to "switch" lists (as it also requires + * attaching to the output list the list which we will be iterating next) and + * to attach the last non-empty list. + */ +static struct edge * +merge_sorted_edges (struct edge *head_a, struct edge *head_b) +{ + struct edge *head, **next; + int32_t x; + + if (head_a == NULL) + return head_b; + + next = &head; + if (head_a->x.quo <= head_b->x.quo) { + head = head_a; + } else { + head = head_b; + goto start_with_b; + } + + do { + x = head_b->x.quo; + while (head_a != NULL && head_a->x.quo <= x) { + next = &head_a->next; + head_a = head_a->next; + } + + *next = head_b; + if (head_a == NULL) + return head; + +start_with_b: + x = head_a->x.quo; + while (head_b != NULL && head_b->x.quo <= x) { + next = &head_b->next; + head_b = head_b->next; + } + + *next = head_a; + if (head_b == NULL) + return head; + } while (1); +} + +/* + * Sort (part of) a list. + * Input: + * - list: The list to be sorted; list cannot be NULL. + * - limit: Recursion limit. + * Output: + * - head_out: The head of the sorted list containing the first 2^(level+1) elements of the + * input list; if the input list has fewer elements, head_out be a sorted list + * containing all the elements of the input list. + * Returns the head of the list of unprocessed elements (NULL if the sorted list contains + * all the elements of the input list). + * + * Implementation notes: + * Special case single element list, unroll/inline the sorting of the first two elements. + * Some tail recursion is used since we iterate on the bottom-up solution of the problem + * (we start with a small sorted list and keep merging other lists of the same size to it). + */ +static struct edge * +sort_edges (struct edge *list, + unsigned int level, + struct edge **head_out) +{ + struct edge *head_other, *remaining; + unsigned int i; + + head_other = list->next; + + /* Single element list -> return */ + if (head_other == NULL) { + *head_out = list; + return NULL; + } + + /* Unroll the first iteration of the following loop (halves the number of calls to merge_sorted_edges): + * - Initialize remaining to be the list containing the elements after the second in the input list. + * - Initialize *head_out to be the sorted list containing the first two element. + */ + remaining = head_other->next; + if (list->x.quo <= head_other->x.quo) { + *head_out = list; + /* list->next = head_other; */ /* The input list is already like this. */ + head_other->next = NULL; + } else { + *head_out = head_other; + head_other->next = list; + list->next = NULL; + } + + for (i = 0; i < level && remaining; i++) { + /* Extract a sorted list of the same size as *head_out + * (2^(i+1) elements) from the list of remaining elements. */ + remaining = sort_edges (remaining, i, &head_other); + *head_out = merge_sorted_edges (*head_out, head_other); + } + + /* *head_out now contains (at most) 2^(level+1) elements. */ + + return remaining; +} + +/* Test if the edges on the active list can be safely advanced by a + * full row without intersections or any edges ending. */ +inline static int +active_list_can_step_full_row (struct active_list *active) +{ + const struct edge *e; + int prev_x = INT_MIN; + + /* Recomputes the minimum height of all edges on the active + * list if we have been dropping edges. */ + if (active->min_height <= 0) { + int min_height = INT_MAX; + + e = active->head; + while (NULL != e) { + if (e->height_left < min_height) + min_height = e->height_left; + e = e->next; + } + + active->min_height = min_height; + } + + if (active->min_height < GRID_Y) + return 0; + + /* Check for intersections as no edges end during the next row. */ + e = active->head; + while (NULL != e) { + struct quorem x = e->x; + + if (! e->vertical) { + x.quo += e->dxdy_full.quo; + x.rem += e->dxdy_full.rem; + if (x.rem >= 0) + ++x.quo; + } + + if (x.quo <= prev_x) + return 0; + + prev_x = x.quo; + e = e->next; + } + + return 1; +} + +/* Merges edges on the given subpixel row from the polygon to the + * active_list. */ +inline static void +active_list_merge_edges_from_polygon(struct active_list *active, + struct edge **ptail, + grid_scaled_y_t y, + struct polygon *polygon) +{ + /* Split off the edges on the current subrow and merge them into + * the active list. */ + int min_height = active->min_height; + struct edge *subrow_edges = NULL; + struct edge *tail = *ptail; + + do { + struct edge *next = tail->next; + + if (y == tail->ytop) { + tail->next = subrow_edges; + subrow_edges = tail; + + if (tail->height_left < min_height) + min_height = tail->height_left; + + *ptail = next; + } else + ptail = &tail->next; + + tail = next; + } while (tail); + + if (subrow_edges) { + sort_edges (subrow_edges, UINT_MAX, &subrow_edges); + active->head = merge_sorted_edges (active->head, subrow_edges); + active->min_height = min_height; + } +} + +/* Advance the edges on the active list by one subsample row by + * updating their x positions. Drop edges from the list that end. */ +inline static void +active_list_substep_edges(struct active_list *active) +{ + struct edge **cursor = &active->head; + grid_scaled_x_t prev_x = INT_MIN; + struct edge *unsorted = NULL; + struct edge *edge = *cursor; + + do { + UNROLL3({ + struct edge *next; + + if (NULL == edge) + break; + + next = edge->next; + if (--edge->height_left) { + edge->x.quo += edge->dxdy.quo; + edge->x.rem += edge->dxdy.rem; + if (edge->x.rem >= 0) { + ++edge->x.quo; + edge->x.rem -= edge->dy; + } + + if (edge->x.quo < prev_x) { + *cursor = next; + edge->next = unsorted; + unsorted = edge; + } else { + prev_x = edge->x.quo; + cursor = &edge->next; + } + } else { + *cursor = next; + } + edge = next; + }) + } while (1); + + if (unsorted) { + sort_edges (unsorted, UINT_MAX, &unsorted); + active->head = merge_sorted_edges (active->head, unsorted); + } +} + +inline static void +apply_nonzero_fill_rule_for_subrow (struct active_list *active, + struct cell_list *coverages) +{ + struct edge *edge = active->head; + int winding = 0; + int xstart; + int xend; + + cell_list_rewind (coverages); + + while (NULL != edge) { + xstart = edge->x.quo; + winding = edge->dir; + while (1) { + edge = edge->next; + if (NULL == edge) { + ASSERT_NOT_REACHED; + return; + } + + winding += edge->dir; + if (0 == winding) { + if (edge->next == NULL || edge->next->x.quo != edge->x.quo) + break; + } + } + + xend = edge->x.quo; + cell_list_add_subspan (coverages, xstart, xend); + + edge = edge->next; + } +} + +static void +apply_evenodd_fill_rule_for_subrow (struct active_list *active, + struct cell_list *coverages) +{ + struct edge *edge = active->head; + int xstart; + int xend; + + cell_list_rewind (coverages); + + while (NULL != edge) { + xstart = edge->x.quo; + + while (1) { + edge = edge->next; + if (NULL == edge) { + ASSERT_NOT_REACHED; + return; + } + + if (edge->next == NULL || edge->next->x.quo != edge->x.quo) + break; + + edge = edge->next; + } + + xend = edge->x.quo; + cell_list_add_subspan (coverages, xstart, xend); + + edge = edge->next; + } +} + +static void +apply_nonzero_fill_rule_and_step_edges (struct active_list *active, + struct cell_list *coverages) +{ + struct edge **cursor = &active->head; + struct edge *left_edge; + + left_edge = *cursor; + while (NULL != left_edge) { + struct edge *right_edge; + int winding = left_edge->dir; + + left_edge->height_left -= GRID_Y; + if (left_edge->height_left) + cursor = &left_edge->next; + else + *cursor = left_edge->next; + + while (1) { + right_edge = *cursor; + if (NULL == right_edge) { + cell_list_render_edge (coverages, left_edge, +1); + return; + } + + right_edge->height_left -= GRID_Y; + if (right_edge->height_left) + cursor = &right_edge->next; + else + *cursor = right_edge->next; + + winding += right_edge->dir; + if (0 == winding) { + if (right_edge->next == NULL || + right_edge->next->x.quo != right_edge->x.quo) + { + break; + } + } + + if (! right_edge->vertical) { + right_edge->x.quo += right_edge->dxdy_full.quo; + right_edge->x.rem += right_edge->dxdy_full.rem; + if (right_edge->x.rem >= 0) { + ++right_edge->x.quo; + right_edge->x.rem -= right_edge->dy; + } + } + } + + cell_list_render_edge (coverages, left_edge, +1); + cell_list_render_edge (coverages, right_edge, -1); + + left_edge = *cursor; + } +} + +static void +apply_evenodd_fill_rule_and_step_edges (struct active_list *active, + struct cell_list *coverages) +{ + struct edge **cursor = &active->head; + struct edge *left_edge; + + left_edge = *cursor; + while (NULL != left_edge) { + struct edge *right_edge; + + left_edge->height_left -= GRID_Y; + if (left_edge->height_left) + cursor = &left_edge->next; + else + *cursor = left_edge->next; + + while (1) { + right_edge = *cursor; + if (NULL == right_edge) { + cell_list_render_edge (coverages, left_edge, +1); + return; + } + + right_edge->height_left -= GRID_Y; + if (right_edge->height_left) + cursor = &right_edge->next; + else + *cursor = right_edge->next; + + if (right_edge->next == NULL || + right_edge->next->x.quo != right_edge->x.quo) + { + break; + } + + if (! right_edge->vertical) { + right_edge->x.quo += right_edge->dxdy_full.quo; + right_edge->x.rem += right_edge->dxdy_full.rem; + if (right_edge->x.rem >= 0) { + ++right_edge->x.quo; + right_edge->x.rem -= right_edge->dy; + } + } + } + + cell_list_render_edge (coverages, left_edge, +1); + cell_list_render_edge (coverages, right_edge, -1); + + left_edge = *cursor; + } +} + +static void +_glitter_scan_converter_init(glitter_scan_converter_t *converter, jmp_buf *jmp) +{ + polygon_init(converter->polygon, jmp); + active_list_init(converter->active); + cell_list_init(converter->coverages, jmp); + converter->ymin=0; + converter->ymax=0; +} + +static void +_glitter_scan_converter_fini(glitter_scan_converter_t *converter) +{ + polygon_fini(converter->polygon); + cell_list_fini(converter->coverages); + converter->ymin=0; + converter->ymax=0; +} + +static grid_scaled_t +int_to_grid_scaled(int i, int scale) +{ + /* Clamp to max/min representable scaled number. */ + if (i >= 0) { + if (i >= INT_MAX/scale) + i = INT_MAX/scale; + } + else { + if (i <= INT_MIN/scale) + i = INT_MIN/scale; + } + return i*scale; +} + +#define int_to_grid_scaled_x(x) int_to_grid_scaled((x), GRID_X) +#define int_to_grid_scaled_y(x) int_to_grid_scaled((x), GRID_Y) + +static cairo_status_t +glitter_scan_converter_reset(glitter_scan_converter_t *converter, + int ymin, int ymax) +{ + cairo_status_t status; + + converter->ymin = 0; + converter->ymax = 0; + + ymin = int_to_grid_scaled_y(ymin); + ymax = int_to_grid_scaled_y(ymax); + + active_list_reset(converter->active); + cell_list_reset(converter->coverages); + status = polygon_reset(converter->polygon, ymin, ymax); + if (status) + return status; + + converter->ymin = ymin; + converter->ymax = ymax; + return CAIRO_STATUS_SUCCESS; +} + +/* INPUT_TO_GRID_X/Y (in_coord, out_grid_scaled, grid_scale) + * These macros convert an input coordinate in the client's + * device space to the rasterisation grid. + */ +/* Gah.. this bit of ugly defines INPUT_TO_GRID_X/Y so as to use + * shifts if possible, and something saneish if not. + */ +#if !defined(INPUT_TO_GRID_Y) && defined(GRID_Y_BITS) && GRID_Y_BITS <= GLITTER_INPUT_BITS +# define INPUT_TO_GRID_Y(in, out) (out) = (in) >> (GLITTER_INPUT_BITS - GRID_Y_BITS) +#else +# define INPUT_TO_GRID_Y(in, out) INPUT_TO_GRID_general(in, out, GRID_Y) +#endif + +#if !defined(INPUT_TO_GRID_X) && defined(GRID_X_BITS) && GRID_X_BITS <= GLITTER_INPUT_BITS +# define INPUT_TO_GRID_X(in, out) (out) = (in) >> (GLITTER_INPUT_BITS - GRID_X_BITS) +#else +# define INPUT_TO_GRID_X(in, out) INPUT_TO_GRID_general(in, out, GRID_X) +#endif + +#define INPUT_TO_GRID_general(in, out, grid_scale) do { \ + long long tmp__ = (long long)(grid_scale) * (in); \ + tmp__ >>= GLITTER_INPUT_BITS; \ + (out) = tmp__; \ +} while (0) + +static void +glitter_scan_converter_add_edge (glitter_scan_converter_t *converter, + const cairo_edge_t *edge, + int clip) +{ + cairo_edge_t e; + + INPUT_TO_GRID_Y (edge->top, e.top); + INPUT_TO_GRID_Y (edge->bottom, e.bottom); + if (e.top >= e.bottom) + return; + + /* XXX: possible overflows if GRID_X/Y > 2**GLITTER_INPUT_BITS */ + INPUT_TO_GRID_Y (edge->line.p1.y, e.line.p1.y); + INPUT_TO_GRID_Y (edge->line.p2.y, e.line.p2.y); + if (e.line.p1.y == e.line.p2.y) + return; + + INPUT_TO_GRID_X (edge->line.p1.x, e.line.p1.x); + INPUT_TO_GRID_X (edge->line.p2.x, e.line.p2.x); + + e.dir = edge->dir; + + polygon_add_edge (converter->polygon, &e, clip); +} + +static cairo_bool_t +active_list_is_vertical (struct active_list *active) +{ + struct edge *e; + + for (e = active->head; e != NULL; e = e->next) { + if (! e->vertical) + return FALSE; + } + + return TRUE; +} + +static void +step_edges (struct active_list *active, int count) +{ + struct edge **cursor = &active->head; + struct edge *edge; + + for (edge = *cursor; edge != NULL; edge = *cursor) { + edge->height_left -= GRID_Y * count; + if (edge->height_left) + cursor = &edge->next; + else + *cursor = edge->next; + } +} + +static cairo_status_t +blit_coverages (struct cell_list *cells, + cairo_span_renderer_t *renderer, + struct pool *span_pool, + int y, int height) +{ + struct cell *cell = cells->head.next; + int prev_x = -1; + int cover = 0, last_cover = 0; + int clip = 0; + cairo_half_open_span_t *spans; + unsigned num_spans; + + assert (cell != &cells->tail); + + /* Count number of cells remaining. */ + { + struct cell *next = cell; + num_spans = 2; + while (next->next) { + next = next->next; + ++num_spans; + } + num_spans = 2*num_spans; + } + + /* Allocate enough spans for the row. */ + pool_reset (span_pool); + spans = pool_alloc (span_pool, sizeof(spans[0])*num_spans); + num_spans = 0; + + /* Form the spans from the coverages and areas. */ + for (; cell->next; cell = cell->next) { + int x = cell->x; + int area; + + if (x > prev_x && cover != last_cover) { + spans[num_spans].x = prev_x; + spans[num_spans].coverage = GRID_AREA_TO_ALPHA (cover); + spans[num_spans].inverse = 0; + last_cover = cover; + ++num_spans; + } + + cover += cell->covered_height*GRID_X*2; + clip += cell->covered_height*GRID_X*2; + area = cover - cell->uncovered_area; + + if (area != last_cover) { + spans[num_spans].x = x; + spans[num_spans].coverage = GRID_AREA_TO_ALPHA (area); + spans[num_spans].inverse = 0; + last_cover = area; + ++num_spans; + } + + prev_x = x+1; + } + + /* Dump them into the renderer. */ + return renderer->render_rows (renderer, y, height, spans, num_spans); +} + +static void +glitter_scan_converter_render(glitter_scan_converter_t *converter, + int nonzero_fill, + cairo_span_renderer_t *span_renderer, + struct pool *span_pool) +{ + int i, j; + int ymax_i = converter->ymax / GRID_Y; + int ymin_i = converter->ymin / GRID_Y; + int h = ymax_i - ymin_i; + struct polygon *polygon = converter->polygon; + struct cell_list *coverages = converter->coverages; + struct active_list *active = converter->active; + + /* Render each pixel row. */ + for (i = 0; i < h; i = j) { + int do_full_step = 0; + + j = i + 1; + + /* Determine if we can ignore this row or use the full pixel + * stepper. */ + if (GRID_Y == EDGE_Y_BUCKET_HEIGHT && ! polygon->y_buckets[i]) { + if (! active->head) { + for (; j < h && ! polygon->y_buckets[j]; j++) + ; + continue; + } + + do_full_step = active_list_can_step_full_row (active); + } + + if (do_full_step) { + /* Step by a full pixel row's worth. */ + if (nonzero_fill) + apply_nonzero_fill_rule_and_step_edges (active, coverages); + else + apply_evenodd_fill_rule_and_step_edges (active, coverages); + + if (active_list_is_vertical (active)) { + while (j < h && + polygon->y_buckets[j] == NULL && + active->min_height >= 2*GRID_Y) + { + active->min_height -= GRID_Y; + j++; + } + if (j != i + 1) + step_edges (active, j - (i + 1)); + } + } else { + grid_scaled_y_t suby; + + /* Subsample this row. */ + for (suby = 0; suby < GRID_Y; suby++) { + grid_scaled_y_t y = (i+ymin_i)*GRID_Y + suby; + + if (polygon->y_buckets[i]) { + active_list_merge_edges_from_polygon (active, + &polygon->y_buckets[i], y, + polygon); + } + + if (nonzero_fill) + apply_nonzero_fill_rule_for_subrow (active, coverages); + else + apply_evenodd_fill_rule_for_subrow (active, coverages); + + active_list_substep_edges(active); + } + } + + blit_coverages (coverages, span_renderer, span_pool, i+ymin_i, j -i); + cell_list_reset (coverages); + + if (! active->head) + active->min_height = INT_MAX; + else + active->min_height -= GRID_Y; + } +} + +struct _cairo_clip_tor_scan_converter { + cairo_scan_converter_t base; + + glitter_scan_converter_t converter[1]; + cairo_fill_rule_t fill_rule; + cairo_antialias_t antialias; + + cairo_fill_rule_t clip_fill_rule; + cairo_antialias_t clip_antialias; + + jmp_buf jmp; + + struct { + struct pool base[1]; + cairo_half_open_span_t embedded[32]; + } span_pool; +}; + +typedef struct _cairo_clip_tor_scan_converter cairo_clip_tor_scan_converter_t; + +static void +_cairo_clip_tor_scan_converter_destroy (void *converter) +{ + cairo_clip_tor_scan_converter_t *self = converter; + if (self == NULL) { + return; + } + _glitter_scan_converter_fini (self->converter); + pool_fini (self->span_pool.base); + free(self); +} + +static cairo_status_t +_cairo_clip_tor_scan_converter_generate (void *converter, + cairo_span_renderer_t *renderer) +{ + cairo_clip_tor_scan_converter_t *self = converter; + cairo_status_t status; + + if ((status = setjmp (self->jmp))) + return _cairo_scan_converter_set_error (self, _cairo_error (status)); + + glitter_scan_converter_render (self->converter, + self->fill_rule == CAIRO_FILL_RULE_WINDING, + renderer, + self->span_pool.base); + return CAIRO_STATUS_SUCCESS; +} + +cairo_scan_converter_t * +_cairo_clip_tor_scan_converter_create (cairo_clip_t *clip, + cairo_polygon_t *polygon, + cairo_fill_rule_t fill_rule, + cairo_antialias_t antialias) +{ + cairo_clip_tor_scan_converter_t *self; + cairo_polygon_t clipper; + cairo_status_t status; + int i; + + self = calloc (1, sizeof(struct _cairo_clip_tor_scan_converter)); + if (unlikely (self == NULL)) { + status = _cairo_error (CAIRO_STATUS_NO_MEMORY); + goto bail_nomem; + } + + self->base.destroy = _cairo_clip_tor_scan_converter_destroy; + self->base.generate = _cairo_clip_tor_scan_converter_generate; + + pool_init (self->span_pool.base, &self->jmp, + 250 * sizeof(self->span_pool.embedded[0]), + sizeof(self->span_pool.embedded)); + + _glitter_scan_converter_init (self->converter, &self->jmp); + status = glitter_scan_converter_reset (self->converter, + clip->extents.y, + clip->extents.y + clip->extents.height); + if (unlikely (status)) + goto bail; + + self->fill_rule = fill_rule; + self->antialias = antialias; + + for (i = 0; i < polygon->num_edges; i++) + glitter_scan_converter_add_edge (self->converter, + &polygon->edges[i], + FALSE); + + status = _cairo_clip_get_polygon (clip, + &clipper, + &self->clip_fill_rule, + &self->clip_antialias); + if (unlikely (status)) + goto bail; + + for (i = 0; i < clipper.num_edges; i++) + glitter_scan_converter_add_edge (self->converter, + &clipper.edges[i], + TRUE); + _cairo_polygon_fini (&clipper); + + return &self->base; + + bail: + self->base.destroy(&self->base); + bail_nomem: + return _cairo_scan_converter_create_in_error (status); +} + diff --git a/src/cairo-clip.c b/src/cairo-clip.c index 6355a977..44f4e7b2 100644 --- a/src/cairo-clip.c +++ b/src/cairo-clip.c @@ -246,16 +246,9 @@ _cairo_clip_intersect_path (cairo_clip_t *clip, if (extents.width == 0 || extents.height == 0) return _cairo_clip_set_all_clipped (clip); - if (clip && ! _cairo_rectangle_intersect (&clip->extents, &extents)) - return _cairo_clip_set_all_clipped (clip); - - if (clip == NULL) { - clip = _cairo_clip_create (); - if (unlikely (clip == NULL)) - return _cairo_clip_set_all_clipped (clip); - - clip->extents = extents; - } + clip = _cairo_clip_intersect_rectangle (clip, &extents); + if (_cairo_clip_is_all_clipped (clip)) + return clip; clip_path = _cairo_clip_path_create (clip); if (unlikely (clip_path == NULL)) @@ -263,7 +256,7 @@ _cairo_clip_intersect_path (cairo_clip_t *clip, status = _cairo_path_fixed_init_copy (&clip_path->path, path); if (unlikely (status)) - return _cairo_clip_set_all_clipped (clip); + return _cairo_clip_set_all_clipped (clip); clip_path->fill_rule = fill_rule; clip_path->tolerance = tolerance; @@ -532,9 +525,10 @@ _cairo_debug_print_clip (FILE *stream, const cairo_clip_t *clip) } fprintf (stream, "clip:\n"); - fprintf (stream, " extents: (%d, %d) x (%d, %d)", + fprintf (stream, " extents: (%d, %d) x (%d, %d), is-region? %d", clip->extents.x, clip->extents.y, - clip->extents.width, clip->extents.height); + clip->extents.width, clip->extents.height, + clip->is_region); fprintf (stream, " num_boxes = %d\n", clip->num_boxes); for (i = 0; i < clip->num_boxes; i++) { diff --git a/src/cairo-composite-rectangles-private.h b/src/cairo-composite-rectangles-private.h index f0553ab0..8a06bf9f 100644 --- a/src/cairo-composite-rectangles-private.h +++ b/src/cairo-composite-rectangles-private.h @@ -39,6 +39,7 @@ #include "cairo-types-private.h" #include "cairo-error-private.h" +#include "cairo-pattern-private.h" CAIRO_BEGIN_DECLS @@ -52,6 +53,9 @@ CAIRO_BEGIN_DECLS * */ struct _cairo_composite_rectangles { + cairo_surface_t *surface; + cairo_operator_t op; + cairo_rectangle_int_t source; cairo_rectangle_int_t mask; cairo_rectangle_int_t destination; @@ -60,19 +64,27 @@ struct _cairo_composite_rectangles { cairo_rectangle_int_t unbounded; /* destination IN clip */ uint32_t is_bounded; + cairo_rectangle_int_t source_sample_area; + cairo_rectangle_int_t mask_sample_area; + + cairo_pattern_union_t source_pattern; + cairo_pattern_union_t mask_pattern; + const cairo_pattern_t *original_source_pattern; + const cairo_pattern_t *original_mask_pattern; + cairo_clip_t *clip; /* clip will be reduced to the minimal container */ }; cairo_private cairo_int_status_t _cairo_composite_rectangles_init_for_paint (cairo_composite_rectangles_t *extents, - const cairo_rectangle_int_t *unbounded, + cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_clip_t *clip); cairo_private cairo_int_status_t _cairo_composite_rectangles_init_for_mask (cairo_composite_rectangles_t *extents, - const cairo_rectangle_int_t *unbounded, + cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_pattern_t *mask, @@ -80,7 +92,7 @@ _cairo_composite_rectangles_init_for_mask (cairo_composite_rectangles_t *extents cairo_private cairo_int_status_t _cairo_composite_rectangles_init_for_stroke (cairo_composite_rectangles_t *extents, - const cairo_rectangle_int_t *unbounded, + cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_path_fixed_t *path, @@ -90,15 +102,31 @@ _cairo_composite_rectangles_init_for_stroke (cairo_composite_rectangles_t *exten cairo_private cairo_int_status_t _cairo_composite_rectangles_init_for_fill (cairo_composite_rectangles_t *extents, - const cairo_rectangle_int_t *unbounded, + cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_path_fixed_t *path, const cairo_clip_t *clip); cairo_private cairo_int_status_t +_cairo_composite_rectangles_init_for_boxes (cairo_composite_rectangles_t *extents, + cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_boxes_t *boxes, + const cairo_clip_t *clip); + +cairo_private cairo_int_status_t +_cairo_composite_rectangles_init_for_polygon (cairo_composite_rectangles_t *extents, + cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_polygon_t *polygon, + const cairo_clip_t *clip); + +cairo_private cairo_int_status_t _cairo_composite_rectangles_init_for_glyphs (cairo_composite_rectangles_t *extents, - const cairo_rectangle_int_t *unbounded, + cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, cairo_scaled_font_t *scaled_font, diff --git a/src/cairo-composite-rectangles.c b/src/cairo-composite-rectangles.c index a25e6d34..a50a3474 100644 --- a/src/cairo-composite-rectangles.c +++ b/src/cairo-composite-rectangles.c @@ -46,57 +46,93 @@ void _cairo_composite_rectangles_fini (cairo_composite_rectangles_t *extents) _cairo_clip_destroy (extents->clip); } +static void +_cairo_composite_reduce_pattern (const cairo_pattern_t *src, + cairo_pattern_union_t *dst) +{ + int tx, ty; + + _cairo_pattern_init_static_copy (&dst->base, src); + if (dst->base.type == CAIRO_PATTERN_TYPE_SOLID) + return; + + dst->base.filter = _cairo_pattern_analyze_filter (&dst->base, NULL), + + tx = ty = 0; + if (_cairo_matrix_is_pixman_translation (&dst->base.matrix, + dst->base.filter, + &tx, &ty)) + { + dst->base.matrix.x0 = tx; + dst->base.matrix.y0 = ty; + } +} + static inline cairo_bool_t _cairo_composite_rectangles_init (cairo_composite_rectangles_t *extents, - const cairo_rectangle_int_t *unbounded, + cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_clip_t *clip) { - extents->clip = NULL; - extents->destination = *unbounded; - if (_cairo_clip_is_all_clipped (clip)) return FALSE; + extents->surface = surface; + extents->op = op; + + _cairo_surface_get_extents (surface, &extents->destination); + extents->clip = NULL; + extents->unbounded = extents->destination; - if (clip != NULL) { - if (! _cairo_rectangle_intersect (&extents->unbounded, - _cairo_clip_get_extents (clip))) - return FALSE; - } + if (clip && ! _cairo_rectangle_intersect (&extents->unbounded, + _cairo_clip_get_extents (clip))) + return FALSE; extents->bounded = extents->unbounded; extents->is_bounded = _cairo_operator_bounded_by_either (op); - _cairo_pattern_get_extents (source, &extents->source); + extents->original_source_pattern = source; + _cairo_composite_reduce_pattern (source, &extents->source_pattern); + + _cairo_pattern_get_extents (&extents->source_pattern.base, + &extents->source); if (extents->is_bounded & CAIRO_OPERATOR_BOUND_BY_SOURCE) { if (! _cairo_rectangle_intersect (&extents->bounded, &extents->source)) return FALSE; } + extents->original_mask_pattern = NULL; + extents->mask_pattern.base.type = CAIRO_PATTERN_TYPE_SOLID; + extents->mask_pattern.solid.color.alpha = 1.; /* XXX full initialisation? */ + return TRUE; } cairo_int_status_t _cairo_composite_rectangles_init_for_paint (cairo_composite_rectangles_t *extents, - const cairo_rectangle_int_t *unbounded, + cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_clip_t *clip) { - if (! _cairo_composite_rectangles_init (extents, unbounded, - op, source, clip)) + if (! _cairo_composite_rectangles_init (extents, + surface, op, source, clip)) { return CAIRO_INT_STATUS_NOTHING_TO_DO; } - extents->mask = *unbounded; + extents->mask = extents->destination; extents->clip = _cairo_clip_reduce_for_composite (clip, extents); if (_cairo_clip_is_all_clipped (extents->clip)) return CAIRO_INT_STATUS_NOTHING_TO_DO; + if (extents->source_pattern.base.type != CAIRO_PATTERN_TYPE_SOLID) + _cairo_pattern_sampled_area (&extents->source_pattern.base, + &extents->bounded, + &extents->source_sample_area); + return CAIRO_STATUS_SUCCESS; } @@ -117,6 +153,21 @@ _cairo_composite_rectangles_intersect (cairo_composite_rectangles_t *extents, if (_cairo_clip_is_all_clipped (extents->clip)) return CAIRO_INT_STATUS_NOTHING_TO_DO; + if (extents->source_pattern.base.type != CAIRO_PATTERN_TYPE_SOLID) + _cairo_pattern_sampled_area (&extents->source_pattern.base, + &extents->bounded, + &extents->source_sample_area); + if (extents->mask_pattern.base.type != CAIRO_PATTERN_TYPE_SOLID) { + _cairo_pattern_sampled_area (&extents->mask_pattern.base, + &extents->bounded, + &extents->mask_sample_area); + if (extents->mask_sample_area.width == 0 || + extents->mask_sample_area.height == 0) { + _cairo_composite_rectangles_fini (extents); + return CAIRO_INT_STATUS_NOTHING_TO_DO; + } + } + return CAIRO_STATUS_SUCCESS; } @@ -125,7 +176,6 @@ _cairo_composite_rectangles_intersect_mask_extents (cairo_composite_rectangles_t const cairo_box_t *box) { cairo_rectangle_int_t mask; - cairo_int_status_t status; cairo_clip_t *clip; _cairo_box_round_to_rectangle (box, &mask); @@ -139,39 +189,70 @@ _cairo_composite_rectangles_intersect_mask_extents (cairo_composite_rectangles_t _cairo_rectangle_intersect (&extents->mask, &mask); + mask = extents->bounded; + if (! _cairo_rectangle_intersect (&extents->bounded, &extents->mask) && + extents->is_bounded & CAIRO_OPERATOR_BOUND_BY_MASK) + return CAIRO_INT_STATUS_NOTHING_TO_DO; + + if (mask.width == extents->bounded.width && + mask.height == extents->bounded.height) + return CAIRO_INT_STATUS_SUCCESS; + + if (extents->is_bounded == (CAIRO_OPERATOR_BOUND_BY_MASK | CAIRO_OPERATOR_BOUND_BY_SOURCE)) + extents->unbounded = extents->bounded; + extents->mask = mask; clip = extents->clip; - status = _cairo_composite_rectangles_intersect (extents, clip); + extents->clip = _cairo_clip_reduce_for_composite (clip, extents); if (clip != extents->clip) _cairo_clip_destroy (clip); - return status; + if (_cairo_clip_is_all_clipped (extents->clip)) + return CAIRO_INT_STATUS_NOTHING_TO_DO; + + if (extents->source_pattern.base.type != CAIRO_PATTERN_TYPE_SOLID) + _cairo_pattern_sampled_area (&extents->source_pattern.base, + &extents->bounded, + &extents->source_sample_area); + if (extents->mask_pattern.base.type != CAIRO_PATTERN_TYPE_SOLID) { + _cairo_pattern_sampled_area (&extents->mask_pattern.base, + &extents->bounded, + &extents->mask_sample_area); + if (extents->mask_sample_area.width == 0 || + extents->mask_sample_area.height == 0) + return CAIRO_INT_STATUS_NOTHING_TO_DO; + } + + return CAIRO_INT_STATUS_SUCCESS; } cairo_int_status_t _cairo_composite_rectangles_init_for_mask (cairo_composite_rectangles_t *extents, - const cairo_rectangle_int_t *unbounded, + cairo_surface_t*surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_pattern_t *mask, const cairo_clip_t *clip) { - if (! _cairo_composite_rectangles_init (extents, unbounded, - op, source, clip)) + if (! _cairo_composite_rectangles_init (extents, + surface, op, source, clip)) { return CAIRO_INT_STATUS_NOTHING_TO_DO; } - _cairo_pattern_get_extents (mask, &extents->mask); + + extents->original_mask_pattern = mask; + _cairo_composite_reduce_pattern (mask, &extents->mask_pattern); + _cairo_pattern_get_extents (&extents->mask_pattern.base, &extents->mask); return _cairo_composite_rectangles_intersect (extents, clip); } cairo_int_status_t _cairo_composite_rectangles_init_for_stroke (cairo_composite_rectangles_t *extents, - const cairo_rectangle_int_t *unbounded, + cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_path_fixed_t *path, @@ -179,8 +260,8 @@ _cairo_composite_rectangles_init_for_stroke (cairo_composite_rectangles_t *exten const cairo_matrix_t *ctm, const cairo_clip_t *clip) { - if (! _cairo_composite_rectangles_init (extents, unbounded, - op, source, clip)) + if (! _cairo_composite_rectangles_init (extents, + surface, op, source, clip)) { return CAIRO_INT_STATUS_NOTHING_TO_DO; } @@ -192,14 +273,14 @@ _cairo_composite_rectangles_init_for_stroke (cairo_composite_rectangles_t *exten cairo_int_status_t _cairo_composite_rectangles_init_for_fill (cairo_composite_rectangles_t *extents, - const cairo_rectangle_int_t *unbounded, + cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_path_fixed_t *path, const cairo_clip_t *clip) { - if (! _cairo_composite_rectangles_init (extents, unbounded, - op, source, clip)) + if (! _cairo_composite_rectangles_init (extents, + surface, op, source, clip)) { return CAIRO_INT_STATUS_NOTHING_TO_DO; } @@ -210,8 +291,47 @@ _cairo_composite_rectangles_init_for_fill (cairo_composite_rectangles_t *extents } cairo_int_status_t +_cairo_composite_rectangles_init_for_polygon (cairo_composite_rectangles_t *extents, + cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_polygon_t *polygon, + const cairo_clip_t *clip) +{ + if (! _cairo_composite_rectangles_init (extents, + surface, op, source, clip)) + { + return CAIRO_INT_STATUS_NOTHING_TO_DO; + } + + _cairo_box_round_to_rectangle (&polygon->extents, &extents->mask); + return _cairo_composite_rectangles_intersect (extents, clip); +} + +cairo_int_status_t +_cairo_composite_rectangles_init_for_boxes (cairo_composite_rectangles_t *extents, + cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_boxes_t *boxes, + const cairo_clip_t *clip) +{ + cairo_box_t box; + + if (! _cairo_composite_rectangles_init (extents, + surface, op, source, clip)) + { + return CAIRO_INT_STATUS_NOTHING_TO_DO; + } + + _cairo_boxes_extents (boxes, &box); + _cairo_box_round_to_rectangle (&box, &extents->mask); + return _cairo_composite_rectangles_intersect (extents, clip); +} + +cairo_int_status_t _cairo_composite_rectangles_init_for_glyphs (cairo_composite_rectangles_t *extents, - const cairo_rectangle_int_t *unbounded, + cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, cairo_scaled_font_t *scaled_font, @@ -222,8 +342,7 @@ _cairo_composite_rectangles_init_for_glyphs (cairo_composite_rectangles_t *exten { cairo_status_t status; - if (! _cairo_composite_rectangles_init (extents, unbounded, - op, source, clip)) + if (! _cairo_composite_rectangles_init (extents, surface, op, source, clip)) return CAIRO_INT_STATUS_NOTHING_TO_DO; /* Computing the exact bbox and the overlap is expensive. diff --git a/src/cairo-compositor-private.h b/src/cairo-compositor-private.h new file mode 100644 index 00000000..72507b21 --- /dev/null +++ b/src/cairo-compositor-private.h @@ -0,0 +1,355 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#ifndef CAIRO_COMPOSITOR_PRIVATE_H +#define CAIRO_COMPOSITOR_PRIVATE_H + +#include "cairo-composite-rectangles-private.h" + +CAIRO_BEGIN_DECLS + +typedef struct { + cairo_scaled_font_t *font; + cairo_glyph_t *glyphs; + int num_glyphs; + cairo_bool_t use_mask; + cairo_rectangle_int_t extents; +} cairo_composite_glyphs_info_t; + +struct cairo_compositor { + const cairo_compositor_t *delegate; + + cairo_warn cairo_int_status_t + (*paint) (const cairo_compositor_t *compositor, + cairo_composite_rectangles_t *extents); + + cairo_warn cairo_int_status_t + (*mask) (const cairo_compositor_t *compositor, + cairo_composite_rectangles_t *extents); + + cairo_warn cairo_int_status_t + (*stroke) (const cairo_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + 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); + + cairo_warn cairo_int_status_t + (*fill) (const cairo_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + cairo_antialias_t antialias); + + cairo_warn cairo_int_status_t + (*glyphs) (const cairo_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *scaled_font, + cairo_glyph_t *glyphs, + int num_glyphs, + cairo_bool_t overlap); +}; + +struct cairo_mask_compositor { + cairo_compositor_t base; + + cairo_int_status_t (*acquire) (void *surface); + cairo_int_status_t (*release) (void *surface); + + cairo_int_status_t (*set_clip_region) (void *surface, + cairo_region_t *clip_region); + + cairo_surface_t * (*pattern_to_surface) (cairo_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y); + + cairo_int_status_t (*draw_image_boxes) (void *surface, + cairo_image_surface_t *image, + cairo_boxes_t *boxes, + int dx, int dy); + + cairo_int_status_t (*copy_boxes) (void *surface, + cairo_surface_t *src, + cairo_boxes_t *boxes, + const cairo_rectangle_int_t *extents, + int dx, int dy); + + cairo_int_status_t + (*fill_rectangles) (void *surface, + cairo_operator_t op, + const cairo_color_t *color, + cairo_rectangle_int_t *rectangles, + int num_rects); + + cairo_int_status_t + (*fill_boxes) (void *surface, + cairo_operator_t op, + const cairo_color_t *color, + cairo_boxes_t *boxes); + + cairo_int_status_t + (*composite) (void *dst, + cairo_operator_t op, + cairo_surface_t *src, + cairo_surface_t *mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height); + + cairo_int_status_t + (*composite_boxes) (void *surface, + cairo_operator_t op, + cairo_surface_t *source, + cairo_surface_t *mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + cairo_boxes_t *boxes, + const cairo_rectangle_int_t *extents); + + cairo_int_status_t + (*check_composite_glyphs) (const cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *scaled_font, + cairo_glyph_t *glyphs, + int *num_glyphs); + cairo_int_status_t + (*composite_glyphs) (void *surface, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, + int src_y, + int dst_x, + int dst_y, + cairo_composite_glyphs_info_t *info); +}; + +struct cairo_traps_compositor { + cairo_compositor_t base; + + cairo_int_status_t + (*acquire) (void *surface); + + cairo_int_status_t + (*release) (void *surface); + + cairo_int_status_t + (*set_clip_region) (void *surface, + cairo_region_t *clip_region); + + cairo_surface_t * + (*pattern_to_surface) (cairo_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y); + + cairo_int_status_t (*draw_image_boxes) (void *surface, + cairo_image_surface_t *image, + cairo_boxes_t *boxes, + int dx, int dy); + + cairo_int_status_t (*copy_boxes) (void *surface, + cairo_surface_t *src, + cairo_boxes_t *boxes, + const cairo_rectangle_int_t *extents, + int dx, int dy); + + cairo_int_status_t + (*fill_boxes) (void *surface, + cairo_operator_t op, + const cairo_color_t *color, + cairo_boxes_t *boxes); + + cairo_int_status_t + (*composite) (void *dst, + cairo_operator_t op, + cairo_surface_t *src, + cairo_surface_t *mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height); + cairo_int_status_t + (*lerp) (void *_dst, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height); + + cairo_int_status_t + (*composite_boxes) (void *surface, + cairo_operator_t op, + cairo_surface_t *source, + cairo_surface_t *mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + cairo_boxes_t *boxes, + const cairo_rectangle_int_t *extents); + + cairo_int_status_t + (*composite_traps) (void *dst, + cairo_operator_t op, + cairo_surface_t *source, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_antialias_t antialias, + cairo_traps_t *traps); + + cairo_int_status_t + (*composite_tristrip) (void *dst, + cairo_operator_t op, + cairo_surface_t *source, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_antialias_t antialias, + cairo_tristrip_t *tristrip); + + cairo_int_status_t + (*check_composite_glyphs) (const cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *scaled_font, + cairo_glyph_t *glyphs, + int *num_glyphs); + cairo_int_status_t + (*composite_glyphs) (void *surface, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, + int src_y, + int dst_x, + int dst_y, + cairo_composite_glyphs_info_t *info); +}; + +cairo_private extern const cairo_compositor_t __cairo_no_compositor; +cairo_private extern const cairo_compositor_t _cairo_fallback_compositor; + +cairo_private void +_cairo_mask_compositor_init (cairo_mask_compositor_t *compositor, + const cairo_compositor_t *delegate); + +cairo_private void +_cairo_traps_compositor_init (cairo_traps_compositor_t *compositor, + const cairo_compositor_t *delegate); + +cairo_private cairo_int_status_t +_cairo_compositor_paint (const cairo_compositor_t *compositor, + cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_clip_t *clip); + +cairo_private cairo_int_status_t +_cairo_compositor_mask (const cairo_compositor_t *compositor, + cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_pattern_t *mask, + const cairo_clip_t *clip); + +cairo_private cairo_int_status_t +_cairo_compositor_stroke (const cairo_compositor_t *compositor, + cairo_surface_t *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_private cairo_int_status_t +_cairo_compositor_fill (const cairo_compositor_t *compositor, + cairo_surface_t *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_private cairo_int_status_t +_cairo_compositor_glyphs (const cairo_compositor_t *compositor, + cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + cairo_glyph_t *glyphs, + int num_glyphs, + cairo_scaled_font_t *scaled_font, + const cairo_clip_t *clip); + +CAIRO_END_DECLS + +#endif /* CAIRO_COMPOSITOR_PRIVATE_H */ diff --git a/src/cairo-compositor.c b/src/cairo-compositor.c new file mode 100644 index 00000000..cf943e73 --- /dev/null +++ b/src/cairo-compositor.c @@ -0,0 +1,213 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#include "cairoint.h" + +#include "cairo-compositor-private.h" +#include "cairo-error-private.h" + +cairo_int_status_t +_cairo_compositor_paint (const cairo_compositor_t *compositor, + cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_clip_t *clip) +{ + cairo_composite_rectangles_t extents; + cairo_int_status_t status; + + status = _cairo_composite_rectangles_init_for_paint (&extents, surface, + op, source, + clip); + if (unlikely (status)) + return status; + + do { + while (compositor->paint == NULL) + compositor = compositor->delegate; + + status = compositor->paint (compositor, &extents); + + compositor = compositor->delegate; + } while (status == CAIRO_INT_STATUS_UNSUPPORTED); + + _cairo_composite_rectangles_fini (&extents); + + return status; +} + +cairo_int_status_t +_cairo_compositor_mask (const cairo_compositor_t *compositor, + cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_pattern_t *mask, + const cairo_clip_t *clip) +{ + cairo_composite_rectangles_t extents; + cairo_int_status_t status; + + status = _cairo_composite_rectangles_init_for_mask (&extents, surface, + op, source, mask, + clip); + if (unlikely (status)) + return status; + + do { + while (compositor->mask == NULL) + compositor = compositor->delegate; + + status = compositor->mask (compositor, &extents); + + compositor = compositor->delegate; + } while (status == CAIRO_INT_STATUS_UNSUPPORTED); + + _cairo_composite_rectangles_fini (&extents); + + return status; +} + +cairo_int_status_t +_cairo_compositor_stroke (const cairo_compositor_t *compositor, + cairo_surface_t *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_composite_rectangles_t extents; + cairo_int_status_t status; + + status = _cairo_composite_rectangles_init_for_stroke (&extents, surface, + op, source, + path, style, ctm, + clip); + if (unlikely (status)) + return status; + + do { + while (compositor->stroke == NULL) + compositor = compositor->delegate; + + status = compositor->stroke (compositor, &extents, + path, style, ctm, ctm_inverse, + tolerance, antialias); + + compositor = compositor->delegate; + } while (status == CAIRO_INT_STATUS_UNSUPPORTED); + + _cairo_composite_rectangles_fini (&extents); + + return status; +} + +cairo_int_status_t +_cairo_compositor_fill (const cairo_compositor_t *compositor, + cairo_surface_t *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_composite_rectangles_t extents; + cairo_int_status_t status; + + status = _cairo_composite_rectangles_init_for_fill (&extents, surface, + op, source, path, + clip); + if (unlikely (status)) + return status; + + do { + while (compositor->fill == NULL) + compositor = compositor->delegate; + + status = compositor->fill (compositor, &extents, + path, fill_rule, tolerance, antialias); + + compositor = compositor->delegate; + } while (status == CAIRO_INT_STATUS_UNSUPPORTED); + + _cairo_composite_rectangles_fini (&extents); + + return status; +} + +cairo_int_status_t +_cairo_compositor_glyphs (const cairo_compositor_t *compositor, + cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + cairo_glyph_t *glyphs, + int num_glyphs, + cairo_scaled_font_t *scaled_font, + const cairo_clip_t *clip) +{ + cairo_composite_rectangles_t extents; + cairo_bool_t overlap; + cairo_int_status_t status; + + status = _cairo_composite_rectangles_init_for_glyphs (&extents, surface, + op, source, + scaled_font, + glyphs, num_glyphs, + clip, &overlap); + if (unlikely (status)) + return status; + + do { + while (compositor->glyphs == NULL) + compositor = compositor->delegate; + + status = compositor->glyphs (compositor, &extents, + scaled_font, glyphs, num_glyphs, overlap); + + compositor = compositor->delegate; + } while (status == CAIRO_INT_STATUS_UNSUPPORTED); + + _cairo_composite_rectangles_fini (&extents); + + return status; +} diff --git a/src/cairo-default-context.c b/src/cairo-default-context.c index 017eb7ba..98cc6684 100644 --- a/src/cairo-default-context.c +++ b/src/cairo-default-context.c @@ -158,8 +158,7 @@ _cairo_default_context_push_group (void *abstract_cr, cairo_content_t content) content, extents.width, extents.height, - CAIRO_COLOR_TRANSPARENT, - TRUE); + CAIRO_COLOR_TRANSPARENT); status = group_surface->status; if (unlikely (status)) goto bail; diff --git a/src/cairo-fallback-compositor.c b/src/cairo-fallback-compositor.c new file mode 100644 index 00000000..105859d6 --- /dev/null +++ b/src/cairo-fallback-compositor.c @@ -0,0 +1,174 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Joonas Pihlaja <jpihlaja@cc.helsinki.fi> + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#include "cairoint.h" + +#include "cairo-compositor-private.h" +#include "cairo-surface-offset-private.h" + +/* high-level compositor interface */ + +static cairo_int_status_t +_cairo_fallback_compositor_paint (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents) +{ + cairo_surface_t *image; + cairo_int_status_t status; + + image = cairo_surface_map_to_image (extents->surface, &extents->unbounded); + status = _cairo_surface_offset_paint (image, + -extents->unbounded.x, + -extents->unbounded.y, + extents->op, + &extents->source_pattern.base, + extents->clip); + cairo_surface_unmap_image (extents->surface, image); + + return status; +} + +static cairo_int_status_t +_cairo_fallback_compositor_mask (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents) +{ + cairo_surface_t *image; + cairo_int_status_t status; + + image = cairo_surface_map_to_image (extents->surface, &extents->unbounded); + status = _cairo_surface_offset_mask (image, + extents->unbounded.x, + extents->unbounded.y, + extents->op, + &extents->source_pattern.base, + &extents->mask_pattern.base, + extents->clip); + cairo_surface_unmap_image (extents->surface, image); + + return status; +} + +static cairo_int_status_t +_cairo_fallback_compositor_stroke (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + 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) +{ + cairo_surface_t *image; + cairo_int_status_t status; + + image = cairo_surface_map_to_image (extents->surface, &extents->unbounded); + status = _cairo_surface_offset_stroke (image, + extents->unbounded.x, + extents->unbounded.y, + extents->op, + &extents->source_pattern.base, + path, style, + ctm, ctm_inverse, + tolerance, + antialias, + extents->clip); + cairo_surface_unmap_image (extents->surface, image); + + return status; +} + +static cairo_int_status_t +_cairo_fallback_compositor_fill (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + cairo_antialias_t antialias) +{ + cairo_surface_t *image; + cairo_int_status_t status; + + image = cairo_surface_map_to_image (extents->surface, &extents->unbounded); + status = _cairo_surface_offset_fill (image, + extents->unbounded.x, + extents->unbounded.y, + extents->op, + &extents->source_pattern.base, + path, + fill_rule, tolerance, antialias, + extents->clip); + cairo_surface_unmap_image (extents->surface, image); + + return status; +} + +static cairo_int_status_t +_cairo_fallback_compositor_glyphs (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *scaled_font, + cairo_glyph_t *glyphs, + int num_glyphs, + cairo_bool_t overlap) +{ + cairo_surface_t *image; + cairo_int_status_t status; + + image = cairo_surface_map_to_image (extents->surface, &extents->unbounded); + status = _cairo_surface_offset_glyphs (image, + extents->unbounded.x, + extents->unbounded.y, + extents->op, + &extents->source_pattern.base, + scaled_font, glyphs, num_glyphs, + extents->clip); + cairo_surface_unmap_image (extents->surface, image); + + return status; +} + +const cairo_compositor_t _cairo_fallback_compositor = { + &__cairo_no_compositor, + + _cairo_fallback_compositor_paint, + _cairo_fallback_compositor_mask, + _cairo_fallback_compositor_stroke, + _cairo_fallback_compositor_fill, + _cairo_fallback_compositor_glyphs, +}; diff --git a/src/cairo-freed-pool-private.h b/src/cairo-freed-pool-private.h index 259c57db..0ec6de3d 100644 --- a/src/cairo-freed-pool-private.h +++ b/src/cairo-freed-pool-private.h @@ -42,7 +42,9 @@ CAIRO_BEGIN_DECLS -#if HAS_ATOMIC_OPS +#define DISABLE_FREED_POOLS 0 + +#if HAS_ATOMIC_OPS && ! DISABLE_FREED_POOLS /* Keep a stash of recently freed clip_paths, since we need to * reallocate them frequently. */ @@ -128,7 +130,7 @@ typedef int freed_pool_t; #define _freed_pool_get(pool) NULL #define _freed_pool_put(pool, ptr) free(ptr) -#define _freed_pool_reset(ptr) assert((ptr) != NULL) +#define _freed_pool_reset(ptr) #endif diff --git a/src/cairo-ft-font.c b/src/cairo-ft-font.c index 9024463e..e0df535c 100644 --- a/src/cairo-ft-font.c +++ b/src/cairo-ft-font.c @@ -2586,7 +2586,6 @@ static const cairo_scaled_font_backend_t _cairo_ft_scaled_font_backend = { _cairo_ft_scaled_glyph_init, NULL, /* text_to_glyphs */ _cairo_ft_ucs4_to_index, - NULL, /* show_glyphs */ _cairo_ft_load_truetype_table, _cairo_ft_index_to_ucs4, _cairo_ft_is_synthetic, diff --git a/src/cairo-gl-composite.c b/src/cairo-gl-composite.c index 01fe7259..c59501ec 100644 --- a/src/cairo-gl-composite.c +++ b/src/cairo-gl-composite.c @@ -49,326 +49,6 @@ #include "cairo-error-private.h" #include "cairo-image-surface-private.h" -static cairo_int_status_t -_cairo_gl_create_gradient_texture (cairo_gl_surface_t *dst, - const cairo_gradient_pattern_t *pattern, - cairo_gl_gradient_t **gradient) -{ - cairo_gl_context_t *ctx; - cairo_status_t status; - - status = _cairo_gl_context_acquire (dst->base.device, &ctx); - if (unlikely (status)) - return status; - - status = _cairo_gl_gradient_create (ctx, pattern->n_stops, pattern->stops, gradient); - - return _cairo_gl_context_release (ctx, status); -} - -/* - * Like cairo_pattern_acquire_surface(), but returns a matrix that transforms - * from dest to src coords. - */ -static cairo_status_t -_cairo_gl_pattern_texture_setup (cairo_gl_operand_t *operand, - const cairo_pattern_t *src, - cairo_gl_surface_t *dst, - int src_x, int src_y, - int dst_x, int dst_y, - int width, int height) -{ - cairo_status_t status; - cairo_matrix_t m; - cairo_gl_surface_t *surface; - cairo_surface_attributes_t *attributes; - attributes = &operand->texture.attributes; - - status = _cairo_pattern_acquire_surface (src, &dst->base, - src_x, src_y, - width, height, - CAIRO_PATTERN_ACQUIRE_NONE, - (cairo_surface_t **) - &surface, - attributes); - if (unlikely (status)) - return status; - - if (_cairo_gl_device_requires_power_of_two_textures (dst->base.device) && - (attributes->extend == CAIRO_EXTEND_REPEAT || - attributes->extend == CAIRO_EXTEND_REFLECT)) - { - _cairo_pattern_release_surface (src, - &surface->base, - attributes); - return UNSUPPORTED ("EXT_texture_rectangle with repeat/reflect"); - } - - assert (surface->base.backend == &_cairo_gl_surface_backend); - assert (_cairo_gl_surface_is_texture (surface)); - - operand->type = CAIRO_GL_OPERAND_TEXTURE; - operand->texture.surface = surface; - operand->texture.tex = surface->tex; - /* Translate the matrix from - * (unnormalized src -> unnormalized src) to - * (unnormalized dst -> unnormalized src) - */ - cairo_matrix_init_translate (&m, - src_x - dst_x + attributes->x_offset, - src_y - dst_y + attributes->y_offset); - cairo_matrix_multiply (&attributes->matrix, - &m, - &attributes->matrix); - - - /* Translate the matrix from - * (unnormalized dst -> unnormalized src) to - * (unnormalized dst -> normalized src) - */ - if (_cairo_gl_device_requires_power_of_two_textures (dst->base.device)) { - cairo_matrix_init_scale (&m, - 1.0, - 1.0); - } else { - cairo_matrix_init_scale (&m, - 1.0 / surface->width, - 1.0 / surface->height); - } - cairo_matrix_multiply (&attributes->matrix, - &attributes->matrix, - &m); - - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_cairo_gl_solid_operand_init (cairo_gl_operand_t *operand, - const cairo_color_t *color) -{ - operand->type = CAIRO_GL_OPERAND_CONSTANT; - operand->constant.color[0] = color->red * color->alpha; - operand->constant.color[1] = color->green * color->alpha; - operand->constant.color[2] = color->blue * color->alpha; - operand->constant.color[3] = color->alpha; - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_cairo_gl_gradient_operand_init (cairo_gl_operand_t *operand, - const cairo_pattern_t *pattern, - cairo_gl_surface_t *dst, - int src_x, int src_y, - int dst_x, int dst_y) -{ - const cairo_gradient_pattern_t *gradient = (const cairo_gradient_pattern_t *)pattern; - cairo_status_t status; - - assert (gradient->base.type == CAIRO_PATTERN_TYPE_LINEAR || - gradient->base.type == CAIRO_PATTERN_TYPE_RADIAL); - - if (! _cairo_gl_device_has_glsl (dst->base.device)) - return CAIRO_INT_STATUS_UNSUPPORTED; - - status = _cairo_gl_create_gradient_texture (dst, - gradient, - &operand->gradient.gradient); - if (unlikely (status)) - return status; - - if (gradient->base.type == CAIRO_PATTERN_TYPE_LINEAR) { - cairo_linear_pattern_t *linear = (cairo_linear_pattern_t *) gradient; - double x0, y0, dx, dy, sf, offset; - - dx = linear->pd2.x - linear->pd1.x; - dy = linear->pd2.y - linear->pd1.y; - sf = 1.0 / (dx * dx + dy * dy); - dx *= sf; - dy *= sf; - - x0 = linear->pd1.x; - y0 = linear->pd1.y; - offset = dx * x0 + dy * y0; - - operand->type = CAIRO_GL_OPERAND_LINEAR_GRADIENT; - - cairo_matrix_init (&operand->gradient.m, dx, 0, dy, 1, -offset, 0); - if (! _cairo_matrix_is_identity (&pattern->matrix)) { - cairo_matrix_multiply (&operand->gradient.m, - &pattern->matrix, - &operand->gradient.m); - } - } else { - cairo_matrix_t m; - cairo_circle_double_t circles[2]; - double x0, y0, r0, dx, dy, dr; - - /* - * Some fragment shader implementations use half-floats to - * represent numbers, so the maximum number they can represent - * is about 2^14. Some intermediate computations used in the - * radial gradient shaders can produce results of up to 2*k^4. - * Setting k=8 makes the maximum result about 8192 (assuming - * that the extreme circles are not much smaller than the - * destination image). - */ - _cairo_gradient_pattern_fit_to_range (gradient, 8., - &operand->gradient.m, circles); - - x0 = circles[0].center.x; - y0 = circles[0].center.y; - r0 = circles[0].radius; - dx = circles[1].center.x - x0; - dy = circles[1].center.y - y0; - dr = circles[1].radius - r0; - - operand->gradient.a = dx * dx + dy * dy - dr * dr; - operand->gradient.radius_0 = r0; - operand->gradient.circle_d.center.x = dx; - operand->gradient.circle_d.center.y = dy; - operand->gradient.circle_d.radius = dr; - - if (operand->gradient.a == 0) - operand->type = CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0; - else if (pattern->extend == CAIRO_EXTEND_NONE) - operand->type = CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE; - else - operand->type = CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT; - - cairo_matrix_init_translate (&m, -x0, -y0); - cairo_matrix_multiply (&operand->gradient.m, - &operand->gradient.m, - &m); - } - - cairo_matrix_translate (&operand->gradient.m, src_x - dst_x, src_y - dst_y); - - operand->gradient.extend = pattern->extend; - - return CAIRO_STATUS_SUCCESS; -} - -static void -_cairo_gl_operand_destroy (cairo_gl_operand_t *operand) -{ - switch (operand->type) { - case CAIRO_GL_OPERAND_CONSTANT: - break; - case CAIRO_GL_OPERAND_LINEAR_GRADIENT: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: - _cairo_gl_gradient_destroy (operand->gradient.gradient); - break; - case CAIRO_GL_OPERAND_TEXTURE: - _cairo_pattern_release_surface (NULL, /* XXX */ - &operand->texture.surface->base, - &operand->texture.attributes); - break; - default: - case CAIRO_GL_OPERAND_COUNT: - ASSERT_NOT_REACHED; - case CAIRO_GL_OPERAND_NONE: - case CAIRO_GL_OPERAND_SPANS: - break; - } - - operand->type = CAIRO_GL_OPERAND_NONE; -} - -static cairo_int_status_t -_cairo_gl_operand_init (cairo_gl_operand_t *operand, - const cairo_pattern_t *pattern, - cairo_gl_surface_t *dst, - int src_x, int src_y, - int dst_x, int dst_y, - int width, int height) -{ - cairo_int_status_t status; - - switch (pattern->type) { - case CAIRO_PATTERN_TYPE_SOLID: - return _cairo_gl_solid_operand_init (operand, - &((cairo_solid_pattern_t *) pattern)->color); - case CAIRO_PATTERN_TYPE_LINEAR: - case CAIRO_PATTERN_TYPE_RADIAL: - status = _cairo_gl_gradient_operand_init (operand, - pattern, dst, - src_x, src_y, - dst_x, dst_y); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - - /* fall through */ - - default: - case CAIRO_PATTERN_TYPE_MESH: - case CAIRO_PATTERN_TYPE_SURFACE: - return _cairo_gl_pattern_texture_setup (operand, - pattern, dst, - src_x, src_y, - dst_x, dst_y, - width, height); - } -} - -cairo_filter_t -_cairo_gl_operand_get_filter (cairo_gl_operand_t *operand) -{ - cairo_filter_t filter; - - switch ((int) operand->type) { - case CAIRO_GL_OPERAND_TEXTURE: - filter = operand->texture.attributes.filter; - break; - case CAIRO_GL_OPERAND_LINEAR_GRADIENT: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: - filter = CAIRO_FILTER_BILINEAR; - break; - default: - filter = CAIRO_FILTER_DEFAULT; - break; - } - - return filter; -} - -GLint -_cairo_gl_operand_get_gl_filter (cairo_gl_operand_t *operand) -{ - cairo_filter_t filter = _cairo_gl_operand_get_filter (operand); - - return filter != CAIRO_FILTER_FAST && filter != CAIRO_FILTER_NEAREST ? - GL_LINEAR : - GL_NEAREST; -} - -cairo_extend_t -_cairo_gl_operand_get_extend (cairo_gl_operand_t *operand) -{ - cairo_extend_t extend; - - switch ((int) operand->type) { - case CAIRO_GL_OPERAND_TEXTURE: - extend = operand->texture.attributes.extend; - break; - case CAIRO_GL_OPERAND_LINEAR_GRADIENT: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: - extend = operand->gradient.extend; - break; - default: - extend = CAIRO_EXTEND_NONE; - break; - } - - return extend; -} - - cairo_int_status_t _cairo_gl_composite_set_source (cairo_gl_composite_t *setup, const cairo_pattern_t *pattern, @@ -384,6 +64,22 @@ _cairo_gl_composite_set_source (cairo_gl_composite_t *setup, width, height); } +void +_cairo_gl_composite_set_source_operand (cairo_gl_composite_t *setup, + const cairo_gl_operand_t *source) +{ + _cairo_gl_operand_destroy (&setup->src); + setup->src = *source; +} + +void +_cairo_gl_composite_set_solid_source (cairo_gl_composite_t *setup, + const cairo_color_t *color) +{ + _cairo_gl_operand_destroy (&setup->src); + _cairo_gl_solid_operand_init (&setup->src, color); +} + cairo_int_status_t _cairo_gl_composite_set_mask (cairo_gl_composite_t *setup, const cairo_pattern_t *pattern, @@ -403,91 +99,25 @@ _cairo_gl_composite_set_mask (cairo_gl_composite_t *setup, } void -_cairo_gl_composite_set_mask_spans (cairo_gl_composite_t *setup) +_cairo_gl_composite_set_mask_operand (cairo_gl_composite_t *setup, + const cairo_gl_operand_t *mask) { _cairo_gl_operand_destroy (&setup->mask); - setup->mask.type = CAIRO_GL_OPERAND_SPANS; + if (mask) + setup->mask = *mask; } void -_cairo_gl_composite_set_clip_region (cairo_gl_composite_t *setup, - cairo_region_t *clip_region) +_cairo_gl_composite_set_spans (cairo_gl_composite_t *setup) { - setup->clip_region = clip_region; + setup->spans = TRUE; } -static void -_cairo_gl_operand_bind_to_shader (cairo_gl_context_t *ctx, - cairo_gl_operand_t *operand, - cairo_gl_tex_t tex_unit) +void +_cairo_gl_composite_set_clip_region (cairo_gl_composite_t *setup, + cairo_region_t *clip_region) { - char uniform_name[50]; - char *custom_part; - static const char *names[] = { "source", "mask" }; - - strcpy (uniform_name, names[tex_unit]); - custom_part = uniform_name + strlen (names[tex_unit]); - - switch (operand->type) { - default: - case CAIRO_GL_OPERAND_COUNT: - ASSERT_NOT_REACHED; - case CAIRO_GL_OPERAND_NONE: - case CAIRO_GL_OPERAND_SPANS: - break; - case CAIRO_GL_OPERAND_CONSTANT: - strcpy (custom_part, "_constant"); - _cairo_gl_shader_bind_vec4 (ctx, - uniform_name, - operand->constant.color[0], - operand->constant.color[1], - operand->constant.color[2], - operand->constant.color[3]); - break; - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: - strcpy (custom_part, "_a"); - _cairo_gl_shader_bind_float (ctx, - uniform_name, - operand->gradient.a); - /* fall through */ - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: - strcpy (custom_part, "_circle_d"); - _cairo_gl_shader_bind_vec3 (ctx, - uniform_name, - operand->gradient.circle_d.center.x, - operand->gradient.circle_d.center.y, - operand->gradient.circle_d.radius); - strcpy (custom_part, "_radius_0"); - _cairo_gl_shader_bind_float (ctx, - uniform_name, - operand->gradient.radius_0); - /* fall through */ - case CAIRO_GL_OPERAND_LINEAR_GRADIENT: - case CAIRO_GL_OPERAND_TEXTURE: - /* - * For GLES2 we use shaders to implement GL_CLAMP_TO_BORDER (used - * with CAIRO_EXTEND_NONE). When bilinear filtering is enabled, - * these shaders need the texture dimensions for their calculations. - */ - if (ctx->gl_flavor == CAIRO_GL_FLAVOR_ES && - _cairo_gl_operand_get_extend (operand) == CAIRO_EXTEND_NONE && - _cairo_gl_operand_get_gl_filter (operand) == GL_LINEAR) - { - float width, height; - if (operand->type == CAIRO_GL_OPERAND_TEXTURE) { - width = operand->texture.surface->width; - height = operand->texture.surface->height; - } - else { - width = operand->gradient.gradient->cache_entry.size, - height = 1; - } - strcpy (custom_part, "_texdims"); - _cairo_gl_shader_bind_vec2 (ctx, uniform_name, width, height); - } - break; - } + setup->clip_region = clip_region; } static void @@ -501,6 +131,29 @@ _cairo_gl_composite_bind_to_shader (cairo_gl_context_t *ctx, } static void +_cairo_gl_texture_set_filter (cairo_gl_context_t *ctx, + GLuint target, + cairo_filter_t filter) +{ + switch (filter) { + case CAIRO_FILTER_FAST: + case CAIRO_FILTER_NEAREST: + glTexParameteri (target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri (target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + break; + case CAIRO_FILTER_GOOD: + case CAIRO_FILTER_BEST: + case CAIRO_FILTER_BILINEAR: + glTexParameteri (target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri (target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + break; + default: + case CAIRO_FILTER_GAUSSIAN: + ASSERT_NOT_REACHED; + } +} + +static void _cairo_gl_texture_set_extend (cairo_gl_context_t *ctx, GLuint target, cairo_extend_t extend) @@ -534,66 +187,6 @@ _cairo_gl_texture_set_extend (cairo_gl_context_t *ctx, } } -static void -_cairo_gl_texture_set_filter (cairo_gl_context_t *ctx, - GLuint target, - cairo_filter_t filter) -{ - switch (filter) { - case CAIRO_FILTER_FAST: - case CAIRO_FILTER_NEAREST: - glTexParameteri (target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - glTexParameteri (target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - break; - case CAIRO_FILTER_GOOD: - case CAIRO_FILTER_BEST: - case CAIRO_FILTER_BILINEAR: - glTexParameteri (target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameteri (target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - break; - default: - case CAIRO_FILTER_GAUSSIAN: - ASSERT_NOT_REACHED; - } -} - -static cairo_bool_t -_cairo_gl_operand_needs_setup (cairo_gl_operand_t *dest, - cairo_gl_operand_t *source, - unsigned int vertex_offset) -{ - if (dest->type != source->type) - return TRUE; - if (dest->vertex_offset != vertex_offset) - return TRUE; - - switch (source->type) { - case CAIRO_GL_OPERAND_NONE: - case CAIRO_GL_OPERAND_SPANS: - return FALSE; - case CAIRO_GL_OPERAND_CONSTANT: - return dest->constant.color[0] != source->constant.color[0] || - dest->constant.color[1] != source->constant.color[1] || - dest->constant.color[2] != source->constant.color[2] || - dest->constant.color[3] != source->constant.color[3]; - case CAIRO_GL_OPERAND_TEXTURE: - return dest->texture.surface != source->texture.surface || - dest->texture.attributes.extend != source->texture.attributes.extend || - dest->texture.attributes.filter != source->texture.attributes.filter || - dest->texture.attributes.has_component_alpha != source->texture.attributes.has_component_alpha; - case CAIRO_GL_OPERAND_LINEAR_GRADIENT: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: - /* XXX: improve this */ - return TRUE; - default: - case CAIRO_GL_OPERAND_COUNT: - ASSERT_NOT_REACHED; - break; - } - return TRUE; -} static void _cairo_gl_context_setup_operand (cairo_gl_context_t *ctx, @@ -629,11 +222,6 @@ _cairo_gl_context_setup_operand (cairo_gl_context_t *ctx, ASSERT_NOT_REACHED; case CAIRO_GL_OPERAND_NONE: break; - case CAIRO_GL_OPERAND_SPANS: - dispatch->VertexAttribPointer (CAIRO_GL_COLOR_ATTRIB_INDEX, 4, - GL_UNSIGNED_BYTE, GL_TRUE, vertex_size, - (void *) (uintptr_t) vertex_offset); - dispatch->EnableVertexAttribArray (CAIRO_GL_COLOR_ATTRIB_INDEX); /* fall through */ case CAIRO_GL_OPERAND_CONSTANT: break; @@ -668,6 +256,19 @@ _cairo_gl_context_setup_operand (cairo_gl_context_t *ctx, } } +static void +_cairo_gl_context_setup_spans (cairo_gl_context_t *ctx, + unsigned int vertex_size, + unsigned int vertex_offset) +{ + cairo_gl_dispatch_t *dispatch = &ctx->dispatch; + + dispatch->VertexAttribPointer (CAIRO_GL_COLOR_ATTRIB_INDEX, 4, + GL_UNSIGNED_BYTE, GL_TRUE, vertex_size, + (void *) (uintptr_t) vertex_offset); + dispatch->EnableVertexAttribArray (CAIRO_GL_COLOR_ATTRIB_INDEX); +} + void _cairo_gl_context_destroy_operand (cairo_gl_context_t *ctx, cairo_gl_tex_t tex_unit) @@ -681,8 +282,6 @@ _cairo_gl_context_destroy_operand (cairo_gl_context_t *ctx, ASSERT_NOT_REACHED; case CAIRO_GL_OPERAND_NONE: break; - case CAIRO_GL_OPERAND_SPANS: - dispatch->DisableVertexAttribArray (CAIRO_GL_COLOR_ATTRIB_INDEX); /* fall through */ case CAIRO_GL_OPERAND_CONSTANT: break; @@ -764,27 +363,6 @@ _cairo_gl_set_operator (cairo_gl_context_t *ctx, } } -static unsigned int -_cairo_gl_operand_get_vertex_size (cairo_gl_operand_type_t type) -{ - switch (type) { - default: - case CAIRO_GL_OPERAND_COUNT: - ASSERT_NOT_REACHED; - case CAIRO_GL_OPERAND_NONE: - case CAIRO_GL_OPERAND_CONSTANT: - return 0; - case CAIRO_GL_OPERAND_SPANS: - return 4 * sizeof (GLbyte); - case CAIRO_GL_OPERAND_TEXTURE: - case CAIRO_GL_OPERAND_LINEAR_GRADIENT: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: - return 2 * sizeof (GLfloat); - } -} - static cairo_status_t _cairo_gl_composite_begin_component_alpha (cairo_gl_context_t *ctx, cairo_gl_composite_t *setup) @@ -872,6 +450,7 @@ _cairo_gl_composite_begin_component_alpha (cairo_gl_context_t *ctx, status = _cairo_gl_get_shader_by_type (ctx, &setup->src, &setup->mask, + setup->spans, CAIRO_GL_SHADER_IN_CA_SOURCE_ALPHA, &pre_shader); if (unlikely (status)) @@ -919,10 +498,12 @@ _cairo_gl_composite_begin (cairo_gl_composite_t *setup, } status = _cairo_gl_get_shader_by_type (ctx, - &setup->src, - &setup->mask, - component_alpha ? CAIRO_GL_SHADER_IN_CA_SOURCE - : CAIRO_GL_SHADER_IN_NORMAL, + &setup->src, + &setup->mask, + setup->spans, + component_alpha ? + CAIRO_GL_SHADER_IN_CA_SOURCE : + CAIRO_GL_SHADER_IN_NORMAL, &shader); if (unlikely (status)) { ctx->pre_shader = NULL; @@ -954,10 +535,12 @@ _cairo_gl_composite_begin (cairo_gl_composite_t *setup, _cairo_gl_context_setup_operand (ctx, CAIRO_GL_TEX_SOURCE, &setup->src, vertex_size, dst_size); _cairo_gl_context_setup_operand (ctx, CAIRO_GL_TEX_MASK, &setup->mask, vertex_size, dst_size + src_size); + if (setup->spans) + _cairo_gl_context_setup_spans (ctx, vertex_size, dst_size + src_size); + else + ctx->dispatch.DisableVertexAttribArray (CAIRO_GL_COLOR_ATTRIB_INDEX); - _cairo_gl_set_operator (ctx, - setup->op, - component_alpha); + _cairo_gl_set_operator (ctx, setup->op, component_alpha); ctx->vertex_size = vertex_size; @@ -1065,62 +648,6 @@ _cairo_gl_composite_prepare_buffer (cairo_gl_context_t *ctx, } static inline void -_cairo_gl_operand_emit (cairo_gl_operand_t *operand, - GLfloat ** vb, - GLfloat x, - GLfloat y, - uint8_t alpha) -{ - switch (operand->type) { - default: - case CAIRO_GL_OPERAND_COUNT: - ASSERT_NOT_REACHED; - case CAIRO_GL_OPERAND_NONE: - case CAIRO_GL_OPERAND_CONSTANT: - break; - case CAIRO_GL_OPERAND_SPANS: - { - union fi { - float f; - GLbyte bytes[4]; - } fi; - - fi.bytes[0] = 0; - fi.bytes[1] = 0; - fi.bytes[2] = 0; - fi.bytes[3] = alpha; - *(*vb)++ = fi.f; - } - break; - case CAIRO_GL_OPERAND_LINEAR_GRADIENT: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: - case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: - { - double s = x; - double t = y; - - cairo_matrix_transform_point (&operand->gradient.m, &s, &t); - - *(*vb)++ = s; - *(*vb)++ = t; - } - break; - case CAIRO_GL_OPERAND_TEXTURE: - { - cairo_surface_attributes_t *src_attributes = &operand->texture.attributes; - double s = x; - double t = y; - - cairo_matrix_transform_point (&src_attributes->matrix, &s, &t); - *(*vb)++ = s; - *(*vb)++ = t; - } - break; - } -} - -static inline void _cairo_gl_composite_emit_vertex (cairo_gl_context_t *ctx, GLfloat x, GLfloat y, @@ -1134,6 +661,19 @@ _cairo_gl_composite_emit_vertex (cairo_gl_context_t *ctx, _cairo_gl_operand_emit (&ctx->operands[CAIRO_GL_TEX_SOURCE], &vb, x, y, alpha); _cairo_gl_operand_emit (&ctx->operands[CAIRO_GL_TEX_MASK ], &vb, x, y, alpha); + if (ctx->spans) { + union fi { + float f; + GLbyte bytes[4]; + } fi; + + fi.bytes[0] = 0; + fi.bytes[1] = 0; + fi.bytes[2] = 0; + fi.bytes[3] = alpha; + *vb++ = fi.f; + } + ctx->vb_offset += ctx->vertex_size; } @@ -1229,517 +769,3 @@ _cairo_gl_composite_init (cairo_gl_composite_t *setup, return CAIRO_STATUS_SUCCESS; } - -static cairo_bool_t -cairo_boxes_for_each_box (cairo_boxes_t *boxes, - cairo_bool_t (*func) (cairo_box_t *box, - void *data), - void *data) -{ - struct _cairo_boxes_chunk *chunk; - int i; - - for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { - for (i = 0; i < chunk->count; i++) - if (! func (&chunk->base[i], data)) - return FALSE; - } - - return TRUE; -} - -struct image_contains_box { - int width, height; - int tx, ty; -}; - -static cairo_bool_t image_contains_box (cairo_box_t *box, void *closure) -{ - struct image_contains_box *data = closure; - - return - _cairo_fixed_integer_part (box->p1.x) + data->tx >= 0 && - _cairo_fixed_integer_part (box->p1.y) + data->ty >= 0 && - _cairo_fixed_integer_part (box->p2.x) + data->tx <= data->width && - _cairo_fixed_integer_part (box->p2.y) + data->ty <= data->height; -} - -struct image_upload_box { - cairo_gl_surface_t *surface; - cairo_image_surface_t *image; - int tx, ty; -}; - -static cairo_bool_t image_upload_box (cairo_box_t *box, void *closure) -{ - const struct image_upload_box *iub = closure; - int x = _cairo_fixed_integer_part (box->p1.x); - int y = _cairo_fixed_integer_part (box->p1.y); - int w = _cairo_fixed_integer_part (box->p2.x - box->p1.x); - int h = _cairo_fixed_integer_part (box->p2.y - box->p1.y); - - return _cairo_gl_surface_draw_image (iub->surface, - iub->image, - x + iub->tx, y + iub->ty, - w, h, - x, y) == CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_upload_image_inplace (cairo_gl_surface_t *surface, - const cairo_pattern_t *source, - cairo_boxes_t *boxes) -{ - const cairo_surface_pattern_t *pattern; - struct image_contains_box icb; - struct image_upload_box iub; - cairo_image_surface_t *image; - int tx, ty; - - if (! boxes->is_pixel_aligned) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (source->type != CAIRO_PATTERN_TYPE_SURFACE) - return CAIRO_INT_STATUS_UNSUPPORTED; - - pattern = (const cairo_surface_pattern_t *) source; - if (pattern->surface->type != CAIRO_SURFACE_TYPE_IMAGE) - return CAIRO_INT_STATUS_UNSUPPORTED; - - image = (cairo_image_surface_t *) pattern->surface; - if (image->format == CAIRO_FORMAT_INVALID) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (! _cairo_matrix_is_integer_translation (&source->matrix, &tx, &ty)) - return CAIRO_INT_STATUS_UNSUPPORTED; - - /* Check that the data is entirely within the image */ - icb.width = image->width; - icb.height = image->height; - icb.tx = tx; - icb.ty = ty; - if (! cairo_boxes_for_each_box (boxes, image_contains_box, &icb)) - return CAIRO_INT_STATUS_UNSUPPORTED; - - iub.surface = surface; - iub.image = image; - iub.tx = tx; - iub.ty = ty; - cairo_boxes_for_each_box (boxes, image_upload_box, &iub); - - return CAIRO_STATUS_SUCCESS; -} - -static cairo_bool_t composite_box (cairo_box_t *box, void *closure) -{ - _cairo_gl_composite_emit_rect (closure, - _cairo_fixed_integer_part (box->p1.x), - _cairo_fixed_integer_part (box->p1.y), - _cairo_fixed_integer_part (box->p2.x), - _cairo_fixed_integer_part (box->p2.y), - 0); - return TRUE; -} - -static cairo_status_t -_composite_boxes (cairo_gl_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_boxes_t *boxes, - const cairo_composite_rectangles_t *extents) -{ - cairo_bool_t need_clip_mask = FALSE; - cairo_gl_composite_t setup; - cairo_gl_context_t *ctx; - cairo_surface_pattern_t mask; - cairo_status_t status; - - /* If the boxes are not pixel-aligned, we will need to compute a real mask */ - if (! boxes->is_pixel_aligned) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (extents->clip->path && - (! extents->is_bounded || op == CAIRO_OPERATOR_SOURCE)) - { - return CAIRO_INT_STATUS_UNSUPPORTED; - } - - if (! extents->is_bounded) - return CAIRO_INT_STATUS_UNSUPPORTED; - - status = _cairo_gl_composite_init (&setup, op, dst, FALSE, - &extents->bounded); - if (unlikely (status)) - goto CLEANUP; - - status = _cairo_gl_composite_set_source (&setup, src, - extents->bounded.x, - extents->bounded.y, - extents->bounded.x, - extents->bounded.y, - extents->bounded.width, - extents->bounded.height); - if (unlikely (status)) - goto CLEANUP; - - need_clip_mask = extents->clip->path != NULL; - if (need_clip_mask) { - cairo_surface_t *clip_surface; - int clip_x, clip_y; - - clip_surface = _cairo_clip_get_surface (extents->clip, - &dst->base, - &clip_x, &clip_y); - if (unlikely (clip_surface->status)) { - status = clip_surface->status; - need_clip_mask = FALSE; - goto CLEANUP; - } - - _cairo_pattern_init_for_surface (&mask, clip_surface); - mask.base.filter = CAIRO_FILTER_NEAREST; - cairo_matrix_init_translate (&mask.base.matrix, - -clip_x, - -clip_y); - cairo_surface_destroy (clip_surface); - - if (op == CAIRO_OPERATOR_CLEAR) { - src = NULL; - op = CAIRO_OPERATOR_DEST_OUT; - } - - status = _cairo_gl_composite_set_mask (&setup, &mask.base, - extents->bounded.x, - extents->bounded.y, - extents->bounded.x, - extents->bounded.y, - extents->bounded.width, - extents->bounded.height); - if (unlikely (status)) - goto CLEANUP; - } - - status = _cairo_gl_composite_begin (&setup, &ctx); - if (unlikely (status)) - goto CLEANUP; - - cairo_boxes_for_each_box (boxes, composite_box, ctx); - - status = _cairo_gl_context_release (ctx, status); - - CLEANUP: - if (need_clip_mask) - _cairo_pattern_fini (&mask.base); - - _cairo_gl_composite_fini (&setup); - return status; -} - -static cairo_bool_t converter_add_box (cairo_box_t *box, void *closure) -{ - return _cairo_rectangular_scan_converter_add_box (closure, box, 1) == CAIRO_STATUS_SUCCESS; -} - -typedef struct _cairo_gl_surface_span_renderer { - cairo_span_renderer_t base; - - cairo_gl_composite_t setup; - - int xmin, xmax; - int ymin, ymax; - - cairo_gl_context_t *ctx; -} cairo_gl_surface_span_renderer_t; - -static cairo_status_t -_cairo_gl_render_bounded_spans (void *abstract_renderer, - int y, int height, - const cairo_half_open_span_t *spans, - unsigned num_spans) -{ - cairo_gl_surface_span_renderer_t *renderer = abstract_renderer; - - if (num_spans == 0) - return CAIRO_STATUS_SUCCESS; - - do { - if (spans[0].coverage) { - _cairo_gl_composite_emit_rect (renderer->ctx, - spans[0].x, y, - spans[1].x, y + height, - spans[0].coverage); - } - - spans++; - } while (--num_spans > 1); - - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_cairo_gl_render_unbounded_spans (void *abstract_renderer, - int y, int height, - const cairo_half_open_span_t *spans, - unsigned num_spans) -{ - cairo_gl_surface_span_renderer_t *renderer = abstract_renderer; - - if (y > renderer->ymin) { - _cairo_gl_composite_emit_rect (renderer->ctx, - renderer->xmin, renderer->ymin, - renderer->xmax, y, - 0); - } - - if (num_spans == 0) { - _cairo_gl_composite_emit_rect (renderer->ctx, - renderer->xmin, y, - renderer->xmax, y + height, - 0); - } else { - if (spans[0].x != renderer->xmin) { - _cairo_gl_composite_emit_rect (renderer->ctx, - renderer->xmin, y, - spans[0].x, y + height, - 0); - } - - do { - _cairo_gl_composite_emit_rect (renderer->ctx, - spans[0].x, y, - spans[1].x, y + height, - spans[0].coverage); - spans++; - } while (--num_spans > 1); - - if (spans[0].x != renderer->xmax) { - _cairo_gl_composite_emit_rect (renderer->ctx, - spans[0].x, y, - renderer->xmax, y + height, - 0); - } - } - - renderer->ymin = y + height; - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_cairo_gl_finish_unbounded_spans (void *abstract_renderer) -{ - cairo_gl_surface_span_renderer_t *renderer = abstract_renderer; - - if (renderer->ymax > renderer->ymin) { - _cairo_gl_composite_emit_rect (renderer->ctx, - renderer->xmin, renderer->ymin, - renderer->xmax, renderer->ymax, - 0); - } - - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_cairo_gl_finish_bounded_spans (void *abstract_renderer) -{ - return CAIRO_STATUS_SUCCESS; -} - -static cairo_int_status_t -_composite_unaligned_boxes (cairo_gl_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_boxes_t *boxes, - const cairo_composite_rectangles_t *composite) -{ - cairo_rectangular_scan_converter_t converter; - cairo_gl_surface_span_renderer_t renderer; - const cairo_rectangle_int_t *extents; - cairo_status_t status; - - if (composite->clip->path) - return CAIRO_INT_STATUS_UNSUPPORTED; - - /* XXX for ADD or if we know the boxes are disjoint we can do a simpler - * pass, but for now... */ - - _cairo_rectangular_scan_converter_init (&converter, &composite->bounded); - cairo_boxes_for_each_box (boxes, converter_add_box, &converter); - - if (composite->is_bounded) { - renderer.base.render_rows = _cairo_gl_render_bounded_spans; - renderer.base.finish = _cairo_gl_finish_bounded_spans; - extents = &composite->bounded; - } else { - renderer.base.render_rows = _cairo_gl_render_unbounded_spans; - renderer.base.finish = _cairo_gl_finish_unbounded_spans; - extents = &composite->unbounded; - } - renderer.xmin = extents->x; - renderer.xmax = extents->x + extents->width; - renderer.ymin = extents->y; - renderer.ymax = extents->y + extents->height; - - status = _cairo_gl_composite_init (&renderer.setup, - op, dst, - FALSE, extents); - if (unlikely (status)) - goto FAIL; - - status = _cairo_gl_composite_set_source (&renderer.setup, pattern, - extents->x, extents->y, - extents->x, extents->y, - extents->width, extents->height); - if (unlikely (status)) - goto FAIL; - - _cairo_gl_composite_set_mask_spans (&renderer.setup); - if (! composite->is_bounded) - _cairo_gl_composite_set_clip_region (&renderer.setup, - _cairo_clip_get_region (composite->clip)); - - status = _cairo_gl_composite_begin (&renderer.setup, &renderer.ctx); - if (unlikely (status)) - goto FAIL; - - status = converter.base.generate (&converter.base, &renderer.base); - - converter.base.destroy (&converter.base); - renderer.base.finish (&renderer.base); - - status = _cairo_gl_context_release (renderer.ctx, status); -FAIL: - _cairo_gl_composite_fini (&renderer.setup); - return status; -} - -/* XXX _cairo_gl_clip_and_composite_polygon() */ -cairo_int_status_t -_cairo_gl_surface_polygon (cairo_gl_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_polygon_t *polygon, - cairo_fill_rule_t fill_rule, - cairo_antialias_t antialias, - const cairo_composite_rectangles_t *extents) -{ - cairo_region_t *clip_region = _cairo_clip_get_region (extents->clip); - - if (! _cairo_clip_is_region (extents->clip)) - return UNSUPPORTED ("a clip surface would be required"); - - if (! _cairo_surface_check_span_renderer (op, src, &dst->base, antialias)) - return UNSUPPORTED ("no span renderer"); - - if (op == CAIRO_OPERATOR_SOURCE) - return UNSUPPORTED ("SOURCE compositing doesn't work in GL"); - if (op == CAIRO_OPERATOR_CLEAR) { - op = CAIRO_OPERATOR_DEST_OUT; - src = &_cairo_pattern_white.base; - } - - return _cairo_surface_composite_polygon (&dst->base, - op, - src, - fill_rule, - antialias, - extents, - polygon, - clip_region); -} - -cairo_int_status_t -_cairo_gl_clip_and_composite_boxes (cairo_gl_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_boxes_t *boxes, - cairo_composite_rectangles_t *extents) -{ - cairo_int_status_t status; - - if (boxes->num_boxes == 0 && extents->is_bounded) - return CAIRO_STATUS_SUCCESS; - - if (! _cairo_gl_operator_is_supported (op)) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (boxes->is_pixel_aligned && _cairo_clip_is_region (extents->clip) && - (op == CAIRO_OPERATOR_SOURCE || - (dst->base.is_clear && (op == CAIRO_OPERATOR_OVER || op == CAIRO_OPERATOR_ADD)))) - { - if (boxes->num_boxes == 1 && - extents->bounded.width == dst->width && - extents->bounded.height == dst->height) - { - op = CAIRO_OPERATOR_SOURCE; -#if 0 - dst->deferred_clear = FALSE; -#endif - } - - status = _upload_image_inplace (dst, src, boxes); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - } - - /* Can we reduce drawing through a clip-mask to simply drawing the clip? */ - if (extents->clip->path != NULL && extents->is_bounded) { - cairo_polygon_t polygon; - cairo_fill_rule_t fill_rule; - cairo_antialias_t antialias; - cairo_clip_t *clip; - - clip = _cairo_clip_copy (extents->clip); - clip = _cairo_clip_intersect_boxes (clip, boxes); - status = _cairo_clip_get_polygon (clip, &polygon, - &fill_rule, &antialias); - _cairo_clip_path_destroy (clip->path); - clip->path = NULL; - if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { - cairo_clip_t *saved_clip = extents->clip; - extents->clip = clip; - status = _cairo_gl_surface_polygon (dst, op, src, - &polygon, - fill_rule, - antialias, - extents); - if (extents->clip != clip) - clip = NULL; - extents->clip = saved_clip; - _cairo_polygon_fini (&polygon); - } - if (clip) - _cairo_clip_destroy (clip); - - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - } - -#if 0 - if (dst->deferred_clear) { - status = _cairo_gl_surface_clear (dst); - if (unlikely (status)) - return status; - } -#endif - - if (boxes->is_pixel_aligned && - _cairo_clip_is_region (extents->clip) && - op == CAIRO_OPERATOR_SOURCE) { - status = _upload_image_inplace (dst, src, boxes); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - } - - /* Use a fast path if the boxes are pixel aligned */ - status = _composite_boxes (dst, op, src, boxes, extents); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - - status = _composite_unaligned_boxes (dst, op, src, boxes, extents); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - - /* Otherwise XXX */ - return CAIRO_INT_STATUS_UNSUPPORTED; -} diff --git a/src/cairo-gl-device.c b/src/cairo-gl-device.c index 170cf962..f20850e7 100644 --- a/src/cairo-gl-device.c +++ b/src/cairo-gl-device.c @@ -113,18 +113,20 @@ static void _gl_destroy (void *device) { cairo_gl_context_t *ctx = device; - cairo_scaled_font_t *scaled_font, *next_scaled_font; int n; ctx->acquire (ctx); - cairo_list_foreach_entry_safe (scaled_font, - next_scaled_font, - cairo_scaled_font_t, - &ctx->fonts, - link) - { - _cairo_scaled_font_revoke_ownership (scaled_font); + while (! cairo_list_is_empty (&ctx->fonts)) { + cairo_gl_font_t *font; + + font = cairo_list_first_entry (&ctx->fonts, + cairo_gl_font_t, + link); + + cairo_list_del (&font->base.link); + cairo_list_del (&font->link); + free (font); } for (n = 0; n < ARRAY_LENGTH (ctx->glyph_cache); n++) @@ -161,6 +163,8 @@ _cairo_gl_context_init (cairo_gl_context_t *ctx) _cairo_device_init (&ctx->base, &_cairo_gl_device_backend); + ctx->compositor = _cairo_gl_span_compositor_get (); + memset (ctx->glyph_cache, 0, sizeof (ctx->glyph_cache)); cairo_list_init (&ctx->fonts); diff --git a/src/cairo-gl-glyphs.c b/src/cairo-gl-glyphs.c index 0772d2a0..ee5c543c 100644 --- a/src/cairo-gl-glyphs.c +++ b/src/cairo-gl-glyphs.c @@ -40,6 +40,7 @@ #include "cairo-gl-private.h" +#include "cairo-compositor-private.h" #include "cairo-composite-rectangles-private.h" #include "cairo-error-private.h" #include "cairo-image-surface-private.h" @@ -50,11 +51,26 @@ #define GLYPH_CACHE_MIN_SIZE 4 #define GLYPH_CACHE_MAX_SIZE 128 -typedef struct _cairo_gl_glyph_private { +typedef struct _cairo_gl_glyph { cairo_rtree_node_t node; + cairo_scaled_glyph_private_t base; cairo_gl_glyph_cache_t *cache; struct { float x, y; } p1, p2; -} cairo_gl_glyph_private_t; +} cairo_gl_glyph_t; + +static void +_cairo_gl_glyph_fini (cairo_scaled_glyph_private_t *_priv, + cairo_scaled_glyph_t *scaled_glyph, + cairo_scaled_font_t *scaled_font) +{ + cairo_gl_glyph_t *priv = cairo_container_of (_priv, cairo_gl_glyph_t, base); + + priv->node.owner = NULL; + if (! priv->node.pinned) { + /* XXX thread-safety? Probably ok due to the frozen scaled-font. */ + _cairo_rtree_node_remove (&priv->cache->rtree, &priv->node); + } +} static cairo_int_status_t _cairo_gl_glyph_cache_add_glyph (cairo_gl_context_t *ctx, @@ -63,7 +79,7 @@ _cairo_gl_glyph_cache_add_glyph (cairo_gl_context_t *ctx, { cairo_image_surface_t *glyph_surface = scaled_glyph->surface; cairo_gl_surface_t *cache_surface; - cairo_gl_glyph_private_t *glyph_private; + cairo_gl_glyph_t *glyph_private; cairo_rtree_node_t *node = NULL; cairo_int_status_t status; int width, height; @@ -101,11 +117,15 @@ _cairo_gl_glyph_cache_add_glyph (cairo_gl_context_t *ctx, if (unlikely (status)) return status; - scaled_glyph->surface_private = node; - node->owner = &scaled_glyph->surface_private; - - glyph_private = (cairo_gl_glyph_private_t *) node; + glyph_private = (cairo_gl_glyph_t *) node; glyph_private->cache = cache; + _cairo_scaled_glyph_attach_private (scaled_glyph, + &glyph_private->base, + cache, + _cairo_gl_glyph_fini); + + scaled_glyph->dev_private = glyph_private; + scaled_glyph->dev_private_key = cache; /* compute tex coords */ glyph_private->p1.x = node->x; @@ -122,11 +142,11 @@ _cairo_gl_glyph_cache_add_glyph (cairo_gl_context_t *ctx, return CAIRO_STATUS_SUCCESS; } -static cairo_gl_glyph_private_t * +static cairo_gl_glyph_t * _cairo_gl_glyph_cache_lock (cairo_gl_glyph_cache_t *cache, cairo_scaled_glyph_t *scaled_glyph) { - return _cairo_rtree_pin (&cache->rtree, scaled_glyph->surface_private); + return _cairo_rtree_pin (&cache->rtree, scaled_glyph->dev_private); } static cairo_status_t @@ -183,63 +203,29 @@ _cairo_gl_glyph_cache_unlock (cairo_gl_glyph_cache_t *cache) _cairo_rtree_unpin (&cache->rtree); } -static cairo_bool_t -_cairo_gl_surface_owns_font (cairo_gl_surface_t *surface, - cairo_scaled_font_t *scaled_font) -{ - cairo_device_t *font_private; - - font_private = scaled_font->surface_private; - if ((scaled_font->surface_backend != NULL && - scaled_font->surface_backend != &_cairo_gl_surface_backend) || - (font_private != NULL && font_private != surface->base.device)) - { - return FALSE; - } - - return TRUE; -} - -void -_cairo_gl_surface_scaled_font_fini (cairo_scaled_font_t *scaled_font) +static void +_cairo_gl_font_fini (cairo_scaled_font_private_t *_priv, + cairo_scaled_font_t *scaled_font) { - cairo_list_del (&scaled_font->link); -} + cairo_gl_font_t *priv = (cairo_gl_font_t *)_priv; -void -_cairo_gl_surface_scaled_glyph_fini (cairo_scaled_glyph_t *scaled_glyph, - cairo_scaled_font_t *scaled_font) -{ - cairo_gl_glyph_private_t *glyph_private; - - glyph_private = scaled_glyph->surface_private; - if (glyph_private != NULL) { - glyph_private->node.owner = NULL; - if (! glyph_private->node.pinned) { - /* XXX thread-safety? Probably ok due to the frozen scaled-font. */ - _cairo_rtree_node_remove (&glyph_private->cache->rtree, - &glyph_private->node); - } - } + cairo_list_del (&priv->link); + free (priv); } static cairo_status_t -_render_glyphs (cairo_gl_surface_t *dst, - int dst_x, int dst_y, - cairo_operator_t op, - const cairo_pattern_t *source, - cairo_glyph_t *glyphs, - int num_glyphs, - cairo_scaled_font_t *scaled_font, - const cairo_composite_rectangles_t *extents, - cairo_bool_t *has_component_alpha, - int *remaining_glyphs) +render_glyphs (cairo_gl_surface_t *dst, + int dst_x, int dst_y, + cairo_operator_t op, + const cairo_pattern_t *source, + cairo_composite_glyphs_info_t *info, + cairo_bool_t *has_component_alpha) { cairo_format_t last_format = CAIRO_FORMAT_INVALID; cairo_gl_glyph_cache_t *cache = NULL; cairo_gl_context_t *ctx; cairo_gl_composite_t setup; - cairo_status_t status; + cairo_int_status_t status; int i = 0; *has_component_alpha = FALSE; @@ -248,45 +234,30 @@ _render_glyphs (cairo_gl_surface_t *dst, if (unlikely (status)) return status; - _cairo_scaled_font_freeze_cache (scaled_font); - - status = _cairo_gl_composite_init (&setup, op, dst, - TRUE, &extents->bounded); - + status = _cairo_gl_composite_init (&setup, op, dst, TRUE, &info->extents); if (unlikely (status)) goto FINISH; - if (! _cairo_gl_surface_owns_font (dst, scaled_font)) { - status = CAIRO_INT_STATUS_UNSUPPORTED; - goto FINISH; - } - status = _cairo_gl_composite_set_source (&setup, source, - extents->bounded.x, - extents->bounded.y, + info->extents.x, + info->extents.y, dst_x, dst_y, - extents->bounded.width, - extents->bounded.height); + info->extents.width, + info->extents.height); if (unlikely (status)) goto FINISH; - if (scaled_font->surface_private == NULL) { - scaled_font->surface_private = ctx; - scaled_font->surface_backend = &_cairo_gl_surface_backend; - cairo_list_add (&scaled_font->link, &ctx->fonts); - } - _cairo_gl_composite_set_clip_region (&setup, - _cairo_clip_get_region (extents->clip)); + //_cairo_gl_composite_set_clip_region (&setup, _cairo_clip_get_region (extents->clip)); - for (i = 0; i < num_glyphs; i++) { + for (i = 0; i < info->num_glyphs; i++) { cairo_scaled_glyph_t *scaled_glyph; - cairo_gl_glyph_private_t *glyph; + cairo_gl_glyph_t *glyph; double x_offset, y_offset; double x1, x2, y1, y2; - status = _cairo_scaled_glyph_lookup (scaled_font, - glyphs[i].index, + status = _cairo_scaled_glyph_lookup (info->font, + info->glyphs[i].index, CAIRO_SCALED_GLYPH_INFO_SURFACE, &scaled_glyph); if (unlikely (status)) @@ -297,13 +268,6 @@ _render_glyphs (cairo_gl_surface_t *dst, { continue; } - if (scaled_glyph->surface->width > GLYPH_CACHE_MAX_SIZE || - scaled_glyph->surface->height > GLYPH_CACHE_MAX_SIZE) - { - status = CAIRO_INT_STATUS_UNSUPPORTED; - goto FINISH; - } - if (scaled_glyph->surface->format != last_format) { status = cairo_gl_context_get_glyph_cache (ctx, scaled_glyph->surface->format, @@ -331,25 +295,35 @@ _render_glyphs (cairo_gl_surface_t *dst, goto FINISH; } - if (scaled_glyph->surface_private == NULL) { - status = _cairo_gl_glyph_cache_add_glyph (ctx, cache, scaled_glyph); + if (scaled_glyph->dev_private_key != cache) { + cairo_scaled_glyph_private_t *priv; - if (status == CAIRO_INT_STATUS_UNSUPPORTED) { - /* Cache is full, so flush existing prims and try again. */ - _cairo_gl_composite_flush (ctx); - _cairo_gl_glyph_cache_unlock (cache); + priv = _cairo_scaled_glyph_find_private (scaled_glyph, cache); + if (priv) { + scaled_glyph->dev_private_key = cache; + scaled_glyph->dev_private = cairo_container_of (priv, + cairo_gl_glyph_t, + base);; + } else { status = _cairo_gl_glyph_cache_add_glyph (ctx, cache, scaled_glyph); - } - if (unlikely (_cairo_status_is_error (status))) - goto FINISH; + if (status == CAIRO_INT_STATUS_UNSUPPORTED) { + /* Cache is full, so flush existing prims and try again. */ + _cairo_gl_composite_flush (ctx); + _cairo_gl_glyph_cache_unlock (cache); + status = _cairo_gl_glyph_cache_add_glyph (ctx, cache, scaled_glyph); + } + + if (unlikely (_cairo_int_status_is_error (status))) + goto FINISH; + } } x_offset = scaled_glyph->surface->base.device_transform.x0; y_offset = scaled_glyph->surface->base.device_transform.y0; - x1 = _cairo_lround (glyphs[i].x - x_offset); - y1 = _cairo_lround (glyphs[i].y - y_offset); + x1 = _cairo_lround (info->glyphs[i].x - x_offset); + y1 = _cairo_lround (info->glyphs[i].y - y_offset); x2 = x1 + scaled_glyph->surface->width; y2 = y1 + scaled_glyph->surface->height; @@ -362,75 +336,59 @@ _render_glyphs (cairo_gl_surface_t *dst, status = CAIRO_STATUS_SUCCESS; FINISH: - _cairo_scaled_font_thaw_cache (scaled_font); - status = _cairo_gl_context_release (ctx, status); _cairo_gl_composite_fini (&setup); - - *remaining_glyphs = num_glyphs - i; return status; } static cairo_int_status_t -_cairo_gl_surface_show_glyphs_via_mask (cairo_gl_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *source, - cairo_glyph_t *glyphs, - int num_glyphs, - cairo_scaled_font_t *scaled_font, - cairo_composite_rectangles_t *extents, - int *remaining_glyphs) +render_glyphs_via_mask (cairo_gl_surface_t *dst, + cairo_operator_t op, + const cairo_surface_t *source, + cairo_composite_glyphs_info_t *info) { cairo_surface_t *mask; cairo_status_t status; cairo_bool_t has_component_alpha; - cairo_clip_t *saved_clip; int i; /* XXX: For non-CA, this should be CAIRO_CONTENT_ALPHA to save memory */ mask = cairo_gl_surface_create (dst->base.device, CAIRO_CONTENT_COLOR_ALPHA, - extents->bounded.width, - extents->bounded.height); + info->extents.width, + info->extents.height); if (unlikely (mask->status)) return mask->status; - for (i = 0; i < num_glyphs; i++) { - glyphs[i].x -= extents->bounded.x; - glyphs[i].y -= extents->bounded.y; + for (i = 0; i < info->num_glyphs; i++) { + info->glyphs[i].x -= info->extents.x; + info->glyphs[i].y -= info->extents.y; } - - saved_clip = extents->clip; - extents->clip = NULL; - status = _render_glyphs ((cairo_gl_surface_t *) mask, 0, 0, - CAIRO_OPERATOR_ADD, - &_cairo_pattern_white.base, - glyphs, num_glyphs, scaled_font, - extents, - &has_component_alpha, - remaining_glyphs); - extents->clip = saved_clip; - + status = render_glyphs ((cairo_gl_surface_t *) mask, 0, 0, + CAIRO_OPERATOR_ADD, + &_cairo_pattern_white.base, + info, &has_component_alpha); if (likely (status == CAIRO_STATUS_SUCCESS)) { + /* XXX composite */ +#if 0 cairo_surface_pattern_t mask_pattern; - mask->is_clear = FALSE; _cairo_pattern_init_for_surface (&mask_pattern, mask); mask_pattern.base.has_component_alpha = has_component_alpha; cairo_matrix_init_translate (&mask_pattern.base.matrix, - -extents->bounded.x, -extents->bounded.y); + -info->extents.x, -info->extents.y); status = _cairo_surface_mask (&dst->base, op, source, &mask_pattern.base, - extents->clip); + NULL); _cairo_pattern_fini (&mask_pattern.base); +#endif } else { - for (i = 0; i < num_glyphs; i++) { - glyphs[i].x += extents->bounded.x; - glyphs[i].y += extents->bounded.y; + for (i = 0; i < info->num_glyphs; i++) { + info->glyphs[i].x += info->extents.x; + info->glyphs[i].y += info->extents.y; } - *remaining_glyphs = num_glyphs; } cairo_surface_destroy (mask); @@ -438,143 +396,62 @@ _cairo_gl_surface_show_glyphs_via_mask (cairo_gl_surface_t *dst, return status; } +cairo_int_status_t +_cairo_gl_check_composite_glyphs (const cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *scaled_font, + cairo_glyph_t *glyphs, + int *num_glyphs) +{ + if (! _cairo_gl_operator_is_supported (extents->op)) + return UNSUPPORTED ("unsupported operator"); + + /* XXX use individual masks for large glyphs? */ + if (ceil (scaled_font->max_scale) >= GLYPH_CACHE_MAX_SIZE) + return UNSUPPORTED ("glyphs too large"); -cairo_private cairo_bool_t -_cairo_gl_surface_get_extents (void *abstract_surface, - cairo_rectangle_int_t *rectangle); + return CAIRO_STATUS_SUCCESS; +} cairo_int_status_t -_cairo_gl_surface_show_glyphs (void *abstract_dst, - 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, - int *remaining_glyphs) +_cairo_gl_composite_glyphs (void *_dst, + cairo_operator_t op, + cairo_surface_t *_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + cairo_composite_glyphs_info_t *info) { - cairo_gl_surface_t *dst = abstract_dst; - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; - cairo_bool_t overlap, use_mask = FALSE; + cairo_gl_surface_t *dst = _dst; cairo_bool_t has_component_alpha; - cairo_status_t status; int i; - if (! _cairo_gl_operator_is_supported (op)) - return UNSUPPORTED ("unsupported operator"); - - if (! _cairo_operator_bounded_by_mask (op)) - use_mask |= TRUE; - /* If any of the glyphs are component alpha, we have to go through a mask, * since only _cairo_gl_surface_composite() currently supports component * alpha. */ - if (!use_mask && op != CAIRO_OPERATOR_OVER) { - for (i = 0; i < num_glyphs; i++) { + if (!dst->base.is_clear && ! info->use_mask && op != CAIRO_OPERATOR_OVER) { + for (i = 0; i < info->num_glyphs; i++) { cairo_scaled_glyph_t *scaled_glyph; - status = _cairo_scaled_glyph_lookup (scaled_font, - glyphs[i].index, - CAIRO_SCALED_GLYPH_INFO_SURFACE, - &scaled_glyph); - if (!_cairo_status_is_error (status) && + if (_cairo_scaled_glyph_lookup (info->font, info->glyphs[i].index, + CAIRO_SCALED_GLYPH_INFO_SURFACE, + &scaled_glyph) == CAIRO_INT_STATUS_SUCCESS && scaled_glyph->surface->format == CAIRO_FORMAT_ARGB32) { - use_mask = TRUE; + info->use_mask = TRUE; break; } } } - /* For CLEAR, cairo's rendering equation (quoting Owen's description in: - * http://lists.cairographics.org/archives/cairo/2005-August/004992.html) - * is: - * mask IN clip ? src OP dest : dest - * or more simply: - * mask IN CLIP ? 0 : dest - * - * where the ternary operator A ? B : C is (A * B) + ((1 - A) * C). - * - * The model we use in _cairo_gl_set_operator() is Render's: - * src IN mask IN clip OP dest - * which would boil down to: - * 0 (bounded by the extents of the drawing). - * - * However, we can do a Render operation using an opaque source - * and DEST_OUT to produce: - * 1 IN mask IN clip DEST_OUT dest - * which is - * mask IN clip ? 0 : dest - */ - if (op == CAIRO_OPERATOR_CLEAR) { - source = &_cairo_pattern_white.base; - op = CAIRO_OPERATOR_DEST_OUT; - } - - /* For SOURCE, cairo's rendering equation is: - * (mask IN clip) ? src OP dest : dest - * or more simply: - * (mask IN clip) ? src : dest. - * - * If we just used the Render equation, we would get: - * (src IN mask IN clip) OP dest - * or: - * (src IN mask IN clip) bounded by extents of the drawing. - * - * The trick is that for GL blending, we only get our 4 source values - * into the blender, and since we need all 4 components of source, we - * can't also get the mask IN clip into the blender. But if we did - * two passes we could make it work: - * dest = (mask IN clip) DEST_OUT dest - * dest = src IN mask IN clip ADD dest - * - * But for now, composite via an intermediate mask. - */ - if (op == CAIRO_OPERATOR_SOURCE) - use_mask |= TRUE; - - /* XXX we don't need ownership of the font as we use a global - * glyph cache -- but we do need scaled_glyph eviction notification. :-( - */ - if (! _cairo_gl_surface_owns_font (dst, scaled_font)) - return UNSUPPORTED ("do not control font"); - - _cairo_gl_surface_get_extents (dst, &unbounded); - status = _cairo_composite_rectangles_init_for_glyphs (&extents, - &unbounded, - op, source, - scaled_font, - glyphs, num_glyphs, - clip, &overlap); - if (unlikely (status)) - return status; - - /* If the glyphs overlap, we need to build an intermediate mask rather - * then perform the compositing directly. - */ - use_mask |= overlap; - use_mask |= ! _cairo_clip_is_region (extents.clip); - - if (use_mask) { - status = _cairo_gl_surface_show_glyphs_via_mask (dst, op, - source, - glyphs, num_glyphs, - scaled_font, - &extents, - remaining_glyphs); + if (info->use_mask) { + return render_glyphs_via_mask (dst, op, _src, info); } else { - status = _render_glyphs (dst, extents.bounded.x, extents.bounded.y, - op, source, - glyphs, num_glyphs, scaled_font, - &extents, - &has_component_alpha, - remaining_glyphs); + return render_glyphs (dst, dst_x, dst_y, + op, _src, info, + &has_component_alpha); } - - _cairo_composite_rectangles_fini (&extents); - return status; } void @@ -584,7 +461,7 @@ _cairo_gl_glyph_cache_init (cairo_gl_glyph_cache_t *cache) GLYPH_CACHE_WIDTH, GLYPH_CACHE_HEIGHT, GLYPH_CACHE_MIN_SIZE, - sizeof (cairo_gl_glyph_private_t)); + sizeof (cairo_gl_glyph_t)); } void @@ -598,4 +475,3 @@ _cairo_gl_glyph_cache_fini (cairo_gl_context_t *ctx, cache->pattern.surface = NULL; } } - diff --git a/src/cairo-gl-operand.c b/src/cairo-gl-operand.c new file mode 100644 index 00000000..8b345bbd --- /dev/null +++ b/src/cairo-gl-operand.c @@ -0,0 +1,538 @@ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2009 Eric Anholt + * Copyright © 2009 Chris Wilson + * Copyright © 2005,2010 Red Hat, Inc + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is Red Hat, Inc. + * + * Contributor(s): + * Benjamin Otte <otte@gnome.org> + * Carl Worth <cworth@cworth.org> + * Chris Wilson <chris@chris-wilson.co.uk> + * Eric Anholt <eric@anholt.net> + */ + +#include "cairoint.h" + +#include "cairo-gl-private.h" + +#include "cairo-composite-rectangles-private.h" +#include "cairo-compositor-private.h" +#include "cairo-default-context-private.h" +#include "cairo-error-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-surface-backend-private.h" + +static cairo_int_status_t +_cairo_gl_create_gradient_texture (cairo_gl_surface_t *dst, + const cairo_gradient_pattern_t *pattern, + cairo_gl_gradient_t **gradient) +{ + cairo_gl_context_t *ctx; + cairo_status_t status; + + status = _cairo_gl_context_acquire (dst->base.device, &ctx); + if (unlikely (status)) + return status; + + status = _cairo_gl_gradient_create (ctx, pattern->n_stops, pattern->stops, gradient); + + return _cairo_gl_context_release (ctx, status); +} + +/* + * Like cairo_pattern_acquire_surface(), but returns a matrix that transforms + * from dest to src coords. + */ +static cairo_status_t +_cairo_gl_pattern_texture_setup (cairo_gl_operand_t *operand, + const cairo_pattern_t *src, + cairo_gl_surface_t *dst, + int src_x, int src_y, + int dst_x, int dst_y, + int width, int height) +{ + cairo_status_t status; + cairo_matrix_t m; + cairo_gl_surface_t *surface; + cairo_surface_attributes_t *attributes; + + attributes = &operand->texture.attributes; + +#if 0 + status = _cairo_pattern_acquire_surface (src, &dst->base, + src_x, src_y, + width, height, + CAIRO_PATTERN_ACQUIRE_NONE, + (cairo_surface_t **) + &surface, + attributes); + if (unlikely (status)) + return status; +#endif + + if (_cairo_gl_device_requires_power_of_two_textures (dst->base.device) && + (attributes->extend == CAIRO_EXTEND_REPEAT || + attributes->extend == CAIRO_EXTEND_REFLECT)) + { + return UNSUPPORTED ("EXT_texture_rectangle with repeat/reflect"); + } + + assert (_cairo_gl_surface_is_texture (surface)); + + operand->type = CAIRO_GL_OPERAND_TEXTURE; + operand->texture.surface = surface; + operand->texture.tex = surface->tex; + /* Translate the matrix from + * (unnormalized src -> unnormalized src) to + * (unnormalized dst -> unnormalized src) + */ + cairo_matrix_init_translate (&m, + src_x - dst_x + attributes->x_offset, + src_y - dst_y + attributes->y_offset); + cairo_matrix_multiply (&attributes->matrix, + &m, + &attributes->matrix); + + + /* Translate the matrix from + * (unnormalized dst -> unnormalized src) to + * (unnormalized dst -> normalized src) + */ + if (_cairo_gl_device_requires_power_of_two_textures (dst->base.device)) { + cairo_matrix_init_scale (&m, + 1.0, + 1.0); + } else { + cairo_matrix_init_scale (&m, + 1.0 / surface->width, + 1.0 / surface->height); + } + cairo_matrix_multiply (&attributes->matrix, + &attributes->matrix, + &m); + + return CAIRO_STATUS_SUCCESS; +} + +void +_cairo_gl_solid_operand_init (cairo_gl_operand_t *operand, + const cairo_color_t *color) +{ + operand->type = CAIRO_GL_OPERAND_CONSTANT; + operand->constant.color[0] = color->red * color->alpha; + operand->constant.color[1] = color->green * color->alpha; + operand->constant.color[2] = color->blue * color->alpha; + operand->constant.color[3] = color->alpha; +} + +static cairo_status_t +_cairo_gl_gradient_operand_init (cairo_gl_operand_t *operand, + const cairo_pattern_t *pattern, + cairo_gl_surface_t *dst, + int src_x, int src_y, + int dst_x, int dst_y) +{ + const cairo_gradient_pattern_t *gradient = (const cairo_gradient_pattern_t *)pattern; + cairo_status_t status; + + assert (gradient->base.type == CAIRO_PATTERN_TYPE_LINEAR || + gradient->base.type == CAIRO_PATTERN_TYPE_RADIAL); + + if (! _cairo_gl_device_has_glsl (dst->base.device)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + status = _cairo_gl_create_gradient_texture (dst, + gradient, + &operand->gradient.gradient); + if (unlikely (status)) + return status; + + if (gradient->base.type == CAIRO_PATTERN_TYPE_LINEAR) { + cairo_linear_pattern_t *linear = (cairo_linear_pattern_t *) gradient; + double x0, y0, dx, dy, sf, offset; + + dx = linear->pd2.x - linear->pd1.x; + dy = linear->pd2.y - linear->pd1.y; + sf = 1.0 / (dx * dx + dy * dy); + dx *= sf; + dy *= sf; + + x0 = linear->pd1.x; + y0 = linear->pd1.y; + offset = dx * x0 + dy * y0; + + operand->type = CAIRO_GL_OPERAND_LINEAR_GRADIENT; + + cairo_matrix_init (&operand->gradient.m, dx, 0, dy, 1, -offset, 0); + if (! _cairo_matrix_is_identity (&pattern->matrix)) { + cairo_matrix_multiply (&operand->gradient.m, + &pattern->matrix, + &operand->gradient.m); + } + } else { + cairo_matrix_t m; + cairo_circle_double_t circles[2]; + double x0, y0, r0, dx, dy, dr; + + /* + * Some fragment shader implementations use half-floats to + * represent numbers, so the maximum number they can represent + * is about 2^14. Some intermediate computations used in the + * radial gradient shaders can produce results of up to 2*k^4. + * Setting k=8 makes the maximum result about 8192 (assuming + * that the extreme circles are not much smaller than the + * destination image). + */ + _cairo_gradient_pattern_fit_to_range (gradient, 8., + &operand->gradient.m, circles); + + x0 = circles[0].center.x; + y0 = circles[0].center.y; + r0 = circles[0].radius; + dx = circles[1].center.x - x0; + dy = circles[1].center.y - y0; + dr = circles[1].radius - r0; + + operand->gradient.a = dx * dx + dy * dy - dr * dr; + operand->gradient.radius_0 = r0; + operand->gradient.circle_d.center.x = dx; + operand->gradient.circle_d.center.y = dy; + operand->gradient.circle_d.radius = dr; + + if (operand->gradient.a == 0) + operand->type = CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0; + else if (pattern->extend == CAIRO_EXTEND_NONE) + operand->type = CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE; + else + operand->type = CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT; + + cairo_matrix_init_translate (&m, -x0, -y0); + cairo_matrix_multiply (&operand->gradient.m, + &operand->gradient.m, + &m); + } + + cairo_matrix_translate (&operand->gradient.m, src_x - dst_x, src_y - dst_y); + + operand->gradient.extend = pattern->extend; + + return CAIRO_STATUS_SUCCESS; +} + +void +_cairo_gl_operand_destroy (cairo_gl_operand_t *operand) +{ + switch (operand->type) { + case CAIRO_GL_OPERAND_CONSTANT: + break; + case CAIRO_GL_OPERAND_LINEAR_GRADIENT: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: + _cairo_gl_gradient_destroy (operand->gradient.gradient); + break; + case CAIRO_GL_OPERAND_TEXTURE: + break; + default: + case CAIRO_GL_OPERAND_COUNT: + ASSERT_NOT_REACHED; + case CAIRO_GL_OPERAND_NONE: + break; + } + + operand->type = CAIRO_GL_OPERAND_NONE; +} + +cairo_int_status_t +_cairo_gl_operand_init (cairo_gl_operand_t *operand, + const cairo_pattern_t *pattern, + cairo_gl_surface_t *dst, + int src_x, int src_y, + int dst_x, int dst_y, + int width, int height) +{ + cairo_int_status_t status; + + switch (pattern->type) { + case CAIRO_PATTERN_TYPE_SOLID: + _cairo_gl_solid_operand_init (operand, + &((cairo_solid_pattern_t *) pattern)->color); + return CAIRO_STATUS_SUCCESS; + case CAIRO_PATTERN_TYPE_LINEAR: + case CAIRO_PATTERN_TYPE_RADIAL: + status = _cairo_gl_gradient_operand_init (operand, + pattern, dst, + src_x, src_y, + dst_x, dst_y); + if (status != CAIRO_INT_STATUS_UNSUPPORTED) + return status; + + /* fall through */ + + default: + case CAIRO_PATTERN_TYPE_MESH: + case CAIRO_PATTERN_TYPE_SURFACE: + return _cairo_gl_pattern_texture_setup (operand, + pattern, dst, + src_x, src_y, + dst_x, dst_y, + width, height); + } +} + +cairo_filter_t +_cairo_gl_operand_get_filter (cairo_gl_operand_t *operand) +{ + cairo_filter_t filter; + + switch ((int) operand->type) { + case CAIRO_GL_OPERAND_TEXTURE: + filter = operand->texture.attributes.filter; + break; + case CAIRO_GL_OPERAND_LINEAR_GRADIENT: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: + filter = CAIRO_FILTER_BILINEAR; + break; + default: + filter = CAIRO_FILTER_DEFAULT; + break; + } + + return filter; +} + +GLint +_cairo_gl_operand_get_gl_filter (cairo_gl_operand_t *operand) +{ + cairo_filter_t filter = _cairo_gl_operand_get_filter (operand); + + return filter != CAIRO_FILTER_FAST && filter != CAIRO_FILTER_NEAREST ? + GL_LINEAR : + GL_NEAREST; +} + +cairo_extend_t +_cairo_gl_operand_get_extend (cairo_gl_operand_t *operand) +{ + cairo_extend_t extend; + + switch ((int) operand->type) { + case CAIRO_GL_OPERAND_TEXTURE: + extend = operand->texture.attributes.extend; + break; + case CAIRO_GL_OPERAND_LINEAR_GRADIENT: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: + extend = operand->gradient.extend; + break; + default: + extend = CAIRO_EXTEND_NONE; + break; + } + + return extend; +} + + +void +_cairo_gl_operand_bind_to_shader (cairo_gl_context_t *ctx, + cairo_gl_operand_t *operand, + cairo_gl_tex_t tex_unit) +{ + char uniform_name[50]; + char *custom_part; + static const char *names[] = { "source", "mask" }; + + strcpy (uniform_name, names[tex_unit]); + custom_part = uniform_name + strlen (names[tex_unit]); + + switch (operand->type) { + default: + case CAIRO_GL_OPERAND_COUNT: + ASSERT_NOT_REACHED; + case CAIRO_GL_OPERAND_NONE: + break; + case CAIRO_GL_OPERAND_CONSTANT: + strcpy (custom_part, "_constant"); + _cairo_gl_shader_bind_vec4 (ctx, + uniform_name, + operand->constant.color[0], + operand->constant.color[1], + operand->constant.color[2], + operand->constant.color[3]); + break; + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: + strcpy (custom_part, "_a"); + _cairo_gl_shader_bind_float (ctx, + uniform_name, + operand->gradient.a); + /* fall through */ + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: + strcpy (custom_part, "_circle_d"); + _cairo_gl_shader_bind_vec3 (ctx, + uniform_name, + operand->gradient.circle_d.center.x, + operand->gradient.circle_d.center.y, + operand->gradient.circle_d.radius); + strcpy (custom_part, "_radius_0"); + _cairo_gl_shader_bind_float (ctx, + uniform_name, + operand->gradient.radius_0); + /* fall through */ + case CAIRO_GL_OPERAND_LINEAR_GRADIENT: + case CAIRO_GL_OPERAND_TEXTURE: + /* + * For GLES2 we use shaders to implement GL_CLAMP_TO_BORDER (used + * with CAIRO_EXTEND_NONE). When bilinear filtering is enabled, + * these shaders need the texture dimensions for their calculations. + */ + if (ctx->gl_flavor == CAIRO_GL_FLAVOR_ES && + _cairo_gl_operand_get_extend (operand) == CAIRO_EXTEND_NONE && + _cairo_gl_operand_get_gl_filter (operand) == GL_LINEAR) + { + float width, height; + if (operand->type == CAIRO_GL_OPERAND_TEXTURE) { + width = operand->texture.surface->width; + height = operand->texture.surface->height; + } + else { + width = operand->gradient.gradient->cache_entry.size, + height = 1; + } + strcpy (custom_part, "_texdims"); + _cairo_gl_shader_bind_vec2 (ctx, uniform_name, width, height); + } + break; + } +} + + +cairo_bool_t +_cairo_gl_operand_needs_setup (cairo_gl_operand_t *dest, + cairo_gl_operand_t *source, + unsigned int vertex_offset) +{ + if (dest->type != source->type) + return TRUE; + if (dest->vertex_offset != vertex_offset) + return TRUE; + + switch (source->type) { + case CAIRO_GL_OPERAND_NONE: + return FALSE; + case CAIRO_GL_OPERAND_CONSTANT: + return dest->constant.color[0] != source->constant.color[0] || + dest->constant.color[1] != source->constant.color[1] || + dest->constant.color[2] != source->constant.color[2] || + dest->constant.color[3] != source->constant.color[3]; + case CAIRO_GL_OPERAND_TEXTURE: + return dest->texture.surface != source->texture.surface || + dest->texture.attributes.extend != source->texture.attributes.extend || + dest->texture.attributes.filter != source->texture.attributes.filter || + dest->texture.attributes.has_component_alpha != source->texture.attributes.has_component_alpha; + case CAIRO_GL_OPERAND_LINEAR_GRADIENT: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: + /* XXX: improve this */ + return TRUE; + default: + case CAIRO_GL_OPERAND_COUNT: + ASSERT_NOT_REACHED; + break; + } + return TRUE; +} + +unsigned int +_cairo_gl_operand_get_vertex_size (cairo_gl_operand_type_t type) +{ + switch (type) { + default: + case CAIRO_GL_OPERAND_COUNT: + ASSERT_NOT_REACHED; + case CAIRO_GL_OPERAND_NONE: + case CAIRO_GL_OPERAND_CONSTANT: + return 0; + case CAIRO_GL_OPERAND_TEXTURE: + case CAIRO_GL_OPERAND_LINEAR_GRADIENT: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: + return 2 * sizeof (GLfloat); + } +} + +void +_cairo_gl_operand_emit (cairo_gl_operand_t *operand, + GLfloat ** vb, + GLfloat x, + GLfloat y, + uint8_t alpha) +{ + switch (operand->type) { + default: + case CAIRO_GL_OPERAND_COUNT: + ASSERT_NOT_REACHED; + case CAIRO_GL_OPERAND_NONE: + case CAIRO_GL_OPERAND_CONSTANT: + break; + case CAIRO_GL_OPERAND_LINEAR_GRADIENT: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE: + case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: + { + double s = x; + double t = y; + + cairo_matrix_transform_point (&operand->gradient.m, &s, &t); + + *(*vb)++ = s; + *(*vb)++ = t; + } + break; + case CAIRO_GL_OPERAND_TEXTURE: + { + cairo_surface_attributes_t *src_attributes = &operand->texture.attributes; + double s = x; + double t = y; + + cairo_matrix_transform_point (&src_attributes->matrix, &s, &t); + *(*vb)++ = s; + *(*vb)++ = t; + } + break; + } +} diff --git a/src/cairo-gl-private.h b/src/cairo-gl-private.h index ee79b23a..e1005ba8 100644 --- a/src/cairo-gl-private.h +++ b/src/cairo-gl-private.h @@ -48,16 +48,17 @@ #include "cairoint.h" +#include "cairo-gl.h" #include "cairo-gl-gradient-private.h" #include "cairo-device-private.h" #include "cairo-error-private.h" #include "cairo-rtree-private.h" +#include "cairo-scaled-font-private.h" +#include "cairo-spans-compositor-private.h" #include <assert.h> -#include "cairo-gl.h" - #if CAIRO_HAS_GL_SURFACE #include <GL/gl.h> #include <GL/glext.h> @@ -138,7 +139,6 @@ typedef enum cairo_gl_operand_type { CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0, CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE, CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT, - CAIRO_GL_OPERAND_SPANS, CAIRO_GL_OPERAND_COUNT } cairo_gl_operand_type_t; @@ -161,11 +161,10 @@ typedef enum cairo_gl_shader_in { typedef enum cairo_gl_var_type { CAIRO_GL_VAR_NONE, CAIRO_GL_VAR_TEXCOORDS, - CAIRO_GL_VAR_COVERAGE } cairo_gl_var_type_t; -#define cairo_gl_var_type_hash(src,mask,dest) ((mask) << 2 | (src << 1) | (dest)) -#define CAIRO_GL_VAR_TYPE_MAX ((CAIRO_GL_VAR_COVERAGE << 2) | (CAIRO_GL_VAR_TEXCOORDS << 1) | CAIRO_GL_VAR_TEXCOORDS) +#define cairo_gl_var_type_hash(src,mask,spans,dest) ((spans) << 3) | ((mask) << 2 | (src << 1) | (dest)) +#define CAIRO_GL_VAR_TYPE_MAX ((CAIRO_GL_VAR_TEXCOORDS << 3) | (CAIRO_GL_VAR_TEXCOORDS << 2) | (CAIRO_GL_VAR_TEXCOORDS << 1) | CAIRO_GL_VAR_TEXCOORDS) /* This union structure describes a potential source or mask operand to the * compositing equation. @@ -259,6 +258,8 @@ typedef struct _cairo_gl_dispatch { struct _cairo_gl_context { cairo_device_t base; + const cairo_compositor_t *compositor; + GLuint texture_load_pbo; GLuint vbo; GLint max_framebuffer_size; @@ -283,6 +284,7 @@ struct _cairo_gl_context { cairo_gl_shader_t *current_shader; cairo_gl_operand_t operands[2]; + cairo_bool_t spans; char *vb; char *vb_mem; @@ -311,8 +313,15 @@ typedef struct _cairo_gl_composite { cairo_gl_operand_t src; cairo_gl_operand_t mask; + cairo_bool_t spans; } cairo_gl_composite_t; +typedef struct _cairo_gl_font { + cairo_scaled_font_private_t base; + cairo_device_t *device; + cairo_list_t link; +} cairo_gl_font_t; + cairo_private extern const cairo_surface_backend_t _cairo_gl_surface_backend; static cairo_always_inline GLenum @@ -432,6 +441,13 @@ _cairo_gl_composite_set_source (cairo_gl_composite_t *setup, int src_x, int src_y, int dst_x, int dst_y, int width, int height); +cairo_private void +_cairo_gl_composite_set_solid_source (cairo_gl_composite_t *setup, + const cairo_color_t *color); + +cairo_private void +_cairo_gl_composite_set_source_operand (cairo_gl_composite_t *setup, + const cairo_gl_operand_t *source); cairo_private cairo_int_status_t _cairo_gl_composite_set_mask (cairo_gl_composite_t *setup, @@ -441,7 +457,11 @@ _cairo_gl_composite_set_mask (cairo_gl_composite_t *setup, int width, int height); cairo_private void -_cairo_gl_composite_set_mask_spans (cairo_gl_composite_t *setup); +_cairo_gl_composite_set_mask_operand (cairo_gl_composite_t *setup, + const cairo_gl_operand_t *mask); + +cairo_private void +_cairo_gl_composite_set_spans (cairo_gl_composite_t *setup); cairo_private cairo_status_t _cairo_gl_composite_begin (cairo_gl_composite_t *setup, @@ -481,13 +501,6 @@ _cairo_gl_get_image_format_and_type (cairo_gl_flavor_t flavor, cairo_bool_t *needs_swap); cairo_private void -_cairo_gl_surface_scaled_font_fini ( cairo_scaled_font_t *scaled_font); - -cairo_private void -_cairo_gl_surface_scaled_glyph_fini (cairo_scaled_glyph_t *scaled_glyph, - cairo_scaled_font_t *scaled_font); - -cairo_private void _cairo_gl_glyph_cache_init (cairo_gl_glyph_cache_t *cache); cairo_private void @@ -529,6 +542,7 @@ cairo_private cairo_status_t _cairo_gl_get_shader_by_type (cairo_gl_context_t *ctx, cairo_gl_operand_t *source, cairo_gl_operand_t *mask, + cairo_bool_t use_coverage, cairo_gl_shader_in_t in, cairo_gl_shader_t **shader); @@ -585,6 +599,17 @@ cairo_private cairo_status_t _cairo_gl_dispatch_init(cairo_gl_dispatch_t *dispatch, cairo_gl_get_proc_addr_func_t get_proc_addr); +cairo_private cairo_int_status_t +_cairo_gl_operand_init (cairo_gl_operand_t *operand, + const cairo_pattern_t *pattern, + cairo_gl_surface_t *dst, + int src_x, int src_y, + int dst_x, int dst_y, + int width, int height); +cairo_private void +_cairo_gl_solid_operand_init (cairo_gl_operand_t *operand, + const cairo_color_t *color); + cairo_private cairo_filter_t _cairo_gl_operand_get_filter (cairo_gl_operand_t *operand); @@ -594,25 +619,50 @@ _cairo_gl_operand_get_gl_filter (cairo_gl_operand_t *operand); cairo_private cairo_extend_t _cairo_gl_operand_get_extend (cairo_gl_operand_t *operand); +cairo_private unsigned int +_cairo_gl_operand_get_vertex_size (cairo_gl_operand_type_t type); + cairo_private cairo_bool_t -_cairo_gl_surface_get_extents (void *abstract_surface, - cairo_rectangle_int_t *rectangle); +_cairo_gl_operand_needs_setup (cairo_gl_operand_t *dest, + cairo_gl_operand_t *source, + unsigned int vertex_offset); + +cairo_private void +_cairo_gl_operand_bind_to_shader (cairo_gl_context_t *ctx, + cairo_gl_operand_t *operand, + cairo_gl_tex_t tex_unit); + +cairo_private void +_cairo_gl_operand_emit (cairo_gl_operand_t *operand, + GLfloat ** vb, + GLfloat x, + GLfloat y, + uint8_t alpha); + +cairo_private void +_cairo_gl_operand_destroy (cairo_gl_operand_t *operand); + +cairo_private const cairo_compositor_t * +_cairo_gl_span_compositor_get (void); + +cairo_private const cairo_compositor_t * +_cairo_gl_traps_compositor_get (void); cairo_private cairo_int_status_t -_cairo_gl_surface_polygon (cairo_gl_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_polygon_t *polygon, - cairo_fill_rule_t fill_rule, - cairo_antialias_t antialias, - const cairo_composite_rectangles_t *extents); +_cairo_gl_check_composite_glyphs (const cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *scaled_font, + cairo_glyph_t *glyphs, + int *num_glyphs); cairo_private cairo_int_status_t -_cairo_gl_clip_and_composite_boxes (cairo_gl_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_boxes_t *boxes, - cairo_composite_rectangles_t *extents); +_cairo_gl_composite_glyphs (void *_dst, + cairo_operator_t op, + cairo_surface_t *_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + cairo_composite_glyphs_info_t *info); slim_hidden_proto (cairo_gl_surface_create); slim_hidden_proto (cairo_gl_surface_create_for_texture); diff --git a/src/cairo-gl-shaders.c b/src/cairo-gl-shaders.c index 7d60c0f3..69609dfb 100644 --- a/src/cairo-gl-shaders.c +++ b/src/cairo-gl-shaders.c @@ -108,6 +108,7 @@ _cairo_gl_shader_compile (cairo_gl_context_t *ctx, cairo_gl_shader_t *shader, cairo_gl_var_type_t src, cairo_gl_var_type_t mask, + cairo_bool_t use_coverage, const char *fragment_text); /* OpenGL Core 2.0 API. */ @@ -426,6 +427,7 @@ _cairo_gl_context_init_shaders (cairo_gl_context_t *ctx) &ctx->fill_rectangles_shader, CAIRO_GL_VAR_NONE, CAIRO_GL_VAR_NONE, + FALSE, fill_fs_source); if (unlikely (status)) return status; @@ -475,8 +477,6 @@ cairo_gl_operand_get_var_type (cairo_gl_operand_type_t type) case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT: case CAIRO_GL_OPERAND_TEXTURE: return CAIRO_GL_VAR_TEXCOORDS; - case CAIRO_GL_OPERAND_SPANS: - return CAIRO_GL_VAR_COVERAGE; } } @@ -491,13 +491,8 @@ cairo_gl_shader_emit_variable (cairo_output_stream_t *stream, case CAIRO_GL_VAR_NONE: break; case CAIRO_GL_VAR_TEXCOORDS: - _cairo_output_stream_printf (stream, - "varying vec2 %s_texcoords;\n", - operand_names[name]); - break; - case CAIRO_GL_VAR_COVERAGE: - _cairo_output_stream_printf (stream, - "varying float %s_coverage;\n", + _cairo_output_stream_printf (stream, + "varying vec2 %s_texcoords;\n", operand_names[name]); break; } @@ -514,21 +509,29 @@ cairo_gl_shader_emit_vertex (cairo_output_stream_t *stream, case CAIRO_GL_VAR_NONE: break; case CAIRO_GL_VAR_TEXCOORDS: - _cairo_output_stream_printf (stream, + _cairo_output_stream_printf (stream, " %s_texcoords = MultiTexCoord%d.xy;\n", operand_names[name], name); break; - case CAIRO_GL_VAR_COVERAGE: - _cairo_output_stream_printf (stream, - " %s_coverage = Color.a;\n", - operand_names[name]); - break; } } +static void +cairo_gl_shader_dcl_coverage (cairo_output_stream_t *stream) +{ + _cairo_output_stream_printf (stream, "varying float coverage;\n"); +} + +static void +cairo_gl_shader_def_coverage (cairo_output_stream_t *stream) +{ + _cairo_output_stream_printf (stream, " coverage = Color.a;\n"); +} + static cairo_status_t cairo_gl_shader_get_vertex_source (cairo_gl_var_type_t src, cairo_gl_var_type_t mask, + cairo_bool_t use_coverage, cairo_gl_var_type_t dest, char **out) { @@ -539,6 +542,8 @@ cairo_gl_shader_get_vertex_source (cairo_gl_var_type_t src, cairo_gl_shader_emit_variable (stream, src, CAIRO_GL_TEX_SOURCE); cairo_gl_shader_emit_variable (stream, mask, CAIRO_GL_TEX_MASK); + if (use_coverage) + cairo_gl_shader_dcl_coverage (stream); _cairo_output_stream_printf (stream, "attribute vec4 Vertex;\n" @@ -552,6 +557,8 @@ cairo_gl_shader_get_vertex_source (cairo_gl_var_type_t src, cairo_gl_shader_emit_vertex (stream, src, CAIRO_GL_TEX_SOURCE); cairo_gl_shader_emit_vertex (stream, mask, CAIRO_GL_TEX_MASK); + if (use_coverage) + cairo_gl_shader_def_coverage (stream); _cairo_output_stream_write (stream, "}\n\0", 3); @@ -774,15 +781,6 @@ cairo_gl_shader_emit_color (cairo_output_stream_t *stream, namestr, namestr, namestr, namestr, namestr, namestr, namestr, namestr, rectstr, namestr); break; - case CAIRO_GL_OPERAND_SPANS: - _cairo_output_stream_printf (stream, - "varying float %s_coverage;\n" - "vec4 get_%s()\n" - "{\n" - " return vec4(0, 0, 0, %s_coverage);\n" - "}\n", - namestr, namestr, namestr); - break; } } @@ -842,6 +840,7 @@ cairo_gl_shader_get_fragment_source (cairo_gl_context_t *ctx, cairo_gl_shader_in_t in, cairo_gl_operand_t *src, cairo_gl_operand_t *mask, + cairo_bool_t use_coverage, cairo_gl_operand_type_t dest_type, char **out) { @@ -849,6 +848,7 @@ cairo_gl_shader_get_fragment_source (cairo_gl_context_t *ctx, unsigned char *source; unsigned long length; cairo_status_t status; + const char *coverage_str; _cairo_output_stream_printf (stream, "#ifdef GL_ES\n" @@ -865,6 +865,10 @@ cairo_gl_shader_get_fragment_source (cairo_gl_context_t *ctx, cairo_gl_shader_emit_color (stream, ctx, src, CAIRO_GL_TEX_SOURCE); cairo_gl_shader_emit_color (stream, ctx, mask, CAIRO_GL_TEX_MASK); + coverage_str = ""; + if (use_coverage) + coverage_str = " * coverage.a"; + _cairo_output_stream_printf (stream, "void main()\n" "{\n"); @@ -874,15 +878,18 @@ cairo_gl_shader_get_fragment_source (cairo_gl_context_t *ctx, ASSERT_NOT_REACHED; case CAIRO_GL_SHADER_IN_NORMAL: _cairo_output_stream_printf (stream, - " gl_FragColor = get_source() * get_mask().a;\n"); + " gl_FragColor = get_source() * get_mask().a%s;\n", + coverage_str); break; case CAIRO_GL_SHADER_IN_CA_SOURCE: _cairo_output_stream_printf (stream, - " gl_FragColor = get_source() * get_mask();\n"); + " gl_FragColor = get_source() * get_mask()%s;\n", + coverage_str); break; case CAIRO_GL_SHADER_IN_CA_SOURCE_ALPHA: _cairo_output_stream_printf (stream, - " gl_FragColor = get_source().a * get_mask();\n"); + " gl_FragColor = get_source().a * get_mask()%s;\n", + coverage_str); break; } @@ -902,6 +909,7 @@ _cairo_gl_shader_compile (cairo_gl_context_t *ctx, cairo_gl_shader_t *shader, cairo_gl_var_type_t src, cairo_gl_var_type_t mask, + cairo_bool_t use_coverage, const char *fragment_text) { unsigned int vertex_shader; @@ -909,12 +917,14 @@ _cairo_gl_shader_compile (cairo_gl_context_t *ctx, assert (shader->program == 0); - vertex_shader = cairo_gl_var_type_hash (src, mask, CAIRO_GL_VAR_NONE); + vertex_shader = cairo_gl_var_type_hash (src, mask, use_coverage, + CAIRO_GL_VAR_NONE); if (ctx->vertex_shaders[vertex_shader] == 0) { char *source; status = cairo_gl_shader_get_vertex_source (src, mask, + use_coverage, CAIRO_GL_VAR_NONE, &source); if (unlikely (status)) @@ -1042,6 +1052,7 @@ cairo_status_t _cairo_gl_get_shader_by_type (cairo_gl_context_t *ctx, cairo_gl_operand_t *source, cairo_gl_operand_t *mask, + cairo_bool_t use_coverage, cairo_gl_shader_in_t in, cairo_gl_shader_t **shader) { @@ -1071,6 +1082,7 @@ _cairo_gl_get_shader_by_type (cairo_gl_context_t *ctx, in, source, mask, + use_coverage, CAIRO_GL_OPERAND_NONE, &fs_source); if (unlikely (status)) @@ -1090,6 +1102,7 @@ _cairo_gl_get_shader_by_type (cairo_gl_context_t *ctx, &entry->shader, cairo_gl_operand_get_var_type (source->type), cairo_gl_operand_get_var_type (mask->type), + use_coverage, fs_source); free (fs_source); diff --git a/src/cairo-gl-spans-compositor.c b/src/cairo-gl-spans-compositor.c new file mode 100644 index 00000000..57cccc9f --- /dev/null +++ b/src/cairo-gl-spans-compositor.c @@ -0,0 +1,502 @@ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2009 Eric Anholt + * Copyright © 2009 Chris Wilson + * Copyright © 2005,2010 Red Hat, Inc + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is Red Hat, Inc. + * + * Contributor(s): + * Benjamin Otte <otte@gnome.org> + * Carl Worth <cworth@cworth.org> + * Chris Wilson <chris@chris-wilson.co.uk> + * Eric Anholt <eric@anholt.net> + */ + +#include "cairoint.h" + +#include "cairo-gl-private.h" + +#include "cairo-composite-rectangles-private.h" +#include "cairo-compositor-private.h" +#include "cairo-default-context-private.h" +#include "cairo-error-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-spans-compositor-private.h" +#include "cairo-surface-backend-private.h" + +typedef struct _cairo_gl_span_renderer { + cairo_span_renderer_t base; + + cairo_gl_composite_t setup; + double opacity; + + int xmin, xmax; + int ymin, ymax; + + cairo_gl_context_t *ctx; +} cairo_gl_span_renderer_t; + +static cairo_status_t +_cairo_gl_bounded_opaque_spans (void *abstract_renderer, + int y, int height, + const cairo_half_open_span_t *spans, + unsigned num_spans) +{ + cairo_gl_span_renderer_t *r = abstract_renderer; + + if (num_spans == 0) + return CAIRO_STATUS_SUCCESS; + + do { + if (spans[0].coverage) { + _cairo_gl_composite_emit_rect (r->ctx, + spans[0].x, y, + spans[1].x, y + height, + spans[0].coverage); + } + + spans++; + } while (--num_spans > 1); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_gl_bounded_spans (void *abstract_renderer, + int y, int height, + const cairo_half_open_span_t *spans, + unsigned num_spans) +{ + cairo_gl_span_renderer_t *r = abstract_renderer; + + if (num_spans == 0) + return CAIRO_STATUS_SUCCESS; + + do { + if (spans[0].coverage) { + _cairo_gl_composite_emit_rect (r->ctx, + spans[0].x, y, + spans[1].x, y + height, + r->opacity * spans[0].coverage); + } + + spans++; + } while (--num_spans > 1); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_gl_unbounded_spans (void *abstract_renderer, + int y, int height, + const cairo_half_open_span_t *spans, + unsigned num_spans) +{ + cairo_gl_span_renderer_t *r = abstract_renderer; + + if (y > r->ymin) { + _cairo_gl_composite_emit_rect (r->ctx, + r->xmin, r->ymin, + r->xmax, y, + 0); + } + + if (num_spans == 0) { + _cairo_gl_composite_emit_rect (r->ctx, + r->xmin, y, + r->xmax, y + height, + 0); + } else { + if (spans[0].x != r->xmin) { + _cairo_gl_composite_emit_rect (r->ctx, + r->xmin, y, + spans[0].x, y + height, + 0); + } + + do { + _cairo_gl_composite_emit_rect (r->ctx, + spans[0].x, y, + spans[1].x, y + height, + r->opacity * spans[0].coverage); + spans++; + } while (--num_spans > 1); + + if (spans[0].x != r->xmax) { + _cairo_gl_composite_emit_rect (r->ctx, + spans[0].x, y, + r->xmax, y + height, + 0); + } + } + + r->ymin = y + height; + return CAIRO_STATUS_SUCCESS; +} + +/* XXX */ +static cairo_status_t +_cairo_gl_clipped_spans (void *abstract_renderer, + int y, int height, + const cairo_half_open_span_t *spans, + unsigned num_spans) +{ + cairo_gl_span_renderer_t *r = abstract_renderer; + + if (y > r->ymin) { + _cairo_gl_composite_emit_rect (r->ctx, + r->xmin, r->ymin, + r->xmax, y, + 0); + } + + if (num_spans == 0) { + _cairo_gl_composite_emit_rect (r->ctx, + r->xmin, y, + r->xmax, y + height, + 0); + } else { + if (spans[0].x != r->xmin) { + _cairo_gl_composite_emit_rect (r->ctx, + r->xmin, y, + spans[0].x, y + height, + 0); + } + + do { + _cairo_gl_composite_emit_rect (r->ctx, + spans[0].x, y, + spans[1].x, y + height, + r->opacity * spans[0].coverage); + spans++; + } while (--num_spans > 1); + + if (spans[0].x != r->xmax) { + _cairo_gl_composite_emit_rect (r->ctx, + spans[0].x, y, + r->xmax, y + height, + 0); + } + } + + r->ymin = y + height; + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_gl_finish_unbounded_spans (void *abstract_renderer) +{ + cairo_gl_span_renderer_t *r = abstract_renderer; + + if (r->ymax > r->ymin) { + _cairo_gl_composite_emit_rect (r->ctx, + r->xmin, r->ymin, + r->xmax, r->ymax, + 0); + } + + return _cairo_gl_context_release (r->ctx, CAIRO_STATUS_SUCCESS); +} + +static cairo_status_t +_cairo_gl_finish_bounded_spans (void *abstract_renderer) +{ + cairo_gl_span_renderer_t *r = abstract_renderer; + + return _cairo_gl_context_release (r->ctx, CAIRO_STATUS_SUCCESS); +} + +static void +emit_aligned_boxes (cairo_gl_context_t *ctx, + const cairo_boxes_t *boxes) +{ + const struct _cairo_boxes_chunk *chunk; + int i; + + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x); + int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y); + int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x); + int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y); + _cairo_gl_composite_emit_rect (ctx, x1, y1, x2, y2, 0); + } + } +} + +static cairo_int_status_t +fill_boxes (void *_dst, + cairo_operator_t op, + const cairo_color_t *color, + cairo_boxes_t *boxes) +{ + cairo_gl_composite_t setup; + cairo_gl_context_t *ctx; + cairo_int_status_t status; + + status = _cairo_gl_composite_init (&setup, op, _dst, FALSE, NULL); + if (unlikely (status)) + goto FAIL; + + _cairo_gl_composite_set_solid_source (&setup, color); + + status = _cairo_gl_composite_begin (&setup, &ctx); + if (unlikely (status)) + goto FAIL; + + emit_aligned_boxes (ctx, boxes); + status = _cairo_gl_context_release (ctx, CAIRO_STATUS_SUCCESS); + +FAIL: + _cairo_gl_composite_fini (&setup); + return status; +} + +typedef struct cairo_gl_source { + cairo_surface_t base; + + cairo_gl_operand_t operand; +} cairo_gl_source_t; + +static cairo_status_t +_cairo_gl_source_finish (void *abstract_surface) +{ + cairo_gl_source_t *source = abstract_surface; + + _cairo_gl_operand_destroy (&source->operand); + return CAIRO_STATUS_SUCCESS; +} + +static const cairo_surface_backend_t cairo_gl_source_backend = { + CAIRO_SURFACE_TYPE_GL, + _cairo_gl_source_finish, + NULL, /* read-only wrapper */ +}; + +static cairo_surface_t * +pattern_to_surface (cairo_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y) +{ + cairo_gl_source_t *source; + cairo_int_status_t status; + + source = malloc (sizeof (*source)); + if (unlikely (source == NULL)) + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + + _cairo_surface_init (&source->base, + &cairo_gl_source_backend, + NULL, /* device */ + CAIRO_CONTENT_COLOR_ALPHA); + + *src_x = *src_y = 0; + status = _cairo_gl_operand_init (&source->operand, pattern, (cairo_gl_surface_t *)dst, + extents->x, extents->y, + extents->x, extents->y, + extents->width, extents->height); + if (unlikely (status)) { + cairo_surface_destroy (&source->base); + return _cairo_surface_create_in_error (status); + } + + return &source->base; +} + +static inline cairo_gl_operand_t * +source_to_operand (cairo_surface_t *surface) +{ + cairo_gl_source_t *source = (cairo_gl_source_t *)surface; + return &source->operand; +} + +static cairo_int_status_t +composite_boxes (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + cairo_boxes_t *boxes, + const cairo_rectangle_int_t *extents) +{ + cairo_gl_composite_t setup; + cairo_gl_context_t *ctx; + cairo_int_status_t status; + + status = _cairo_gl_composite_init (&setup, op, _dst, FALSE, extents); + if (unlikely (status)) + goto FAIL; + + _cairo_gl_composite_set_source_operand (&setup, + source_to_operand (abstract_src)); + + _cairo_gl_composite_set_mask_operand (&setup, + source_to_operand (abstract_mask)); + + status = _cairo_gl_composite_begin (&setup, &ctx); + if (unlikely (status)) + goto FAIL; + + emit_aligned_boxes (ctx, boxes); + status = _cairo_gl_context_release (ctx, CAIRO_STATUS_SUCCESS); + +FAIL: + _cairo_gl_composite_fini (&setup); + return status; +} + +static cairo_int_status_t +_cairo_gl_span_renderer_init (cairo_abstract_span_renderer_t *_r, + const cairo_composite_rectangles_t *composite, + cairo_bool_t needs_clip) +{ + cairo_gl_span_renderer_t *r = (cairo_gl_span_renderer_t *)_r; + const cairo_pattern_t *source = &composite->source_pattern.base; + cairo_operator_t op = composite->op; + cairo_int_status_t status; + + /* XXX earlier! */ + if (op == CAIRO_OPERATOR_CLEAR) { + source = &_cairo_pattern_white.base; + op = CAIRO_OPERATOR_DEST_OUT; + } else if (composite->surface->is_clear && + (op == CAIRO_OPERATOR_SOURCE || + op == CAIRO_OPERATOR_OVER || + op == CAIRO_OPERATOR_ADD)) { + op = CAIRO_OPERATOR_SOURCE; + } else if (op == CAIRO_OPERATOR_SOURCE) { + /* no lerp equivalent without some major PITA */ + return CAIRO_INT_STATUS_UNSUPPORTED; + } else if (! _cairo_gl_operator_is_supported (op)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + status = _cairo_gl_composite_init (&r->setup, + op, (cairo_gl_surface_t *)composite->surface, + FALSE, &composite->unbounded); + if (unlikely (status)) + goto FAIL; + + status = _cairo_gl_composite_set_source (&r->setup, source, + composite->unbounded.x, + composite->unbounded.y, + composite->unbounded.x, + composite->unbounded.y, + composite->unbounded.width, + composite->unbounded.height); + if (unlikely (status)) + goto FAIL; + + r->opacity = 1.0; + if (composite->mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID) { + r->opacity = composite->mask_pattern.solid.color.alpha; + } else { + status = _cairo_gl_composite_set_mask (&r->setup, + &composite->mask_pattern.base, + composite->unbounded.x, + composite->unbounded.y, + composite->unbounded.x, + composite->unbounded.y, + composite->unbounded.width, + composite->unbounded.height); + if (unlikely (status)) + goto FAIL; + } + + _cairo_gl_composite_set_spans (&r->setup); + + status = _cairo_gl_composite_begin (&r->setup, &r->ctx); + if (unlikely (status)) + goto FAIL; + + if (composite->is_bounded) { + if (r->opacity == 1.) + r->base.render_rows = _cairo_gl_bounded_opaque_spans; + else + r->base.render_rows = _cairo_gl_bounded_spans; + r->base.finish = _cairo_gl_finish_bounded_spans; + } else { + if (needs_clip) + r->base.render_rows = _cairo_gl_clipped_spans; + else + r->base.render_rows = _cairo_gl_unbounded_spans; + r->base.finish = _cairo_gl_finish_unbounded_spans; + r->xmin = composite->unbounded.x; + r->xmax = composite->unbounded.x + composite->unbounded.width; + r->ymin = composite->unbounded.y; + r->ymax = composite->unbounded.y + composite->unbounded.height; + } + + return CAIRO_STATUS_SUCCESS; + +FAIL: + return status; +} + +static void +_cairo_gl_span_renderer_fini (cairo_abstract_span_renderer_t *_r, + cairo_int_status_t status) +{ + cairo_gl_span_renderer_t *r = (cairo_gl_span_renderer_t *) _r; + + if (status == CAIRO_INT_STATUS_SUCCESS) + r->base.finish (r); + + _cairo_gl_composite_fini (&r->setup); +} + +const cairo_compositor_t * +_cairo_gl_span_compositor_get (void) +{ + static cairo_spans_compositor_t compositor; + + if (compositor.base.delegate == NULL) { + /* The fallback to traps here is essentially just for glyphs... */ + _cairo_spans_compositor_init (&compositor, + _cairo_gl_traps_compositor_get()); + + compositor.fill_boxes = fill_boxes; + //compositor.check_composite_boxes = check_composite_boxes; + compositor.pattern_to_surface = pattern_to_surface; + compositor.composite_boxes = composite_boxes; + //compositor.check_span_renderer = check_span_renderer; + compositor.renderer_init = _cairo_gl_span_renderer_init; + compositor.renderer_fini = _cairo_gl_span_renderer_fini; + } + + return &compositor.base; +} diff --git a/src/cairo-gl-surface.c b/src/cairo-gl-surface.c index ec708204..dec4b82a 100644 --- a/src/cairo-gl-surface.c +++ b/src/cairo-gl-surface.c @@ -43,31 +43,11 @@ #include "cairo-gl-private.h" #include "cairo-composite-rectangles-private.h" +#include "cairo-compositor-private.h" #include "cairo-default-context-private.h" #include "cairo-error-private.h" #include "cairo-image-surface-private.h" - -static cairo_int_status_t -_cairo_gl_surface_fill_rectangles (void *abstract_dst, - cairo_operator_t op, - const cairo_color_t *color, - cairo_rectangle_int_t *rects, - int num_rects); - -static cairo_int_status_t -_cairo_gl_surface_composite (cairo_operator_t op, - const cairo_pattern_t *src, - const cairo_pattern_t *mask, - void *abstract_dst, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region); +#include "cairo-surface-backend-private.h" static cairo_status_t _cairo_gl_surface_flush (void *abstract_surface); @@ -306,6 +286,9 @@ _cairo_gl_get_image_format_and_type_gl (pixman_format_code_t pixman_format, case PIXMAN_yv12: case PIXMAN_x2r10g10b10: case PIXMAN_a2r10g10b10: + case PIXMAN_r8g8b8x8: + case PIXMAN_r8g8b8a8: + case PIXMAN_x14r6g6b6: default: return FALSE; } @@ -509,10 +492,8 @@ cairo_gl_surface_create (cairo_device_t *abstract_device, if (! CAIRO_CONTENT_VALID (content)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_CONTENT)); - if (abstract_device == NULL) { - return cairo_image_surface_create (_cairo_format_from_content (content), - width, height); - } + if (abstract_device == NULL) + return _cairo_image_surface_create_with_content (content, width, height); if (abstract_device->status) return _cairo_surface_create_in_error (abstract_device->status); @@ -545,7 +526,6 @@ cairo_gl_surface_create (cairo_device_t *abstract_device, } slim_hidden_def (cairo_gl_surface_create); - /** * cairo_gl_surface_create_for_texture: * @content: type of content in the surface @@ -592,7 +572,7 @@ cairo_gl_surface_create_for_texture (cairo_device_t *abstract_device, return _cairo_surface_create_in_error (abstract_device->status); if (abstract_device->backend->type != CAIRO_DEVICE_TYPE_GL) - return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_DEVICE_TYPE_MISMATCH)); status = _cairo_gl_context_acquire (abstract_device, &ctx); if (unlikely (status)) @@ -614,20 +594,19 @@ cairo_gl_surface_set_size (cairo_surface_t *abstract_surface, int height) { cairo_gl_surface_t *surface = (cairo_gl_surface_t *) abstract_surface; - cairo_status_t status; if (unlikely (abstract_surface->status)) return; if (unlikely (abstract_surface->finished)) { - status = _cairo_surface_set_error (abstract_surface, - _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); + _cairo_surface_set_error (abstract_surface, + _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); return; } if (! _cairo_surface_is_gl (abstract_surface) || _cairo_gl_surface_is_texture (surface)) { - status = _cairo_surface_set_error (abstract_surface, - _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); + _cairo_surface_set_error (abstract_surface, + _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); return; } @@ -664,19 +643,18 @@ void cairo_gl_surface_swapbuffers (cairo_surface_t *abstract_surface) { cairo_gl_surface_t *surface = (cairo_gl_surface_t *) abstract_surface; - cairo_status_t status; if (unlikely (abstract_surface->status)) return; if (unlikely (abstract_surface->finished)) { - status = _cairo_surface_set_error (abstract_surface, - _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); + _cairo_surface_set_error (abstract_surface, + _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); return; } if (! _cairo_surface_is_gl (abstract_surface)) { - status = _cairo_surface_set_error (abstract_surface, - CAIRO_STATUS_SURFACE_TYPE_MISMATCH); + _cairo_surface_set_error (abstract_surface, + CAIRO_STATUS_SURFACE_TYPE_MISMATCH); return; } @@ -694,10 +672,20 @@ cairo_gl_surface_swapbuffers (cairo_surface_t *abstract_surface) status = _cairo_gl_context_release (ctx, status); if (status) - status = _cairo_surface_set_error (abstract_surface, status); + status = _cairo_surface_set_error (abstract_surface, status); } } +static cairo_bool_t +_cairo_gl_surface_size_valid (cairo_gl_surface_t *surface, + int width, int height) +{ + cairo_gl_context_t *ctx = (cairo_gl_context_t *)surface->base.device; + return width > 0 && height > 0 && + width <= ctx->max_framebuffer_size && + height <= ctx->max_framebuffer_size; +} + static cairo_surface_t * _cairo_gl_surface_create_similar (void *abstract_surface, cairo_content_t content, @@ -708,24 +696,15 @@ _cairo_gl_surface_create_similar (void *abstract_surface, cairo_gl_context_t *ctx; cairo_status_t status; - if (width < 1 || height < 1) - return cairo_image_surface_create (_cairo_format_from_content (content), - width, height); + if (! _cairo_gl_surface_size_valid (abstract_surface, width, height)) + return _cairo_image_surface_create_with_content (content, width, height); status = _cairo_gl_context_acquire (surface->device, &ctx); if (unlikely (status)) return _cairo_surface_create_in_error (status); - if (width > ctx->max_framebuffer_size || - height > ctx->max_framebuffer_size) - { - surface = NULL; - goto RELEASE; - } - surface = _cairo_gl_surface_create_scratch (ctx, content, width, height); -RELEASE: status = _cairo_gl_context_release (ctx, status); if (unlikely (status)) { cairo_surface_destroy (surface); @@ -735,6 +714,43 @@ RELEASE: return surface; } +static cairo_int_status_t +_cairo_gl_surface_fill_alpha_channel (void *abstract_dst, + int x, int y, + int width, int height) +{ + cairo_gl_surface_t *dst = abstract_dst; + cairo_gl_composite_t setup; + cairo_gl_context_t *ctx; + cairo_status_t status; + + _cairo_gl_composite_flush (ctx); + glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE); + + status = _cairo_gl_composite_init (&setup, CAIRO_OPERATOR_SOURCE, dst, + FALSE, NULL); + if (unlikely (status)) + goto CLEANUP; + + _cairo_gl_composite_set_solid_source (&setup, CAIRO_COLOR_BLACK); + + status = _cairo_gl_composite_begin (&setup, &ctx); + if (unlikely (status)) + goto CLEANUP; + + _cairo_gl_composite_emit_rect (ctx, x, y, x + width, y + height, 0); + + status = _cairo_gl_context_release (ctx, status); + + CLEANUP: + _cairo_gl_composite_fini (&setup); + + _cairo_gl_composite_flush (ctx); + glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + + return status; +} + cairo_status_t _cairo_gl_surface_draw_image (cairo_gl_surface_t *dst, cairo_image_surface_t *src, @@ -797,8 +813,8 @@ _cairo_gl_surface_draw_image (cairo_gl_surface_t *dst, * image data ourselves in some cases. In particular, we must extract * the pixels if: * a. we don't want full-length lines or - * b. the row stride cannot be handled by GL itself using a 4 byte alignment - * constraint + * b. the row stride cannot be handled by GL itself using a 4 byte + * alignment constraint */ if (ctx->gl_flavor == CAIRO_GL_FLAVOR_ES && (src->width * cpp < src->stride - 3 || @@ -826,7 +842,6 @@ _cairo_gl_surface_draw_image (cairo_gl_surface_t *dst, data_start_gles2 != NULL ? data_start_gles2 : data_start); - free (data_start_gles2); /* If we just treated some rgb-only data as rgba, then we have to @@ -834,21 +849,9 @@ _cairo_gl_surface_draw_image (cairo_gl_surface_t *dst, * texture data. */ if (!has_alpha) { - cairo_rectangle_int_t rect; - - rect.x = dst_x; - rect.y = dst_y; - rect.width = width; - rect.height = height; - - _cairo_gl_composite_flush (ctx); - glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE); - _cairo_gl_surface_fill_rectangles (dst, - CAIRO_OPERATOR_SOURCE, - CAIRO_COLOR_BLACK, - &rect, 1); - _cairo_gl_composite_flush (ctx); - glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + _cairo_gl_surface_fill_alpha_channel (dst, + dst_x, dst_y, + width, height); } } else { cairo_surface_t *tmp; @@ -869,15 +872,10 @@ _cairo_gl_surface_draw_image (cairo_gl_surface_t *dst, cairo_surface_pattern_t tmp_pattern; _cairo_pattern_init_for_surface (&tmp_pattern, tmp); - _cairo_gl_surface_composite (CAIRO_OPERATOR_SOURCE, - &tmp_pattern.base, - NULL, - dst, - 0, 0, - 0, 0, - dst_x, dst_y, - width, height, - NULL); + status = _cairo_surface_paint (&dst->base, + CAIRO_OPERATOR_SOURCE, + &tmp_pattern.base, + NULL); _cairo_pattern_fini (&tmp_pattern.base); } @@ -896,17 +894,53 @@ FAIL: return status; } +static int _cairo_gl_surface_flavor (cairo_gl_surface_t *surface) +{ + cairo_gl_context_t *ctx = (cairo_gl_context_t *)surface->base.device; + return ctx->gl_flavor; +} + static cairo_status_t -_cairo_gl_surface_get_image (cairo_gl_surface_t *surface, - cairo_rectangle_int_t *interest, - cairo_image_surface_t **image_out, - cairo_rectangle_int_t *rect_out) +_cairo_gl_surface_finish (void *abstract_surface) { + cairo_gl_surface_t *surface = abstract_surface; + cairo_status_t status; + cairo_gl_context_t *ctx; + + status = _cairo_gl_context_acquire (surface->base.device, &ctx); + if (unlikely (status)) + return status; + + if (ctx->operands[CAIRO_GL_TEX_SOURCE].type == CAIRO_GL_OPERAND_TEXTURE && + ctx->operands[CAIRO_GL_TEX_SOURCE].texture.surface == surface) + _cairo_gl_context_destroy_operand (ctx, CAIRO_GL_TEX_SOURCE); + if (ctx->operands[CAIRO_GL_TEX_MASK].type == CAIRO_GL_OPERAND_TEXTURE && + ctx->operands[CAIRO_GL_TEX_MASK].texture.surface == surface) + _cairo_gl_context_destroy_operand (ctx, CAIRO_GL_TEX_MASK); + if (ctx->current_target == surface) + ctx->current_target = NULL; + + if (surface->depth) + ctx->dispatch.DeleteFramebuffers (1, &surface->depth); + if (surface->fb) + ctx->dispatch.DeleteFramebuffers (1, &surface->fb); + if (surface->owns_tex) + glDeleteTextures (1, &surface->tex); + + return _cairo_gl_context_release (ctx, status); +} + +static cairo_surface_t * +_cairo_gl_surface_map_to_image (void *abstract_surface, + const cairo_rectangle_int_t *extents) +{ + cairo_gl_surface_t *surface = abstract_surface; cairo_image_surface_t *image; cairo_gl_context_t *ctx; GLenum format, type; pixman_format_code_t pixman_format; unsigned int cpp; + cairo_bool_t invert; cairo_status_t status; /* Want to use a switch statement here but the compiler gets whiny. */ @@ -927,22 +961,18 @@ _cairo_gl_surface_get_image (cairo_gl_surface_t *surface, cpp = 1; } else { ASSERT_NOT_REACHED; - return CAIRO_INT_STATUS_UNSUPPORTED; + return NULL; } - status = _cairo_gl_context_acquire (surface->base.device, &ctx); - if (unlikely (status)) - return status; - /* * GLES2 supports only RGBA, UNSIGNED_BYTE so use that. * We are also using this format for ALPHA as GLES2 does not * support GL_PACK_ROW_LENGTH anyway, and this makes sure that the * pixman image that is created has row_stride = row_width * bpp. */ - if (ctx->gl_flavor == CAIRO_GL_FLAVOR_ES) { + if (_cairo_gl_surface_flavor (surface) == CAIRO_GL_FLAVOR_ES) { format = GL_RGBA; - if (!_cairo_is_little_endian ()) { + if (! _cairo_is_little_endian ()) { if (surface->base.content == CAIRO_CONTENT_COLOR) pixman_format = PIXMAN_r8g8b8x8; else @@ -960,11 +990,20 @@ _cairo_gl_surface_get_image (cairo_gl_surface_t *surface, image = (cairo_image_surface_t*) _cairo_image_surface_create_with_pixman_format (NULL, pixman_format, - interest->width, - interest->height, + extents->width, + extents->height, -1); if (unlikely (image->base.status)) - return _cairo_gl_context_release (ctx, image->base.status); + return &image->base; + + if (surface->base.serial == 0) + return &image->base; + + status = _cairo_gl_context_acquire (surface->base.device, &ctx); + if (unlikely (status)) { + cairo_surface_destroy (&image->base); + return _cairo_surface_create_in_error (status); + } /* This is inefficient, as we'd rather just read the thing without making * it the destination. But then, this is the fallback path, so let's not @@ -973,60 +1012,28 @@ _cairo_gl_surface_get_image (cairo_gl_surface_t *surface, _cairo_gl_composite_flush (ctx); _cairo_gl_context_set_destination (ctx, surface); + invert = ! _cairo_gl_surface_is_texture (surface) && + ctx->has_mesa_pack_invert; + glPixelStorei (GL_PACK_ALIGNMENT, 4); if (ctx->gl_flavor == CAIRO_GL_FLAVOR_DESKTOP) glPixelStorei (GL_PACK_ROW_LENGTH, image->stride / cpp); - if (! _cairo_gl_surface_is_texture (surface) && - ctx->has_mesa_pack_invert) + if (invert) glPixelStorei (GL_PACK_INVERT_MESA, 1); - glReadPixels (interest->x, interest->y, - interest->width, interest->height, + glReadPixels (extents->x, extents->y, + extents->width, extents->height, format, type, image->data); - if (! _cairo_gl_surface_is_texture (surface) && - ctx->has_mesa_pack_invert) + if (invert) glPixelStorei (GL_PACK_INVERT_MESA, 0); status = _cairo_gl_context_release (ctx, status); if (unlikely (status)) { cairo_surface_destroy (&image->base); - return status; + image = (cairo_image_surface_t *) + _cairo_surface_create_in_error (status); } - *image_out = image; - if (rect_out != NULL) - *rect_out = *interest; - - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_cairo_gl_surface_finish (void *abstract_surface) -{ - cairo_gl_surface_t *surface = abstract_surface; - cairo_status_t status; - cairo_gl_context_t *ctx; - - status = _cairo_gl_context_acquire (surface->base.device, &ctx); - if (unlikely (status)) - return status; - - if (ctx->operands[CAIRO_GL_TEX_SOURCE].type == CAIRO_GL_OPERAND_TEXTURE && - ctx->operands[CAIRO_GL_TEX_SOURCE].texture.surface == surface) - _cairo_gl_context_destroy_operand (ctx, CAIRO_GL_TEX_SOURCE); - if (ctx->operands[CAIRO_GL_TEX_MASK].type == CAIRO_GL_OPERAND_TEXTURE && - ctx->operands[CAIRO_GL_TEX_MASK].texture.surface == surface) - _cairo_gl_context_destroy_operand (ctx, CAIRO_GL_TEX_MASK); - if (ctx->current_target == surface) - ctx->current_target = NULL; - - if (surface->depth) - ctx->dispatch.DeleteFramebuffers (1, &surface->depth); - if (surface->fb) - ctx->dispatch.DeleteFramebuffers (1, &surface->fb); - if (surface->owns_tex) - glDeleteTextures (1, &surface->tex); - - return _cairo_gl_context_release (ctx, status); + return &image->base; } static cairo_status_t @@ -1042,7 +1049,10 @@ _cairo_gl_surface_acquire_source_image (void *abstract_surface, extents.x = extents.y = 0; extents.width = surface->width; extents.height = surface->height; - return _cairo_gl_surface_get_image (surface, &extents, image_out, NULL); + + *image_out = (cairo_image_surface_t *) + _cairo_gl_surface_map_to_image (surface, &extents); + return (*image_out)->base.status; } static void @@ -1053,536 +1063,18 @@ _cairo_gl_surface_release_source_image (void *abstract_surface, cairo_surface_destroy (&image->base); } -static cairo_status_t -_cairo_gl_surface_acquire_dest_image (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t **image_out, - cairo_rectangle_int_t *image_rect_out, - void **image_extra) -{ - cairo_gl_surface_t *surface = abstract_surface; - - *image_extra = NULL; - return _cairo_gl_surface_get_image (surface, interest_rect, image_out, - image_rect_out); -} - -static void -_cairo_gl_surface_release_dest_image (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t *image, - cairo_rectangle_int_t *image_rect, - void *image_extra) -{ - cairo_status_t status; - - status = _cairo_gl_surface_draw_image (abstract_surface, image, - 0, 0, - image->width, image->height, - image_rect->x, image_rect->y); - /* as we created the image, its format should be directly applicable */ - assert (status == CAIRO_STATUS_SUCCESS); - - cairo_surface_destroy (&image->base); -} - -static cairo_status_t -_cairo_gl_surface_clone_similar (void *abstract_surface, - cairo_surface_t *src, - int src_x, - int src_y, - int width, - int height, - int *clone_offset_x, - int *clone_offset_y, - cairo_surface_t **clone_out) -{ - cairo_gl_surface_t *surface = abstract_surface; - - /* XXX: Use GLCopyTexImage2D to clone non-texture-surfaces */ - if (src->device == surface->base.device && - _cairo_gl_surface_is_texture ((cairo_gl_surface_t *) src)) { - *clone_offset_x = 0; - *clone_offset_y = 0; - *clone_out = cairo_surface_reference (src); - - return CAIRO_STATUS_SUCCESS; - } else if (_cairo_surface_is_image (src)) { - cairo_image_surface_t *image_src = (cairo_image_surface_t *)src; - cairo_gl_surface_t *clone; - cairo_status_t status; - - clone = (cairo_gl_surface_t *) - _cairo_gl_surface_create_similar (&surface->base, - src->content, - width, height); - if (clone == NULL) - return UNSUPPORTED ("create_similar failed"); - if (clone->base.status) - return clone->base.status; - - status = _cairo_gl_surface_draw_image (clone, image_src, - src_x, src_y, - width, height, - 0, 0); - if (status) { - cairo_surface_destroy (&clone->base); - return status; - } - - *clone_out = &clone->base; - *clone_offset_x = src_x; - *clone_offset_y = src_y; - - return CAIRO_STATUS_SUCCESS; - } - - return UNSUPPORTED ("unknown src surface type in clone_similar"); -} - -/** Creates a cairo-gl pattern surface for the given trapezoids */ -static cairo_status_t -_cairo_gl_get_traps_pattern (cairo_gl_surface_t *dst, - int dst_x, int dst_y, - int width, int height, - cairo_trapezoid_t *traps, - int num_traps, - cairo_antialias_t antialias, - cairo_surface_pattern_t *pattern) -{ - pixman_format_code_t pixman_format; - pixman_image_t *image; - cairo_surface_t *surface; - int i; - - pixman_format = antialias != CAIRO_ANTIALIAS_NONE ? PIXMAN_a8 : PIXMAN_a1, - image = pixman_image_create_bits (pixman_format, width, height, NULL, 0); - if (unlikely (image == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - for (i = 0; i < num_traps; i++) { - pixman_trapezoid_t trap; - - trap.top = _cairo_fixed_to_16_16 (traps[i].top); - trap.bottom = _cairo_fixed_to_16_16 (traps[i].bottom); - - trap.left.p1.x = _cairo_fixed_to_16_16 (traps[i].left.p1.x); - trap.left.p1.y = _cairo_fixed_to_16_16 (traps[i].left.p1.y); - trap.left.p2.x = _cairo_fixed_to_16_16 (traps[i].left.p2.x); - trap.left.p2.y = _cairo_fixed_to_16_16 (traps[i].left.p2.y); - - trap.right.p1.x = _cairo_fixed_to_16_16 (traps[i].right.p1.x); - trap.right.p1.y = _cairo_fixed_to_16_16 (traps[i].right.p1.y); - trap.right.p2.x = _cairo_fixed_to_16_16 (traps[i].right.p2.x); - trap.right.p2.y = _cairo_fixed_to_16_16 (traps[i].right.p2.y); - - pixman_rasterize_trapezoid (image, &trap, -dst_x, -dst_y); - } - - surface = _cairo_image_surface_create_for_pixman_image (image, - pixman_format); - if (unlikely (surface->status)) { - pixman_image_unref (image); - return surface->status; - } - - _cairo_pattern_init_for_surface (pattern, surface); - cairo_surface_destroy (surface); - - return CAIRO_STATUS_SUCCESS; -} - static cairo_int_status_t -_cairo_gl_surface_composite (cairo_operator_t op, - const cairo_pattern_t *src, - const cairo_pattern_t *mask, - void *abstract_dst, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region) +_cairo_gl_surface_unmap_image (void *abstract_surface, + cairo_image_surface_t *image) { - cairo_gl_surface_t *dst = abstract_dst; - cairo_gl_context_t *ctx; - cairo_int_status_t status; - cairo_gl_composite_t setup; - cairo_rectangle_int_t rect = { dst_x, dst_y, width, height }; - int dx, dy; - - if (op == CAIRO_OPERATOR_SOURCE && - mask == NULL && - src->type == CAIRO_PATTERN_TYPE_SURFACE && - _cairo_surface_is_image (((cairo_surface_pattern_t *) src)->surface) && - _cairo_matrix_is_integer_translation (&src->matrix, &dx, &dy)) { - cairo_image_surface_t *image = (cairo_image_surface_t *) - ((cairo_surface_pattern_t *) src)->surface; - dx += src_x; - dy += src_y; - if (dx >= 0 && - dy >= 0 && - dx + width <= (unsigned int) image->width && - dy + height <= (unsigned int) image->height) { - status = _cairo_gl_surface_draw_image (dst, image, - dx, dy, - width, height, - dst_x, dst_y); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - } - } - - status = _cairo_gl_composite_init (&setup, op, dst, - mask && mask->has_component_alpha, - &rect); - if (unlikely (status)) - goto CLEANUP; - - status = _cairo_gl_composite_set_source (&setup, src, - src_x, src_y, - dst_x, dst_y, - width, height); - if (unlikely (status)) - goto CLEANUP; - - status = _cairo_gl_composite_set_mask (&setup, mask, - mask_x, mask_y, - dst_x, dst_y, - width, height); - if (unlikely (status)) - goto CLEANUP; - - status = _cairo_gl_composite_begin (&setup, &ctx); - if (unlikely (status)) - goto CLEANUP; - - if (clip_region != NULL) { - int i, num_rectangles; - - num_rectangles = cairo_region_num_rectangles (clip_region); - - for (i = 0; i < num_rectangles; i++) { - cairo_rectangle_int_t rect; - - cairo_region_get_rectangle (clip_region, i, &rect); - _cairo_gl_composite_emit_rect (ctx, - rect.x, rect.y, - rect.x + rect.width, rect.y + rect.height, - 0); - } - } else { - _cairo_gl_composite_emit_rect (ctx, - dst_x, dst_y, - dst_x + width, dst_y + height, - 0); - } - - status = _cairo_gl_context_release (ctx, status); - - CLEANUP: - _cairo_gl_composite_fini (&setup); - - return status; -} - -static cairo_int_status_t -_cairo_gl_surface_composite_trapezoids (cairo_operator_t op, - const cairo_pattern_t *pattern, - void *abstract_dst, - cairo_antialias_t antialias, - int src_x, int src_y, - int dst_x, int dst_y, - unsigned int width, - unsigned int height, - cairo_trapezoid_t *traps, - int num_traps, - cairo_region_t *clip_region) -{ - cairo_gl_surface_t *dst = abstract_dst; - cairo_surface_pattern_t traps_pattern; - cairo_int_status_t status; - - if (! _cairo_gl_operator_is_supported (op)) - return UNSUPPORTED ("unsupported operator"); - - status = _cairo_gl_get_traps_pattern (dst, - dst_x, dst_y, width, height, - traps, num_traps, antialias, - &traps_pattern); - if (unlikely (status)) - return status; - - status = _cairo_gl_surface_composite (op, - pattern, &traps_pattern.base, dst, - src_x, src_y, - 0, 0, - dst_x, dst_y, - width, height, - clip_region); - - _cairo_pattern_fini (&traps_pattern.base); - - assert (status != CAIRO_INT_STATUS_UNSUPPORTED); - return status; -} - -static cairo_int_status_t -_cairo_gl_surface_fill_rectangles (void *abstract_dst, - cairo_operator_t op, - const cairo_color_t *color, - cairo_rectangle_int_t *rects, - int num_rects) -{ - cairo_gl_surface_t *dst = abstract_dst; - cairo_solid_pattern_t solid; - cairo_gl_context_t *ctx; - cairo_status_t status; - cairo_gl_composite_t setup; - int i; - - status = _cairo_gl_composite_init (&setup, op, dst, - FALSE, - /* XXX */ NULL); - if (unlikely (status)) - goto CLEANUP; - - _cairo_pattern_init_solid (&solid, color); - status = _cairo_gl_composite_set_source (&setup, &solid.base, - 0, 0, - 0, 0, - 0, 0); - if (unlikely (status)) - goto CLEANUP; - - status = _cairo_gl_composite_set_mask (&setup, NULL, - 0, 0, - 0, 0, - 0, 0); - if (unlikely (status)) - goto CLEANUP; - - status = _cairo_gl_composite_begin (&setup, &ctx); - if (unlikely (status)) - goto CLEANUP; - - for (i = 0; i < num_rects; i++) { - _cairo_gl_composite_emit_rect (ctx, - rects[i].x, - rects[i].y, - rects[i].x + rects[i].width, - rects[i].y + rects[i].height, - 0); - } - - status = _cairo_gl_context_release (ctx, status); - - CLEANUP: - _cairo_gl_composite_fini (&setup); - - return status; -} - -typedef struct _cairo_gl_surface_span_renderer { - cairo_span_renderer_t base; - - cairo_gl_composite_t setup; - - int xmin, xmax; - int ymin, ymax; - - cairo_gl_context_t *ctx; -} cairo_gl_surface_span_renderer_t; - -static cairo_status_t -_cairo_gl_render_bounded_spans (void *abstract_renderer, - int y, int height, - const cairo_half_open_span_t *spans, - unsigned num_spans) -{ - cairo_gl_surface_span_renderer_t *renderer = abstract_renderer; - - if (num_spans == 0) - return CAIRO_STATUS_SUCCESS; - - do { - if (spans[0].coverage) { - _cairo_gl_composite_emit_rect (renderer->ctx, - spans[0].x, y, - spans[1].x, y + height, - spans[0].coverage); - } - - spans++; - } while (--num_spans > 1); - - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_cairo_gl_render_unbounded_spans (void *abstract_renderer, - int y, int height, - const cairo_half_open_span_t *spans, - unsigned num_spans) -{ - cairo_gl_surface_span_renderer_t *renderer = abstract_renderer; - - if (y > renderer->ymin) { - _cairo_gl_composite_emit_rect (renderer->ctx, - renderer->xmin, renderer->ymin, - renderer->xmax, y, - 0); - } - - if (num_spans == 0) { - _cairo_gl_composite_emit_rect (renderer->ctx, - renderer->xmin, y, - renderer->xmax, y + height, - 0); - } else { - if (spans[0].x != renderer->xmin) { - _cairo_gl_composite_emit_rect (renderer->ctx, - renderer->xmin, y, - spans[0].x, y + height, - 0); - } - - do { - _cairo_gl_composite_emit_rect (renderer->ctx, - spans[0].x, y, - spans[1].x, y + height, - spans[0].coverage); - spans++; - } while (--num_spans > 1); - - if (spans[0].x != renderer->xmax) { - _cairo_gl_composite_emit_rect (renderer->ctx, - spans[0].x, y, - renderer->xmax, y + height, - 0); - } - } - - renderer->ymin = y + height; - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_cairo_gl_finish_unbounded_spans (void *abstract_renderer) -{ - cairo_gl_surface_span_renderer_t *renderer = abstract_renderer; - - if (renderer->ymax > renderer->ymin) { - _cairo_gl_composite_emit_rect (renderer->ctx, - renderer->xmin, renderer->ymin, - renderer->xmax, renderer->ymax, - 0); - } - - return _cairo_gl_context_release (renderer->ctx, CAIRO_STATUS_SUCCESS); -} - -static cairo_status_t -_cairo_gl_finish_bounded_spans (void *abstract_renderer) -{ - cairo_gl_surface_span_renderer_t *renderer = abstract_renderer; - - return _cairo_gl_context_release (renderer->ctx, CAIRO_STATUS_SUCCESS); -} - -static void -_cairo_gl_surface_span_renderer_destroy (void *abstract_renderer) -{ - cairo_gl_surface_span_renderer_t *renderer = abstract_renderer; - - if (!renderer) - return; - - _cairo_gl_composite_fini (&renderer->setup); - - free (renderer); + return _cairo_gl_surface_draw_image (abstract_surface, image, + 0, 0, + image->width, image->height, + image->base.device_transform_inverse.x0, + image->base.device_transform_inverse.y0); } static cairo_bool_t -_cairo_gl_surface_check_span_renderer (cairo_operator_t op, - const cairo_pattern_t *pattern, - void *abstract_dst, - cairo_antialias_t antialias) -{ - if (! _cairo_gl_operator_is_supported (op)) - return FALSE; - - return TRUE; - - (void) pattern; - (void) abstract_dst; - (void) antialias; -} - -static cairo_span_renderer_t * -_cairo_gl_surface_create_span_renderer (cairo_operator_t op, - const cairo_pattern_t *src, - void *abstract_dst, - cairo_antialias_t antialias, - const cairo_composite_rectangles_t *rects, - cairo_region_t *clip_region) -{ - cairo_gl_surface_t *dst = abstract_dst; - cairo_gl_surface_span_renderer_t *renderer; - cairo_status_t status; - const cairo_rectangle_int_t *extents; - - renderer = calloc (1, sizeof (*renderer)); - if (unlikely (renderer == NULL)) - return _cairo_span_renderer_create_in_error (CAIRO_STATUS_NO_MEMORY); - - renderer->base.destroy = _cairo_gl_surface_span_renderer_destroy; - if (rects->is_bounded) { - renderer->base.render_rows = _cairo_gl_render_bounded_spans; - renderer->base.finish = _cairo_gl_finish_bounded_spans; - extents = &rects->bounded; - } else { - renderer->base.render_rows = _cairo_gl_render_unbounded_spans; - renderer->base.finish = _cairo_gl_finish_unbounded_spans; - extents = &rects->unbounded; - } - renderer->xmin = extents->x; - renderer->xmax = extents->x + extents->width; - renderer->ymin = extents->y; - renderer->ymax = extents->y + extents->height; - - status = _cairo_gl_composite_init (&renderer->setup, - op, dst, - FALSE, extents); - if (unlikely (status)) - goto FAIL; - - status = _cairo_gl_composite_set_source (&renderer->setup, src, - extents->x, extents->y, - extents->x, extents->y, - extents->width, extents->height); - if (unlikely (status)) - goto FAIL; - - _cairo_gl_composite_set_mask_spans (&renderer->setup); - _cairo_gl_composite_set_clip_region (&renderer->setup, clip_region); - - status = _cairo_gl_composite_begin (&renderer->setup, &renderer->ctx); - if (unlikely (status)) - goto FAIL; - - return &renderer->base; - -FAIL: - _cairo_gl_composite_fini (&renderer->setup); - free (renderer); - return _cairo_span_renderer_create_in_error (status); -} - -cairo_bool_t _cairo_gl_surface_get_extents (void *abstract_surface, cairo_rectangle_int_t *rectangle) { @@ -1596,16 +1088,6 @@ _cairo_gl_surface_get_extents (void *abstract_surface, return TRUE; } -static void -_cairo_gl_surface_get_font_options (void *abstract_surface, - cairo_font_options_t *options) -{ - _cairo_font_options_init_default (options); - - cairo_font_options_set_hint_metrics (options, CAIRO_HINT_METRICS_ON); - _cairo_font_options_set_round_glyph_positions (options, CAIRO_ROUND_GLYPH_POS_ON); -} - static cairo_status_t _cairo_gl_surface_flush (void *abstract_surface) { @@ -1627,18 +1109,20 @@ _cairo_gl_surface_flush (void *abstract_surface) return _cairo_gl_context_release (ctx, status); } +static const cairo_compositor_t * +get_compositor (cairo_gl_surface_t *surface) +{ + cairo_gl_context_t *ctx = (cairo_gl_context_t *)surface->base.device; + return ctx->compositor; +} + static cairo_int_status_t -_cairo_gl_surface_paint (void *abstract_surface, +_cairo_gl_surface_paint (void *surface, cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_clip_t *clip) + const cairo_pattern_t *source, + const cairo_clip_t *clip) { - cairo_gl_surface_t *surface = abstract_surface; - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; - cairo_boxes_t boxes; - cairo_status_t status; - +#if 0 /* simplify the common case of clearing the surface */ if (clip == NULL) { if (op == CAIRO_OPERATOR_CLEAR) @@ -1650,93 +1134,43 @@ _cairo_gl_surface_paint (void *abstract_surface, &((cairo_solid_pattern_t *) source)->color); } } +#endif - _cairo_gl_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_paint (&extents, &unbounded, - op, source, - clip); - if (unlikely (status)) - return status; - - status = _cairo_clip_to_boxes(extents.clip, &boxes); - if (likely (status == CAIRO_STATUS_SUCCESS)) { - status = _cairo_gl_clip_and_composite_boxes (surface, op, source, - &boxes, &extents); - } - - _cairo_composite_rectangles_fini (&extents); + return _cairo_compositor_paint (get_compositor (surface), surface, + op, source, clip); +} - return status; +static cairo_int_status_t +_cairo_gl_surface_mask (void *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_pattern_t *mask, + const cairo_clip_t *clip) +{ + return _cairo_compositor_mask (get_compositor (surface), surface, + op, source, mask, clip); } static cairo_int_status_t -_cairo_gl_surface_stroke (void *abstract_surface, +_cairo_gl_surface_stroke (void *surface, cairo_operator_t op, const cairo_pattern_t *source, - const cairo_path_fixed_t *path, + 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) + const cairo_clip_t *clip) { - cairo_gl_surface_t *surface = abstract_surface; - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; - cairo_int_status_t status; - - _cairo_gl_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_stroke (&extents, - &unbounded, - op, source, - path, style, ctm, - clip); - if (unlikely (status)) - return status; - - status = CAIRO_INT_STATUS_UNSUPPORTED; - if (_cairo_path_fixed_stroke_is_rectilinear (path)) { - cairo_boxes_t boxes; - - _cairo_boxes_init_with_clip (&boxes, extents.clip); - status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path, - style, - ctm, - antialias, - &boxes); - if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { - status = _cairo_gl_clip_and_composite_boxes (surface, op, source, - &boxes, &extents); - } - _cairo_boxes_fini (&boxes); - } - - - if (status == CAIRO_INT_STATUS_UNSUPPORTED) { - cairo_polygon_t polygon; - - _cairo_polygon_init_with_clip (&polygon, extents.clip); - status = _cairo_path_fixed_stroke_to_polygon (path, - style, - ctm, ctm_inverse, - tolerance, - &polygon); - if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { - status = _cairo_gl_surface_polygon (surface, op, source, &polygon, - CAIRO_FILL_RULE_WINDING, antialias, - &extents); - } - _cairo_polygon_fini (&polygon); - } - - _cairo_composite_rectangles_fini (&extents); - - return status; + return _cairo_compositor_stroke (get_compositor (surface), surface, + op, source, path, style, + ctm, ctm_inverse, tolerance, antialias, + clip); } static cairo_int_status_t -_cairo_gl_surface_fill (void *abstract_surface, +_cairo_gl_surface_fill (void *surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_path_fixed_t*path, @@ -1745,51 +1179,24 @@ _cairo_gl_surface_fill (void *abstract_surface, cairo_antialias_t antialias, const cairo_clip_t *clip) { - cairo_gl_surface_t *surface = abstract_surface; - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; - cairo_int_status_t status; - - _cairo_gl_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_fill (&extents, - &unbounded, - op, source, path, - clip); - if (unlikely (status)) - return status; - - status = CAIRO_INT_STATUS_UNSUPPORTED; - if (_cairo_path_fixed_fill_is_rectilinear (path)) { - cairo_boxes_t boxes; - - _cairo_boxes_init_with_clip (&boxes, extents.clip); - status = _cairo_path_fixed_fill_rectilinear_to_boxes (path, - fill_rule, - antialias, - &boxes); - if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { - status = _cairo_gl_clip_and_composite_boxes (surface, op, source, - &boxes, &extents); - } - _cairo_boxes_fini (&boxes); - } - - if (status == CAIRO_INT_STATUS_UNSUPPORTED) { - cairo_polygon_t polygon; - - _cairo_polygon_init_with_clip (&polygon, extents.clip); - status = _cairo_path_fixed_fill_to_polygon (path, tolerance, &polygon); - if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { - status = _cairo_gl_surface_polygon (surface, op, source, &polygon, - fill_rule, antialias, - &extents); - } - _cairo_polygon_fini (&polygon); - } - - _cairo_composite_rectangles_fini (&extents); + return _cairo_compositor_fill (get_compositor (surface), surface, + op, source, path, + fill_rule, tolerance, antialias, + clip); +} - return status; +static cairo_int_status_t +_cairo_gl_surface_glyphs (void *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + cairo_glyph_t *glyphs, + int num_glyphs, + cairo_scaled_font_t *font, + const cairo_clip_t *clip) +{ + return _cairo_compositor_glyphs (get_compositor (surface), surface, + op, source, glyphs, num_glyphs, font, + clip); } const cairo_surface_backend_t _cairo_gl_surface_backend = { @@ -1799,34 +1206,26 @@ const cairo_surface_backend_t _cairo_gl_surface_backend = { _cairo_gl_surface_create_similar, NULL, /* similar image */ - NULL, /* map to image */ - NULL, /* unmap image */ + _cairo_gl_surface_map_to_image, + _cairo_gl_surface_unmap_image, _cairo_gl_surface_acquire_source_image, _cairo_gl_surface_release_source_image, - _cairo_gl_surface_acquire_dest_image, - _cairo_gl_surface_release_dest_image, - - _cairo_gl_surface_clone_similar, - _cairo_gl_surface_composite, - _cairo_gl_surface_fill_rectangles, - _cairo_gl_surface_composite_trapezoids, - _cairo_gl_surface_create_span_renderer, - _cairo_gl_surface_check_span_renderer, + NULL, /* snapshot */ NULL, /* copy_page */ NULL, /* show_page */ + _cairo_gl_surface_get_extents, - NULL, /* old_show_glyphs */ - _cairo_gl_surface_get_font_options, + _cairo_image_surface_get_font_options, + _cairo_gl_surface_flush, NULL, /* mark_dirty_rectangle */ - _cairo_gl_surface_scaled_font_fini, - _cairo_gl_surface_scaled_glyph_fini, + _cairo_gl_surface_paint, - NULL, /* mask */ + _cairo_gl_surface_mask, _cairo_gl_surface_stroke, _cairo_gl_surface_fill, - _cairo_gl_surface_show_glyphs, /* show_glyphs */ - NULL /* snapshot */ + NULL, /* fill/stroke */ + _cairo_gl_surface_glyphs, }; diff --git a/src/cairo-gl-traps-compositor.c b/src/cairo-gl-traps-compositor.c new file mode 100644 index 00000000..afc74d0e --- /dev/null +++ b/src/cairo-gl-traps-compositor.c @@ -0,0 +1,550 @@ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2009 Eric Anholt + * Copyright © 2009 Chris Wilson + * Copyright © 2005,2010 Red Hat, Inc + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is Red Hat, Inc. + * + * Contributor(s): + * Benjamin Otte <otte@gnome.org> + * Carl Worth <cworth@cworth.org> + * Chris Wilson <chris@chris-wilson.co.uk> + * Eric Anholt <eric@anholt.net> + */ + +#include "cairoint.h" + +#include "cairo-gl-private.h" + +#include "cairo-composite-rectangles-private.h" +#include "cairo-compositor-private.h" +#include "cairo-default-context-private.h" +#include "cairo-error-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-spans-compositor-private.h" +#include "cairo-surface-backend-private.h" + +static cairo_int_status_t +acquire (void *abstract_dst) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +release (void *abstract_dst) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +set_clip_region (void *_surface, + cairo_region_t *region) +{ + cairo_gl_surface_t *surface = _surface; + + //surface->clip_region = region; + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +draw_image_boxes (void *_dst, + cairo_image_surface_t *image, + cairo_boxes_t *boxes, + int dx, int dy) +{ + cairo_gl_surface_t *dst = _dst; + struct _cairo_boxes_chunk *chunk; + int i; + + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + cairo_box_t *b = &chunk->base[i]; + int x = _cairo_fixed_integer_part (b->p1.x); + int y = _cairo_fixed_integer_part (b->p1.y); + int w = _cairo_fixed_integer_part (b->p2.x) - x; + int h = _cairo_fixed_integer_part (b->p2.y) - y; + cairo_status_t status; + + status = _cairo_gl_surface_draw_image (dst, image, + x + dx, y + dy, + w, h, + x, y); + if (unlikely (status)) + return status; + } + } + + return CAIRO_STATUS_SUCCESS; +} + +static void +emit_aligned_boxes (cairo_gl_context_t *ctx, + const cairo_boxes_t *boxes) +{ + const struct _cairo_boxes_chunk *chunk; + int i; + + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x); + int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y); + int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x); + int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y); + _cairo_gl_composite_emit_rect (ctx, x1, y1, x2, y2, 0); + } + } +} + +static cairo_int_status_t +fill_boxes (void *_dst, + cairo_operator_t op, + const cairo_color_t *color, + cairo_boxes_t *boxes) +{ + cairo_gl_composite_t setup; + cairo_gl_context_t *ctx; + cairo_int_status_t status; + + status = _cairo_gl_composite_init (&setup, op, _dst, FALSE, NULL); + if (unlikely (status)) + goto FAIL; + + _cairo_gl_composite_set_solid_source (&setup, color); + + status = _cairo_gl_composite_begin (&setup, &ctx); + if (unlikely (status)) + goto FAIL; + + emit_aligned_boxes (ctx, boxes); + status = _cairo_gl_context_release (ctx, CAIRO_STATUS_SUCCESS); + +FAIL: + _cairo_gl_composite_fini (&setup); + return status; +} + +typedef struct cairo_gl_source { + cairo_surface_t base; + + cairo_gl_operand_t operand; +} cairo_gl_source_t; + +static cairo_status_t +_cairo_gl_source_finish (void *abstract_surface) +{ + cairo_gl_source_t *source = abstract_surface; + + _cairo_gl_operand_destroy (&source->operand); + return CAIRO_STATUS_SUCCESS; +} + +static const cairo_surface_backend_t cairo_gl_source_backend = { + CAIRO_SURFACE_TYPE_GL, + _cairo_gl_source_finish, + NULL, /* read-only wrapper */ +}; + +static cairo_surface_t * +pattern_to_surface (cairo_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y) +{ + cairo_gl_source_t *source; + cairo_int_status_t status; + + source = malloc (sizeof (*source)); + if (unlikely (source == NULL)) + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + + _cairo_surface_init (&source->base, + &cairo_gl_source_backend, + NULL, /* device */ + CAIRO_CONTENT_COLOR_ALPHA); + + *src_x = *src_y = 0; + status = _cairo_gl_operand_init (&source->operand, pattern, (cairo_gl_surface_t *)dst, + extents->x, extents->y, + extents->x, extents->y, + extents->width, extents->height); + if (unlikely (status)) { + cairo_surface_destroy (&source->base); + return _cairo_surface_create_in_error (status); + } + + return &source->base; +} + +static inline cairo_gl_operand_t * +source_to_operand (cairo_surface_t *surface) +{ + cairo_gl_source_t *source = (cairo_gl_source_t *)surface; + return &source->operand; +} + +static cairo_int_status_t +composite_boxes (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + cairo_boxes_t *boxes, + const cairo_rectangle_int_t *extents) +{ + cairo_gl_composite_t setup; + cairo_gl_context_t *ctx; + cairo_int_status_t status; + + status = _cairo_gl_composite_init (&setup, op, _dst, FALSE, extents); + if (unlikely (status)) + goto FAIL; + + _cairo_gl_composite_set_source_operand (&setup, + source_to_operand (abstract_src)); + + _cairo_gl_composite_set_mask_operand (&setup, + source_to_operand (abstract_mask)); + + status = _cairo_gl_composite_begin (&setup, &ctx); + if (unlikely (status)) + goto FAIL; + + emit_aligned_boxes (ctx, boxes); + status = _cairo_gl_context_release (ctx, CAIRO_STATUS_SUCCESS); + +FAIL: + _cairo_gl_composite_fini (&setup); + return status; +} + +static cairo_int_status_t +composite (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height) +{ + cairo_gl_composite_t setup; + cairo_gl_context_t *ctx; + cairo_int_status_t status; + + status = _cairo_gl_composite_init (&setup, op, _dst, FALSE, NULL); + if (unlikely (status)) + goto FAIL; + + _cairo_gl_composite_set_source_operand (&setup, + source_to_operand (abstract_src)); + + _cairo_gl_composite_set_mask_operand (&setup, + source_to_operand (abstract_mask)); + + status = _cairo_gl_composite_begin (&setup, &ctx); + if (unlikely (status)) + goto FAIL; + + /* XXX clip */ + _cairo_gl_composite_emit_rect (ctx, dst_x, dst_y, dst_x+width, dst_y+height, 0); + status = _cairo_gl_context_release (ctx, CAIRO_STATUS_SUCCESS); + +FAIL: + _cairo_gl_composite_fini (&setup); + return status; +} + +static cairo_int_status_t +lerp (void *dst, + cairo_surface_t *src, + cairo_surface_t *mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height) +{ + cairo_int_status_t status; + + /* we could avoid some repetition... */ + status = composite (dst, CAIRO_OPERATOR_DEST_OUT, src, mask, + src_x, src_y, + mask_x, mask_y, + dst_x, dst_y, + width, height); + if (unlikely (status)) + return status; + + status = composite (dst, CAIRO_OPERATOR_ADD, src, mask, + src_x, src_y, + mask_x, mask_y, + dst_x, dst_y, + width, height); + if (unlikely (status)) + return status; + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_gl_surface_t * +traps_to_surface (void *_dst, + const cairo_rectangle_int_t *extents, + cairo_antialias_t antialias, + cairo_traps_t *traps) +{ + pixman_format_code_t pixman_format; + pixman_image_t *pixman_image; + cairo_surface_t *image, *mask; + cairo_status_t status; + + pixman_format = antialias != CAIRO_ANTIALIAS_NONE ? PIXMAN_a8 : PIXMAN_a1, + pixman_image = pixman_image_create_bits (pixman_format, + extents->width, + extents->height, + NULL, 0); + if (unlikely (pixman_image == NULL)) + return (cairo_gl_surface_t *)_cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + + _pixman_image_add_traps (pixman_image, extents->x, extents->y, traps); + image = _cairo_image_surface_create_for_pixman_image (pixman_image, + pixman_format); + if (unlikely (image->status)) { + pixman_image_unref (pixman_image); + return (cairo_gl_surface_t *)image; + } + + mask = _cairo_surface_create_similar_scratch (_dst, CAIRO_CONTENT_ALPHA, + extents->width, + extents->height); + if (unlikely (mask->status)) { + cairo_surface_destroy (image); + return (cairo_gl_surface_t *)mask; + } + + status = _cairo_gl_surface_draw_image ((cairo_gl_surface_t *)mask, + (cairo_image_surface_t *)image, + 0, 0, + extents->width, extents->height, + 0, 0); + cairo_surface_destroy (image); + if (unlikely (status)) { + cairo_surface_destroy (mask); + return (cairo_gl_surface_t*)_cairo_surface_create_in_error (status); + } + + return (cairo_gl_surface_t*)mask; +} + +static cairo_int_status_t +composite_traps (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_antialias_t antialias, + cairo_traps_t *traps) +{ + cairo_gl_composite_t setup; + cairo_gl_context_t *ctx; + cairo_gl_surface_t *mask; + cairo_int_status_t status; + + mask = traps_to_surface (_dst, extents, antialias, traps); + if (unlikely (mask->base.status)) + return mask->base.status; + + status = _cairo_gl_composite_init (&setup, op, _dst, FALSE, NULL); + if (unlikely (status)) + goto FAIL; + + _cairo_gl_composite_set_source_operand (&setup, + source_to_operand (abstract_src)); + + //_cairo_gl_composite_set_mask_surface (&setup, mask, 0, 0); + + status = _cairo_gl_composite_begin (&setup, &ctx); + if (unlikely (status)) + goto FAIL; + + /* XXX clip */ + _cairo_gl_composite_emit_rect (ctx, + dst_x, dst_y, + dst_x+extents->width, + dst_y+extents->height, 0); + status = _cairo_gl_context_release (ctx, CAIRO_STATUS_SUCCESS); + +FAIL: + _cairo_gl_composite_fini (&setup); + cairo_surface_destroy (&mask->base); + return status; +} + +static cairo_gl_surface_t * +tristrip_to_surface (void *_dst, + const cairo_rectangle_int_t *extents, + cairo_antialias_t antialias, + cairo_tristrip_t *strip) +{ + pixman_format_code_t pixman_format; + pixman_image_t *pixman_image; + cairo_surface_t *image, *mask; + cairo_status_t status; + + pixman_format = antialias != CAIRO_ANTIALIAS_NONE ? PIXMAN_a8 : PIXMAN_a1, + pixman_image = pixman_image_create_bits (pixman_format, + extents->width, + extents->height, + NULL, 0); + if (unlikely (pixman_image == NULL)) + return (cairo_gl_surface_t *)_cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + + _pixman_image_add_tristrip (pixman_image, extents->x, extents->y, strip); + image = _cairo_image_surface_create_for_pixman_image (pixman_image, + pixman_format); + if (unlikely (image->status)) { + pixman_image_unref (pixman_image); + return (cairo_gl_surface_t *)image; + } + + mask = _cairo_surface_create_similar_scratch (_dst, CAIRO_CONTENT_ALPHA, + extents->width, + extents->height); + if (unlikely (mask->status)) { + cairo_surface_destroy (image); + return (cairo_gl_surface_t *)mask; + } + + status = _cairo_gl_surface_draw_image ((cairo_gl_surface_t *)mask, + (cairo_image_surface_t *)image, + 0, 0, + extents->width, extents->height, + 0, 0); + cairo_surface_destroy (image); + if (unlikely (status)) { + cairo_surface_destroy (mask); + return (cairo_gl_surface_t*)_cairo_surface_create_in_error (status); + } + + return (cairo_gl_surface_t*)mask; +} + +static cairo_int_status_t +composite_tristrip (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_antialias_t antialias, + cairo_tristrip_t *strip) +{ + cairo_gl_composite_t setup; + cairo_gl_context_t *ctx; + cairo_gl_surface_t *mask; + cairo_int_status_t status; + + mask = tristrip_to_surface (_dst, extents, antialias, strip); + if (unlikely (mask->base.status)) + return mask->base.status; + + status = _cairo_gl_composite_init (&setup, op, _dst, FALSE, NULL); + if (unlikely (status)) + goto FAIL; + + _cairo_gl_composite_set_source_operand (&setup, + source_to_operand (abstract_src)); + + //_cairo_gl_composite_set_mask_surface (&setup, mask, 0, 0); + + status = _cairo_gl_composite_begin (&setup, &ctx); + if (unlikely (status)) + goto FAIL; + + /* XXX clip */ + _cairo_gl_composite_emit_rect (ctx, + dst_x, dst_y, + dst_x+extents->width, + dst_y+extents->height, 0); + status = _cairo_gl_context_release (ctx, CAIRO_STATUS_SUCCESS); + +FAIL: + _cairo_gl_composite_fini (&setup); + cairo_surface_destroy (&mask->base); + return status; +} + +const cairo_compositor_t * +_cairo_gl_traps_compositor_get (void) +{ + static cairo_traps_compositor_t compositor; + + if (compositor.base.delegate == NULL) { + _cairo_traps_compositor_init (&compositor, &_cairo_fallback_compositor); + compositor.acquire = acquire; + compositor.release = release; + compositor.set_clip_region = set_clip_region; + compositor.pattern_to_surface = pattern_to_surface; + compositor.draw_image_boxes = draw_image_boxes; + //compositor.copy_boxes = copy_boxes; + compositor.fill_boxes = fill_boxes; + //compositor.check_composite = check_composite; + compositor.composite = composite; + compositor.lerp = lerp; + //compositor.check_composite_boxes = check_composite_boxes; + compositor.composite_boxes = composite_boxes; + //compositor.check_composite_traps = check_composite_traps; + compositor.composite_traps = composite_traps; + //compositor.check_composite_tristrip = check_composite_traps; + compositor.composite_tristrip = composite_tristrip; + compositor.check_composite_glyphs = _cairo_gl_check_composite_glyphs; + compositor.composite_glyphs = _cairo_gl_composite_glyphs; + } + + return &compositor.base; +} diff --git a/src/cairo-gstate.c b/src/cairo-gstate.c index 1b0658d8..c37fd8b4 100644 --- a/src/cairo-gstate.c +++ b/src/cairo-gstate.c @@ -41,6 +41,7 @@ #include "cairo-error-private.h" #include "cairo-gstate-private.h" #include "cairo-pattern-private.h" +#include "cairo-traps-private.h" #if _XOPEN_SOURCE >= 600 || defined (_ISOC99_SOURCE) #define ISFINITE(x) isfinite (x) @@ -60,7 +61,7 @@ _cairo_gstate_ensure_scaled_font (cairo_gstate_t *gstate); static void _cairo_gstate_unset_scaled_font (cairo_gstate_t *gstate); -static cairo_status_t +static void _cairo_gstate_transform_glyphs_to_backend (cairo_gstate_t *gstate, const cairo_glyph_t *glyphs, int num_glyphs, @@ -800,11 +801,21 @@ _cairo_gstate_backend_to_user_rectangle (cairo_gstate_t *gstate, { cairo_matrix_t matrix_inverse; - cairo_matrix_multiply (&matrix_inverse, - &gstate->target->device_transform_inverse, - &gstate->ctm_inverse); - _cairo_matrix_transform_bounding_box (&matrix_inverse, - x1, y1, x2, y2, is_tight); + if (! _cairo_matrix_is_identity (&gstate->target->device_transform_inverse) || + ! _cairo_matrix_is_identity (&gstate->ctm_inverse)) + { + cairo_matrix_multiply (&matrix_inverse, + &gstate->target->device_transform_inverse, + &gstate->ctm_inverse); + _cairo_matrix_transform_bounding_box (&matrix_inverse, + x1, y1, x2, y2, is_tight); + } + + else + { + if (is_tight) + *is_tight = TRUE; + } } /* XXX: NYI @@ -1346,45 +1357,29 @@ _cairo_gstate_show_page (cairo_gstate_t *gstate) } static void -_cairo_gstate_traps_extents_to_user_rectangle (cairo_gstate_t *gstate, - cairo_traps_t *traps, - double *x1, double *y1, - double *x2, double *y2) +_cairo_gstate_extents_to_user_rectangle (cairo_gstate_t *gstate, + const cairo_box_t *extents, + double *x1, double *y1, + double *x2, double *y2) { - cairo_box_t extents; - - if (traps->num_traps == 0) { - /* no traps, so we actually won't draw anything */ - if (x1) - *x1 = 0.0; - if (y1) - *y1 = 0.0; - if (x2) - *x2 = 0.0; - if (y2) - *y2 = 0.0; - } else { - double px1, py1, px2, py2; - - _cairo_traps_extents (traps, &extents); + double px1, py1, px2, py2; - px1 = _cairo_fixed_to_double (extents.p1.x); - py1 = _cairo_fixed_to_double (extents.p1.y); - px2 = _cairo_fixed_to_double (extents.p2.x); - py2 = _cairo_fixed_to_double (extents.p2.y); + px1 = _cairo_fixed_to_double (extents->p1.x); + py1 = _cairo_fixed_to_double (extents->p1.y); + px2 = _cairo_fixed_to_double (extents->p2.x); + py2 = _cairo_fixed_to_double (extents->p2.y); - _cairo_gstate_backend_to_user_rectangle (gstate, - &px1, &py1, &px2, &py2, - NULL); - if (x1) - *x1 = px1; - if (y1) - *y1 = py1; - if (x2) - *x2 = px2; - if (y2) - *y2 = py2; - } + _cairo_gstate_backend_to_user_rectangle (gstate, + &px1, &py1, &px2, &py2, + NULL); + if (x1) + *x1 = px1; + if (y1) + *y1 = py1; + if (x2) + *x2 = px2; + if (y2) + *y2 = py2; } cairo_status_t @@ -1393,35 +1388,57 @@ _cairo_gstate_stroke_extents (cairo_gstate_t *gstate, double *x1, double *y1, double *x2, double *y2) { - cairo_status_t status; - cairo_traps_t traps; + cairo_int_status_t status; + cairo_box_t extents; + cairo_bool_t empty; - if (gstate->stroke_style.line_width <= 0.0) { - if (x1) - *x1 = 0.0; - if (y1) - *y1 = 0.0; - if (x2) - *x2 = 0.0; - if (y2) - *y2 = 0.0; - return CAIRO_STATUS_SUCCESS; - } + if (x1) + *x1 = 0.0; + if (y1) + *y1 = 0.0; + if (x2) + *x2 = 0.0; + if (y2) + *y2 = 0.0; - _cairo_traps_init (&traps); + if (gstate->stroke_style.line_width <= 0.0) + return CAIRO_STATUS_SUCCESS; - status = _cairo_path_fixed_stroke_to_traps (path, - &gstate->stroke_style, - &gstate->ctm, - &gstate->ctm_inverse, - gstate->tolerance, - &traps); - if (likely (status == CAIRO_STATUS_SUCCESS)) { - _cairo_gstate_traps_extents_to_user_rectangle (gstate, &traps, - x1, y1, x2, y2); + status = CAIRO_INT_STATUS_UNSUPPORTED; + if (_cairo_path_fixed_stroke_is_rectilinear (path)) { + cairo_boxes_t boxes; + + _cairo_boxes_init (&boxes); + status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path, + &gstate->stroke_style, + &gstate->ctm, + gstate->antialias, + &boxes); + empty = boxes.num_boxes == 0; + if (! empty) + _cairo_boxes_extents (&boxes, &extents); + _cairo_boxes_fini (&boxes); } - _cairo_traps_fini (&traps); + if (status == CAIRO_INT_STATUS_UNSUPPORTED) { + cairo_traps_t traps; + + _cairo_traps_init (&traps); + status = _cairo_path_fixed_stroke_to_traps (path, + &gstate->stroke_style, + &gstate->ctm, + &gstate->ctm_inverse, + gstate->tolerance, + &traps); + empty = traps.num_traps == 0; + if (! empty) + _cairo_traps_extents (&traps, &extents); + _cairo_traps_fini (&traps); + } + if (! empty) { + _cairo_gstate_extents_to_user_rectangle (gstate, &extents, + x1, y1, x2, y2); + } return status; } @@ -1433,32 +1450,54 @@ _cairo_gstate_fill_extents (cairo_gstate_t *gstate, double *x2, double *y2) { cairo_status_t status; - cairo_traps_t traps; + cairo_box_t extents; + cairo_bool_t empty; - if (_cairo_path_fixed_fill_is_empty (path)) { - if (x1) - *x1 = 0.0; - if (y1) - *y1 = 0.0; - if (x2) - *x2 = 0.0; - if (y2) - *y2 = 0.0; + if (x1) + *x1 = 0.0; + if (y1) + *y1 = 0.0; + if (x2) + *x2 = 0.0; + if (y2) + *y2 = 0.0; + + if (_cairo_path_fixed_fill_is_empty (path)) return CAIRO_STATUS_SUCCESS; - } - _cairo_traps_init (&traps); + if (_cairo_path_fixed_fill_is_rectilinear (path)) { + cairo_boxes_t boxes; + + _cairo_boxes_init (&boxes); + status = _cairo_path_fixed_fill_rectilinear_to_boxes (path, + gstate->fill_rule, + gstate->antialias, + &boxes); + empty = boxes.num_boxes == 0; + if (! empty) + _cairo_boxes_extents (&boxes, &extents); + + _cairo_boxes_fini (&boxes); + } else { + cairo_traps_t traps; - status = _cairo_path_fixed_fill_to_traps (path, - gstate->fill_rule, - gstate->tolerance, - &traps); - if (likely (status == CAIRO_STATUS_SUCCESS)) { - _cairo_gstate_traps_extents_to_user_rectangle (gstate, &traps, - x1, y1, x2, y2); + _cairo_traps_init (&traps); + + status = _cairo_path_fixed_fill_to_traps (path, + gstate->fill_rule, + gstate->tolerance, + &traps); + empty = traps.num_traps == 0; + if (! empty) + _cairo_traps_extents (&traps, &extents); + + _cairo_traps_fini (&traps); } - _cairo_traps_fini (&traps); + if (! empty) { + _cairo_gstate_extents_to_user_rectangle (gstate, &extents, + x1, y1, x2, y2); + } return status; } @@ -1834,12 +1873,12 @@ _cairo_gstate_show_text_glyphs (cairo_gstate_t *gstate, int num_glyphs, cairo_glyph_text_info_t *info) { - cairo_pattern_union_t source_pattern; - const cairo_pattern_t *pattern; cairo_glyph_t stack_transformed_glyphs[CAIRO_STACK_ARRAY_LENGTH (cairo_glyph_t)]; - cairo_glyph_t *transformed_glyphs; cairo_text_cluster_t stack_transformed_clusters[CAIRO_STACK_ARRAY_LENGTH (cairo_text_cluster_t)]; - cairo_text_cluster_t *transformed_clusters = NULL; + cairo_pattern_union_t source_pattern; + cairo_glyph_t *transformed_glyphs; + const cairo_pattern_t *pattern; + cairo_text_cluster_t *transformed_clusters; cairo_operator_t op; cairo_status_t status; @@ -1858,16 +1897,15 @@ _cairo_gstate_show_text_glyphs (cairo_gstate_t *gstate, return status; transformed_glyphs = stack_transformed_glyphs; + transformed_clusters = stack_transformed_clusters; + if (num_glyphs > ARRAY_LENGTH (stack_transformed_glyphs)) { transformed_glyphs = cairo_glyph_allocate (num_glyphs); - if (unlikely (transformed_glyphs == NULL)) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto CLEANUP_GLYPHS; - } + if (unlikely (transformed_glyphs == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); } if (info != NULL) { - transformed_clusters = stack_transformed_clusters; if (info->num_clusters > ARRAY_LENGTH (stack_transformed_clusters)) { transformed_clusters = cairo_text_cluster_allocate (info->num_clusters); if (unlikely (transformed_clusters == NULL)) { @@ -1876,24 +1914,24 @@ _cairo_gstate_show_text_glyphs (cairo_gstate_t *gstate, } } - status = _cairo_gstate_transform_glyphs_to_backend (gstate, - glyphs, num_glyphs, - info->clusters, - info->num_clusters, - info->cluster_flags, - transformed_glyphs, - &num_glyphs, - transformed_clusters); + _cairo_gstate_transform_glyphs_to_backend (gstate, + glyphs, num_glyphs, + info->clusters, + info->num_clusters, + info->cluster_flags, + transformed_glyphs, + &num_glyphs, + transformed_clusters); } else { - status = _cairo_gstate_transform_glyphs_to_backend (gstate, - glyphs, num_glyphs, - NULL, 0, 0, - transformed_glyphs, - &num_glyphs, - NULL); + _cairo_gstate_transform_glyphs_to_backend (gstate, + glyphs, num_glyphs, + NULL, 0, 0, + transformed_glyphs, + &num_glyphs, + NULL); } - if (status || num_glyphs == 0) + if (num_glyphs == 0) goto CLEANUP_GLYPHS; op = _reduce_op (gstate); @@ -1971,35 +2009,32 @@ _cairo_gstate_glyph_path (cairo_gstate_t *gstate, int num_glyphs, cairo_path_fixed_t *path) { - cairo_status_t status; - cairo_glyph_t *transformed_glyphs; cairo_glyph_t stack_transformed_glyphs[CAIRO_STACK_ARRAY_LENGTH (cairo_glyph_t)]; + cairo_glyph_t *transformed_glyphs; + cairo_status_t status; status = _cairo_gstate_ensure_scaled_font (gstate); if (unlikely (status)) return status; if (num_glyphs < ARRAY_LENGTH (stack_transformed_glyphs)) { - transformed_glyphs = stack_transformed_glyphs; + transformed_glyphs = stack_transformed_glyphs; } else { transformed_glyphs = cairo_glyph_allocate (num_glyphs); if (unlikely (transformed_glyphs == NULL)) return _cairo_error (CAIRO_STATUS_NO_MEMORY); } - status = _cairo_gstate_transform_glyphs_to_backend (gstate, - glyphs, num_glyphs, - NULL, 0, 0, - transformed_glyphs, - &num_glyphs, NULL); - if (unlikely (status)) - goto CLEANUP_GLYPHS; + _cairo_gstate_transform_glyphs_to_backend (gstate, + glyphs, num_glyphs, + NULL, 0, 0, + transformed_glyphs, + &num_glyphs, NULL); status = _cairo_scaled_font_glyph_path (gstate->scaled_font, transformed_glyphs, num_glyphs, path); - CLEANUP_GLYPHS: if (transformed_glyphs != stack_transformed_glyphs) cairo_glyph_free (transformed_glyphs); @@ -2039,7 +2074,7 @@ _cairo_gstate_get_antialias (cairo_gstate_t *gstate) * This also uses information from the scaled font and the surface to * cull/drop glyphs that will not be visible. **/ -static cairo_status_t +static void _cairo_gstate_transform_glyphs_to_backend (cairo_gstate_t *gstate, const cairo_glyph_t *glyphs, int num_glyphs, @@ -2050,44 +2085,40 @@ _cairo_gstate_transform_glyphs_to_backend (cairo_gstate_t *gstate, int *num_transformed_glyphs, cairo_text_cluster_t *transformed_clusters) { - int i, j, k; + cairo_rectangle_int_t surface_extents; cairo_matrix_t *ctm = &gstate->ctm; cairo_matrix_t *font_matrix = &gstate->font_matrix; cairo_matrix_t *device_transform = &gstate->target->device_transform; cairo_bool_t drop = FALSE; double x1 = 0, x2 = 0, y1 = 0, y2 = 0; + int i, j, k; - if (num_transformed_glyphs != NULL) { - cairo_rectangle_int_t surface_extents; - - drop = TRUE; - if (! _cairo_gstate_int_clip_extents (gstate, &surface_extents)) { - drop = FALSE; /* unbounded surface */ - } else { - double scale10 = 10 * _cairo_scaled_font_get_max_scale (gstate->scaled_font); - if (surface_extents.width == 0 || surface_extents.height == 0) { - /* No visible area. Don't draw anything */ - *num_transformed_glyphs = 0; - return CAIRO_STATUS_SUCCESS; - } - /* XXX We currently drop any glyphs that has its position outside - * of the surface boundaries by a safety margin depending on the - * font scale. This however can fail in extreme cases where the - * font has really long swashes for example... We can correctly - * handle that by looking the glyph up and using its device bbox - * to device if it's going to be visible, but I'm not inclined to - * do that now. - */ - x1 = surface_extents.x - scale10; - y1 = surface_extents.y - scale10; - x2 = surface_extents.x + (int) surface_extents.width + scale10; - y2 = surface_extents.y + (int) surface_extents.height + scale10; + drop = TRUE; + if (! _cairo_gstate_int_clip_extents (gstate, &surface_extents)) { + drop = FALSE; /* unbounded surface */ + } else { + double scale10 = 10 * _cairo_scaled_font_get_max_scale (gstate->scaled_font); + if (surface_extents.width == 0 || surface_extents.height == 0) { + /* No visible area. Don't draw anything */ + *num_transformed_glyphs = 0; + return; } + /* XXX We currently drop any glyphs that has its position outside + * of the surface boundaries by a safety margin depending on the + * font scale. This however can fail in extreme cases where the + * font has really long swashes for example... We can correctly + * handle that by looking the glyph up and using its device bbox + * to device if it's going to be visible, but I'm not inclined to + * do that now. + */ + x1 = surface_extents.x - scale10; + y1 = surface_extents.y - scale10; + x2 = surface_extents.x + (int) surface_extents.width + scale10; + y2 = surface_extents.y + (int) surface_extents.height + scale10; + } - if (!drop) - *num_transformed_glyphs = num_glyphs; - } else - num_transformed_glyphs = &j; + if (!drop) + *num_transformed_glyphs = num_glyphs; #define KEEP_GLYPH(glyph) (x1 <= glyph.x && glyph.x <= x2 && y1 <= glyph.y && glyph.y <= y2) @@ -2156,6 +2187,8 @@ _cairo_gstate_transform_glyphs_to_backend (cairo_gstate_t *gstate, if (!drop || KEEP_GLYPH (transformed_glyphs[j])) j++; } + memcpy (transformed_clusters, clusters, + num_clusters * sizeof (cairo_text_cluster_t)); } else { const cairo_glyph_t *cur_glyph; @@ -2209,6 +2242,8 @@ _cairo_gstate_transform_glyphs_to_backend (cairo_gstate_t *gstate, if (! drop || KEEP_GLYPH (transformed_glyphs[j])) j++; } + memcpy (transformed_clusters, clusters, + num_clusters * sizeof (cairo_text_cluster_t)); } else { const cairo_glyph_t *cur_glyph; @@ -2252,6 +2287,4 @@ _cairo_gstate_transform_glyphs_to_backend (cairo_gstate_t *gstate, transformed_glyphs[j] = tmp; } } - - return CAIRO_STATUS_SUCCESS; } diff --git a/src/cairo-image-compositor.c b/src/cairo-image-compositor.c new file mode 100644 index 00000000..35472de3 --- /dev/null +++ b/src/cairo-image-compositor.c @@ -0,0 +1,1545 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2003 University of Southern California + * Copyright © 2009,2010,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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +/* The primarily reason for keeping a traps-compositor around is + * for validating cairo-xlib (which currently also uses traps). + */ + +#include "cairoint.h" + +#include "cairo-image-surface-private.h" + +#include "cairo-compositor-private.h" +#include "cairo-spans-compositor-private.h" + +#include "cairo-region-private.h" +#include "cairo-traps-private.h" +#include "cairo-tristrip-private.h" + +static pixman_image_t * +to_pixman_image (cairo_surface_t *s) +{ + return ((cairo_image_surface_t *)s)->pixman_image; +} + +static cairo_int_status_t +acquire (void *abstract_dst) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +release (void *abstract_dst) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +set_clip_region (void *_surface, + cairo_region_t *region) +{ + cairo_image_surface_t *surface = _surface; + pixman_region32_t *rgn = region ? ®ion->rgn : NULL; + + if (! pixman_image_set_clip_region32 (surface->pixman_image, rgn)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +draw_image_boxes (void *_dst, + cairo_image_surface_t *image, + cairo_boxes_t *boxes, + int dx, int dy) +{ + cairo_image_surface_t *dst = _dst; + struct _cairo_boxes_chunk *chunk; + int i; + + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + cairo_box_t *b = &chunk->base[i]; + int x = _cairo_fixed_integer_part (b->p1.x); + int y = _cairo_fixed_integer_part (b->p1.y); + int w = _cairo_fixed_integer_part (b->p2.x) - x; + int h = _cairo_fixed_integer_part (b->p2.y) - y; + if (dst->pixman_format != image->pixman_format || + ! pixman_blt ((uint32_t *)image->data, (uint32_t *)dst->data, + image->stride / sizeof (uint32_t), + dst->stride / sizeof (uint32_t), + PIXMAN_FORMAT_BPP (image->pixman_format), + PIXMAN_FORMAT_BPP (dst->pixman_format), + x + dx, y + dy, + x, y, + w, h)) + { + pixman_image_composite32 (PIXMAN_OP_SRC, + image->pixman_image, NULL, dst->pixman_image, + x + dx, y + dy, + 0, 0, + x, y, + w, h); + } + } + } + return CAIRO_STATUS_SUCCESS; +} + +static inline uint32_t +color_to_uint32 (const cairo_color_t *color) +{ + return + (color->alpha_short >> 8 << 24) | + (color->red_short >> 8 << 16) | + (color->green_short & 0xff00) | + (color->blue_short >> 8); +} + +static inline cairo_bool_t +color_to_pixel (const cairo_color_t *color, + pixman_format_code_t format, + uint32_t *pixel) +{ + uint32_t c; + + if (!(format == PIXMAN_a8r8g8b8 || + format == PIXMAN_x8r8g8b8 || + format == PIXMAN_a8b8g8r8 || + format == PIXMAN_x8b8g8r8 || + format == PIXMAN_b8g8r8a8 || + format == PIXMAN_b8g8r8x8 || + format == PIXMAN_r5g6b5 || + format == PIXMAN_b5g6r5 || + format == PIXMAN_a8)) + { + return FALSE; + } + + c = color_to_uint32 (color); + + if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_ABGR) { + c = ((c & 0xff000000) >> 0) | + ((c & 0x00ff0000) >> 16) | + ((c & 0x0000ff00) >> 0) | + ((c & 0x000000ff) << 16); + } + + if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_BGRA) { + c = ((c & 0xff000000) >> 24) | + ((c & 0x00ff0000) >> 8) | + ((c & 0x0000ff00) << 8) | + ((c & 0x000000ff) << 24); + } + + if (format == PIXMAN_a8) { + c = c >> 24; + } else if (format == PIXMAN_r5g6b5 || format == PIXMAN_b5g6r5) { + c = ((((c) >> 3) & 0x001f) | + (((c) >> 5) & 0x07e0) | + (((c) >> 8) & 0xf800)); + } + + *pixel = c; + return TRUE; +} + +static pixman_op_t +_pixman_operator (cairo_operator_t op) +{ + switch ((int) op) { + case CAIRO_OPERATOR_CLEAR: + return PIXMAN_OP_CLEAR; + + case CAIRO_OPERATOR_SOURCE: + return PIXMAN_OP_SRC; + case CAIRO_OPERATOR_OVER: + return PIXMAN_OP_OVER; + case CAIRO_OPERATOR_IN: + return PIXMAN_OP_IN; + case CAIRO_OPERATOR_OUT: + return PIXMAN_OP_OUT; + case CAIRO_OPERATOR_ATOP: + return PIXMAN_OP_ATOP; + + case CAIRO_OPERATOR_DEST: + return PIXMAN_OP_DST; + case CAIRO_OPERATOR_DEST_OVER: + return PIXMAN_OP_OVER_REVERSE; + case CAIRO_OPERATOR_DEST_IN: + return PIXMAN_OP_IN_REVERSE; + case CAIRO_OPERATOR_DEST_OUT: + return PIXMAN_OP_OUT_REVERSE; + case CAIRO_OPERATOR_DEST_ATOP: + return PIXMAN_OP_ATOP_REVERSE; + + case CAIRO_OPERATOR_XOR: + return PIXMAN_OP_XOR; + case CAIRO_OPERATOR_ADD: + return PIXMAN_OP_ADD; + case CAIRO_OPERATOR_SATURATE: + return PIXMAN_OP_SATURATE; + + case CAIRO_OPERATOR_MULTIPLY: + return PIXMAN_OP_MULTIPLY; + case CAIRO_OPERATOR_SCREEN: + return PIXMAN_OP_SCREEN; + case CAIRO_OPERATOR_OVERLAY: + return PIXMAN_OP_OVERLAY; + case CAIRO_OPERATOR_DARKEN: + return PIXMAN_OP_DARKEN; + case CAIRO_OPERATOR_LIGHTEN: + return PIXMAN_OP_LIGHTEN; + case CAIRO_OPERATOR_COLOR_DODGE: + return PIXMAN_OP_COLOR_DODGE; + case CAIRO_OPERATOR_COLOR_BURN: + return PIXMAN_OP_COLOR_BURN; + case CAIRO_OPERATOR_HARD_LIGHT: + return PIXMAN_OP_HARD_LIGHT; + case CAIRO_OPERATOR_SOFT_LIGHT: + return PIXMAN_OP_SOFT_LIGHT; + case CAIRO_OPERATOR_DIFFERENCE: + return PIXMAN_OP_DIFFERENCE; + case CAIRO_OPERATOR_EXCLUSION: + return PIXMAN_OP_EXCLUSION; + case CAIRO_OPERATOR_HSL_HUE: + return PIXMAN_OP_HSL_HUE; + case CAIRO_OPERATOR_HSL_SATURATION: + return PIXMAN_OP_HSL_SATURATION; + case CAIRO_OPERATOR_HSL_COLOR: + return PIXMAN_OP_HSL_COLOR; + case CAIRO_OPERATOR_HSL_LUMINOSITY: + return PIXMAN_OP_HSL_LUMINOSITY; + + default: + ASSERT_NOT_REACHED; + return PIXMAN_OP_OVER; + } +} + +static cairo_bool_t +fill_reduces_to_source (cairo_operator_t op, + const cairo_color_t *color, + cairo_image_surface_t *dst) +{ + if (op == CAIRO_OPERATOR_SOURCE || op == CAIRO_OPERATOR_CLEAR) + return TRUE; + if (op == CAIRO_OPERATOR_OVER && CAIRO_COLOR_IS_OPAQUE (color)) + return TRUE; + if (dst->base.is_clear) + return op == CAIRO_OPERATOR_OVER || op == CAIRO_OPERATOR_ADD; + + return FALSE; +} + +static cairo_int_status_t +fill_rectangles (void *_dst, + cairo_operator_t op, + const cairo_color_t *color, + cairo_rectangle_int_t *rects, + int num_rects) +{ + cairo_image_surface_t *dst = _dst; + uint32_t pixel; + int i; + + if (fill_reduces_to_source (op, color, dst) && + color_to_pixel (color, dst->pixman_format, &pixel)) + { + for (i = 0; i < num_rects; i++) { + pixman_fill ((uint32_t *) dst->data, dst->stride / sizeof (uint32_t), + PIXMAN_FORMAT_BPP (dst->pixman_format), + rects[i].x, rects[i].y, + rects[i].width, rects[i].height, + pixel); + } + } + else + { + pixman_image_t *src = _pixman_image_for_color (color); + + op = _pixman_operator (op); + for (i = 0; i < num_rects; i++) { + pixman_image_composite32 (op, + src, NULL, dst->pixman_image, + 0, 0, + 0, 0, + rects[i].x, rects[i].y, + rects[i].width, rects[i].height); + } + + pixman_image_unref (src); + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +fill_boxes (void *_dst, + cairo_operator_t op, + const cairo_color_t *color, + cairo_boxes_t *boxes) +{ + cairo_image_surface_t *dst = _dst; + struct _cairo_boxes_chunk *chunk; + uint32_t pixel; + int i; + + if (fill_reduces_to_source (op, color, dst) && + color_to_pixel (color, dst->pixman_format, &pixel)) + { + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + int x = _cairo_fixed_integer_part (chunk->base[i].p1.x); + int y = _cairo_fixed_integer_part (chunk->base[i].p1.y); + int w = _cairo_fixed_integer_part (chunk->base[i].p2.x) - x; + int h = _cairo_fixed_integer_part (chunk->base[i].p2.y) - y; + pixman_fill ((uint32_t *) dst->data, + dst->stride / sizeof (uint32_t), + PIXMAN_FORMAT_BPP (dst->pixman_format), + x, y, w, h, pixel); + } + } + } + else + { + pixman_image_t *src = _pixman_image_for_color (color); + + op = _pixman_operator (op); + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x); + int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y); + int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x); + int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y); + pixman_image_composite32 (op, + src, NULL, dst->pixman_image, + 0, 0, + 0, 0, + x1, y1, + x2-x1, y2-y1); + } + } + + pixman_image_unref (src); + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height) +{ + cairo_image_source_t *src = (cairo_image_source_t *)abstract_src; + cairo_image_source_t *mask = (cairo_image_source_t *)abstract_mask; + if (mask) { + pixman_image_composite32 (_pixman_operator (op), + src->pixman_image, mask->pixman_image, to_pixman_image (_dst), + src_x, src_y, + mask_x, mask_y, + dst_x, dst_y, + width, height); + } else { + pixman_image_composite32 (_pixman_operator (op), + src->pixman_image, NULL, to_pixman_image (_dst), + src_x, src_y, + 0, 0, + dst_x, dst_y, + width, height); + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +lerp (void *_dst, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height) +{ + cairo_image_surface_t *dst = _dst; + cairo_image_source_t *src = (cairo_image_source_t *)abstract_src; + cairo_image_source_t *mask = (cairo_image_source_t *)abstract_mask; + +#if PIXMAN_HAS_OP_LERP + pixman_image_composite32 (PIXMAN_OP_LERP, + src->pixman_image, mask->pixman_image, dst->pixman_image, + src_x, src_y, + mask_x, mask_y, + dst_x, dst_y, + width, height); +#else + /* Punch the clip out of the destination */ + pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, + mask->pixman_image, NULL, dst->pixman_image, + mask_x, mask_y, + 0, 0, + dst_x, dst_y, + width, height); + + /* Now add the two results together */ + pixman_image_composite32 (PIXMAN_OP_ADD, + src->pixman_image, mask->pixman_image, dst->pixman_image, + src_x, src_y, + mask_x, mask_y, + dst_x, dst_y, + width, height); +#endif + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_boxes (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + cairo_boxes_t *boxes, + const cairo_rectangle_int_t *extents) +{ + pixman_image_t *dst = to_pixman_image (_dst); + pixman_image_t *src = ((cairo_image_source_t *)abstract_src)->pixman_image; + pixman_image_t *mask = abstract_mask ? ((cairo_image_source_t *)abstract_mask)->pixman_image : NULL; + struct _cairo_boxes_chunk *chunk; + int i; + + /* XXX consider using a region? saves multiple prepare-composite */ + + op = _pixman_operator (op); + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x); + int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y); + int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x); + int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y); + + pixman_image_composite32 (op, src, mask, dst, + x1 + src_x, y1 + src_y, + x1 + mask_x, y1 + mask_y, + x1 + dst_x, y1 + dst_y, + x2 - x1, y2 - y1); + } + } + + return CAIRO_STATUS_SUCCESS; +} + +#define CAIRO_FIXED_16_16_MIN _cairo_fixed_from_int (-32768) +#define CAIRO_FIXED_16_16_MAX _cairo_fixed_from_int (32767) + +static cairo_bool_t +line_exceeds_16_16 (const cairo_line_t *line) +{ + return + line->p1.x <= CAIRO_FIXED_16_16_MIN || + line->p1.x >= CAIRO_FIXED_16_16_MAX || + + line->p2.x <= CAIRO_FIXED_16_16_MIN || + line->p2.x >= CAIRO_FIXED_16_16_MAX || + + line->p1.y <= CAIRO_FIXED_16_16_MIN || + line->p1.y >= CAIRO_FIXED_16_16_MAX || + + line->p2.y <= CAIRO_FIXED_16_16_MIN || + line->p2.y >= CAIRO_FIXED_16_16_MAX; +} + +static void +project_line_x_onto_16_16 (const cairo_line_t *line, + cairo_fixed_t top, + cairo_fixed_t bottom, + pixman_line_fixed_t *out) +{ + /* XXX use fixed-point arithmetic? */ + cairo_point_double_t p1, p2; + double m; + + p1.x = _cairo_fixed_to_double (line->p1.x); + p1.y = _cairo_fixed_to_double (line->p1.y); + + p2.x = _cairo_fixed_to_double (line->p2.x); + p2.y = _cairo_fixed_to_double (line->p2.y); + + m = (p2.x - p1.x) / (p2.y - p1.y); + out->p1.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (top - line->p1.y)); + out->p2.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (bottom - line->p1.y)); +} + +void +_pixman_image_add_traps (pixman_image_t *image, + int dst_x, int dst_y, + cairo_traps_t *traps) +{ + cairo_trapezoid_t *t = traps->traps; + int num_traps = traps->num_traps; + while (num_traps--) { + pixman_trapezoid_t trap; + + /* top/bottom will be clamped to surface bounds */ + trap.top = _cairo_fixed_to_16_16 (t->top); + trap.bottom = _cairo_fixed_to_16_16 (t->bottom); + + /* However, all the other coordinates will have been left untouched so + * as not to introduce numerical error. Recompute them if they + * exceed the 16.16 limits. + */ + if (unlikely (line_exceeds_16_16 (&t->left))) { + project_line_x_onto_16_16 (&t->left, t->top, t->bottom, &trap.left); + trap.left.p1.y = trap.top; + trap.left.p2.y = trap.bottom; + } else { + trap.left.p1.x = _cairo_fixed_to_16_16 (t->left.p1.x); + trap.left.p1.y = _cairo_fixed_to_16_16 (t->left.p1.y); + trap.left.p2.x = _cairo_fixed_to_16_16 (t->left.p2.x); + trap.left.p2.y = _cairo_fixed_to_16_16 (t->left.p2.y); + } + + if (unlikely (line_exceeds_16_16 (&t->right))) { + project_line_x_onto_16_16 (&t->right, t->top, t->bottom, &trap.right); + trap.right.p1.y = trap.top; + trap.right.p2.y = trap.bottom; + } else { + trap.right.p1.x = _cairo_fixed_to_16_16 (t->right.p1.x); + trap.right.p1.y = _cairo_fixed_to_16_16 (t->right.p1.y); + trap.right.p2.x = _cairo_fixed_to_16_16 (t->right.p2.x); + trap.right.p2.y = _cairo_fixed_to_16_16 (t->right.p2.y); + } + + pixman_rasterize_trapezoid (image, &trap, -dst_x, -dst_y); + t++; + } +} + +static cairo_int_status_t +composite_traps (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_antialias_t antialias, + cairo_traps_t *traps) +{ + cairo_image_surface_t *dst = (cairo_image_surface_t *) _dst; + cairo_image_source_t *src = (cairo_image_source_t *) abstract_src; + pixman_image_t *mask; + pixman_format_code_t format; + + /* Special case adding trapezoids onto a mask surface; we want to avoid + * creating an intermediate temporary mask unnecessarily. + * + * We make the assumption here that the portion of the trapezoids + * contained within the surface is bounded by [dst_x,dst_y,width,height]; + * the Cairo core code passes bounds based on the trapezoid extents. + */ + format = antialias == CAIRO_ANTIALIAS_NONE ? PIXMAN_a1 : PIXMAN_a8; + if (dst->pixman_format == format && + (abstract_src == NULL || + (op == CAIRO_OPERATOR_ADD && src->is_opaque_solid))) + { + _pixman_image_add_traps (dst->pixman_image, dst_x, dst_y, traps); + return CAIRO_STATUS_SUCCESS; + } + + mask = pixman_image_create_bits (format, + extents->width, extents->height, + NULL, 0); + if (unlikely (mask == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + _pixman_image_add_traps (mask, extents->x, extents->y, traps); + pixman_image_composite32 (_pixman_operator (op), + src->pixman_image, mask, dst->pixman_image, + extents->x + src_x, extents->y + src_y, + 0, 0, + extents->x - dst_x, extents->y - dst_y, + extents->width, extents->height); + + pixman_image_unref (mask); + + return CAIRO_STATUS_SUCCESS; +} + +static void +set_point (pixman_point_fixed_t *p, cairo_point_t *c) +{ + p->x = _cairo_fixed_to_16_16 (c->x); + p->y = _cairo_fixed_to_16_16 (c->y); +} + +void +_pixman_image_add_tristrip (pixman_image_t *image, + int dst_x, int dst_y, + cairo_tristrip_t *strip) +{ + pixman_triangle_t tri; + pixman_point_fixed_t *p[3] = {&tri.p1, &tri.p2, &tri.p3 }; + int n; + + set_point (p[0], &strip->points[0]); + set_point (p[1], &strip->points[1]); + set_point (p[2], &strip->points[2]); + pixman_add_triangles (image, -dst_x, -dst_y, 1, &tri); + for (n = 3; n < strip->num_points; n++) { + set_point (p[n%3], &strip->points[n]); + pixman_add_triangles (image, -dst_x, -dst_y, 1, &tri); + } +} + +static cairo_int_status_t +composite_tristrip (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_antialias_t antialias, + cairo_tristrip_t *strip) +{ + cairo_image_surface_t *dst = (cairo_image_surface_t *) _dst; + cairo_image_source_t *src = (cairo_image_source_t *) abstract_src; + pixman_image_t *mask; + pixman_format_code_t format; + + if (strip->num_points < 3) + return CAIRO_STATUS_SUCCESS; + + format = antialias == CAIRO_ANTIALIAS_NONE ? PIXMAN_a1 : PIXMAN_a8; + if (dst->pixman_format == format && + (abstract_src == NULL || + (op == CAIRO_OPERATOR_ADD && src->is_opaque_solid))) + { + _pixman_image_add_tristrip (dst->pixman_image, dst_x, dst_y, strip); + return CAIRO_STATUS_SUCCESS; + } + + mask = pixman_image_create_bits (format, + extents->width, extents->height, + NULL, 0); + if (unlikely (mask == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + _pixman_image_add_tristrip (mask, extents->x, extents->y, strip); + pixman_image_composite32 (_pixman_operator (op), + src->pixman_image, mask, dst->pixman_image, + extents->x + src_x, extents->y + src_y, + 0, 0, + extents->x - dst_x, extents->y - dst_y, + extents->width, extents->height); + + pixman_image_unref (mask); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +check_composite_glyphs (const cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *scaled_font, + cairo_glyph_t *glyphs, + int *num_glyphs) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_one_glyph (void *_dst, + cairo_operator_t op, + cairo_surface_t *_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + cairo_composite_glyphs_info_t *info) +{ + cairo_image_surface_t *glyph_surface; + cairo_scaled_glyph_t *scaled_glyph; + cairo_status_t status; + int x, y; + + status = _cairo_scaled_glyph_lookup (info->font, + info->glyphs[0].index, + CAIRO_SCALED_GLYPH_INFO_SURFACE, + &scaled_glyph); + + if (unlikely (status)) + return status; + + glyph_surface = scaled_glyph->surface; + if (glyph_surface->width == 0 || glyph_surface->height == 0) + return CAIRO_INT_STATUS_NOTHING_TO_DO; + + /* round glyph locations to the nearest pixel */ + /* XXX: FRAGILE: We're ignoring device_transform scaling here. A bug? */ + x = _cairo_lround (info->glyphs[0].x - + glyph_surface->base.device_transform.x0); + y = _cairo_lround (info->glyphs[0].y - + glyph_surface->base.device_transform.y0); + + pixman_image_composite32 (_pixman_operator (op), + ((cairo_image_source_t *)_src)->pixman_image, + glyph_surface->pixman_image, + to_pixman_image (_dst), + x + src_x, y + src_y, + 0, 0, + x - dst_x, y - dst_y, + glyph_surface->width, + glyph_surface->height); + + return CAIRO_INT_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_glyphs_via_mask (void *_dst, + cairo_operator_t op, + cairo_surface_t *_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + cairo_composite_glyphs_info_t *info) +{ + cairo_scaled_glyph_t *glyph_cache[64]; + cairo_bool_t component_alpha = FALSE; + uint8_t buf[2048]; + pixman_image_t *mask; + cairo_status_t status; + int i; + + /* XXX convert the glyphs to common formats a8/a8r8g8b8 to hit + * optimised paths through pixman. Should we increase the bit + * depth of the target surface, we should reconsider the appropriate + * mask formats. + */ + i = (info->extents.width + 3) & ~3; + if (i * info->extents.height > (int) sizeof (buf)) { + mask = pixman_image_create_bits (PIXMAN_a8, + info->extents.width, + info->extents.height, + NULL, 0); + } else { + memset (buf, 0, i * info->extents.height); + mask = pixman_image_create_bits (PIXMAN_a8, + info->extents.width, + info->extents.height, + (uint32_t *)buf, i); + } + if (unlikely (mask == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + memset (glyph_cache, 0, sizeof (glyph_cache)); + status = CAIRO_STATUS_SUCCESS; + + for (i = 0; i < info->num_glyphs; i++) { + cairo_image_surface_t *glyph_surface; + cairo_scaled_glyph_t *scaled_glyph; + unsigned long glyph_index = info->glyphs[i].index; + int cache_index = glyph_index % ARRAY_LENGTH (glyph_cache); + int x, y; + + scaled_glyph = glyph_cache[cache_index]; + if (scaled_glyph == NULL || + _cairo_scaled_glyph_index (scaled_glyph) != glyph_index) + { + status = _cairo_scaled_glyph_lookup (info->font, glyph_index, + CAIRO_SCALED_GLYPH_INFO_SURFACE, + &scaled_glyph); + + if (unlikely (status)) { + pixman_image_unref (mask); + return status; + } + + glyph_cache[cache_index] = scaled_glyph; + } + + glyph_surface = scaled_glyph->surface; + if (glyph_surface->width && glyph_surface->height) { + if (glyph_surface->base.content & CAIRO_CONTENT_COLOR && + ! component_alpha) { + pixman_image_t *ca_mask; + + ca_mask = pixman_image_create_bits (PIXMAN_a8r8g8b8, + info->extents.width, + info->extents.height, + NULL, 0); + if (unlikely (ca_mask == NULL)) { + pixman_image_unref (mask); + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + pixman_image_composite32 (PIXMAN_OP_SRC, + mask, 0, ca_mask, + 0, 0, + 0, 0, + 0, 0, + info->extents.width, + info->extents.height); + pixman_image_unref (mask); + mask = ca_mask; + component_alpha = TRUE; + } + + /* round glyph locations to the nearest pixel */ + /* XXX: FRAGILE: We're ignoring device_transform scaling here. A bug? */ + x = _cairo_lround (info->glyphs[i].x - + glyph_surface->base.device_transform.x0); + y = _cairo_lround (info->glyphs[i].y - + glyph_surface->base.device_transform.y0); + + pixman_image_composite32 (PIXMAN_OP_ADD, + glyph_surface->pixman_image, NULL, mask, + 0, 0, + 0, 0, + x - info->extents.x, y - info->extents.y, + glyph_surface->width, + glyph_surface->height); + } + } + + if (component_alpha) + pixman_image_set_component_alpha (mask, TRUE); + + pixman_image_composite32 (_pixman_operator (op), + ((cairo_image_source_t *)_src)->pixman_image, + mask, + to_pixman_image (_dst), + info->extents.x + src_x, info->extents.y + src_y, + 0, 0, + info->extents.x - dst_x, info->extents.y - dst_y, + info->extents.width, info->extents.height); + pixman_image_unref (mask); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_glyphs (void *_dst, + cairo_operator_t op, + cairo_surface_t *_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + cairo_composite_glyphs_info_t *info) +{ + cairo_scaled_glyph_t *glyph_cache[64]; + pixman_image_t *dst, *src; + cairo_status_t status; + int i; + + if (info->num_glyphs == 1) + return composite_one_glyph(_dst, op, _src, src_x, src_y, dst_x, dst_y, info); + + if (info->use_mask) + return composite_glyphs_via_mask(_dst, op, _src, src_x, src_y, dst_x, dst_y, info); + + op = _pixman_operator (op); + dst = to_pixman_image (_dst); + src = ((cairo_image_source_t *)_src)->pixman_image; + + memset (glyph_cache, 0, sizeof (glyph_cache)); + status = CAIRO_STATUS_SUCCESS; + + for (i = 0; i < info->num_glyphs; i++) { + int x, y; + cairo_image_surface_t *glyph_surface; + cairo_scaled_glyph_t *scaled_glyph; + unsigned long glyph_index = info->glyphs[i].index; + int cache_index = glyph_index % ARRAY_LENGTH (glyph_cache); + + scaled_glyph = glyph_cache[cache_index]; + if (scaled_glyph == NULL || + _cairo_scaled_glyph_index (scaled_glyph) != glyph_index) + { + status = _cairo_scaled_glyph_lookup (info->font, glyph_index, + CAIRO_SCALED_GLYPH_INFO_SURFACE, + &scaled_glyph); + + if (unlikely (status)) + break; + + glyph_cache[cache_index] = scaled_glyph; + } + + glyph_surface = scaled_glyph->surface; + if (glyph_surface->width && glyph_surface->height) { + /* round glyph locations to the nearest pixel */ + /* XXX: FRAGILE: We're ignoring device_transform scaling here. A bug? */ + x = _cairo_lround (info->glyphs[i].x - + glyph_surface->base.device_transform.x0); + y = _cairo_lround (info->glyphs[i].y - + glyph_surface->base.device_transform.y0); + + pixman_image_composite32 (op, src, glyph_surface->pixman_image, dst, + x + src_x, y + src_y, + 0, 0, + x - dst_x, y - dst_y, + glyph_surface->width, + glyph_surface->height); + } + } + + return status; +} + +const cairo_compositor_t * +_cairo_image_traps_compositor_get (void) +{ + static cairo_traps_compositor_t compositor; + + if (compositor.base.delegate == NULL) { + _cairo_traps_compositor_init (&compositor, + &__cairo_no_compositor); + compositor.acquire = acquire; + compositor.release = release; + compositor.set_clip_region = set_clip_region; + compositor.pattern_to_surface = _cairo_image_source_create_for_pattern; + compositor.draw_image_boxes = draw_image_boxes; + //compositor.copy_boxes = copy_boxes; + compositor.fill_boxes = fill_boxes; + //compositor.check_composite = check_composite; + compositor.composite = composite; + compositor.lerp = lerp; + //compositor.check_composite_boxes = check_composite_boxes; + compositor.composite_boxes = composite_boxes; + //compositor.check_composite_traps = check_composite_traps; + compositor.composite_traps = composite_traps; + //compositor.check_composite_tristrip = check_composite_traps; + compositor.composite_tristrip = composite_tristrip; + compositor.check_composite_glyphs = check_composite_glyphs; + compositor.composite_glyphs = composite_glyphs; + } + + return &compositor.base; +} + +const cairo_compositor_t * +_cairo_image_mask_compositor_get (void) +{ + static cairo_mask_compositor_t compositor; + + if (compositor.base.delegate == NULL) { + _cairo_mask_compositor_init (&compositor, + _cairo_image_traps_compositor_get ()); + compositor.acquire = acquire; + compositor.release = release; + compositor.set_clip_region = set_clip_region; + compositor.pattern_to_surface = _cairo_image_source_create_for_pattern; + compositor.draw_image_boxes = draw_image_boxes; + compositor.fill_rectangles = fill_rectangles; + compositor.fill_boxes = fill_boxes; + //compositor.check_composite = check_composite; + compositor.composite = composite; + //compositor.lerp = lerp; + //compositor.check_composite_boxes = check_composite_boxes; + compositor.composite_boxes = composite_boxes; + compositor.check_composite_glyphs = check_composite_glyphs; + compositor.composite_glyphs = composite_glyphs; + } + + return &compositor.base; +} + +#if PIXMAN_HAS_COMPOSITOR +typedef struct _cairo_image_span_renderer { + cairo_span_renderer_t base; + + pixman_image_compositor_t *compositor; + pixman_image_t *src, *mask; + float opacity; + cairo_rectangle_int_t extents; +} cairo_image_span_renderer_t; +COMPILE_TIME_ASSERT (sizeof (cairo_image_span_renderer_t) <= sizeof (cairo_abstract_span_renderer_t)); + +static cairo_status_t +_cairo_image_bounded_opaque_spans (void *abstract_renderer, + int y, int height, + const cairo_half_open_span_t *spans, + unsigned num_spans) +{ + cairo_image_span_renderer_t *r = abstract_renderer; + + if (num_spans == 0) + return CAIRO_STATUS_SUCCESS; + + do { + if (spans[0].coverage) + pixman_image_compositor_blt (r->compositor, + spans[0].x, y, + spans[1].x - spans[0].x, height, + spans[0].coverage); + spans++; + } while (--num_spans > 1); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_image_bounded_spans (void *abstract_renderer, + int y, int height, + const cairo_half_open_span_t *spans, + unsigned num_spans) +{ + cairo_image_span_renderer_t *r = abstract_renderer; + + if (num_spans == 0) + return CAIRO_STATUS_SUCCESS; + + do { + if (spans[0].coverage) { + pixman_image_compositor_blt (r->compositor, + spans[0].x, y, + spans[1].x - spans[0].x, height, + r->opacity * spans[0].coverage); + } + spans++; + } while (--num_spans > 1); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_image_unbounded_spans (void *abstract_renderer, + int y, int height, + const cairo_half_open_span_t *spans, + unsigned num_spans) +{ + cairo_image_span_renderer_t *r = abstract_renderer; + + assert (y + height <= r->extents.height); + if (y > r->extents.y) { + pixman_image_compositor_blt (r->compositor, + r->extents.x, r->extents.y, + r->extents.width, y - r->extents.y, + 0); + } + + if (num_spans == 0) { + pixman_image_compositor_blt (r->compositor, + r->extents.x, y, + r->extents.width, height, + 0); + } else { + if (spans[0].x != r->extents.x) { + pixman_image_compositor_blt (r->compositor, + r->extents.x, y, + spans[0].x - r->extents.x, + height, + 0); + } + + do { + assert (spans[0].x < r->extents.x + r->extents.width); + pixman_image_compositor_blt (r->compositor, + spans[0].x, y, + spans[1].x - spans[0].x, height, + r->opacity * spans[0].coverage); + spans++; + } while (--num_spans > 1); + + if (spans[0].x != r->extents.x + r->extents.width) { + assert (spans[0].x < r->extents.x + r->extents.width); + pixman_image_compositor_blt (r->compositor, + spans[0].x, y, + r->extents.x + r->extents.width - spans[0].x, height, + 0); + } + } + + r->extents.y = y + height; + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_image_clipped_spans (void *abstract_renderer, + int y, int height, + const cairo_half_open_span_t *spans, + unsigned num_spans) +{ + cairo_image_span_renderer_t *r = abstract_renderer; + + assert (num_spans); + + do { + if (! spans[0].inverse) + pixman_image_compositor_blt (r->compositor, + spans[0].x, y, + spans[1].x - spans[0].x, height, + r->opacity * spans[0].coverage); + spans++; + } while (--num_spans > 1); + + r->extents.y = y + height; + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_image_finish_unbounded_spans (void *abstract_renderer) +{ + cairo_image_span_renderer_t *r = abstract_renderer; + + if (r->extents.y < r->extents.height) { + pixman_image_compositor_blt (r->compositor, + r->extents.x, r->extents.y, + r->extents.width, + r->extents.height - r->extents.y, + 0); + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +span_renderer_init (cairo_abstract_span_renderer_t *_r, + const cairo_composite_rectangles_t *composite, + cairo_bool_t needs_clip) +{ + cairo_image_span_renderer_t *r = (cairo_image_span_renderer_t *)_r; + cairo_image_surface_t *dst = (cairo_image_surface_t *)composite->surface; + const cairo_pattern_t *source = &composite->source_pattern.base; + cairo_operator_t op = composite->op; + int src_x, src_y; + int mask_x, mask_y; + + if (op == CAIRO_OPERATOR_CLEAR) { + source = &_cairo_pattern_white.base; + op = PIXMAN_OP_OUT_REVERSE; + } else if (dst->base.is_clear && + (op == CAIRO_OPERATOR_SOURCE || + op == CAIRO_OPERATOR_OVER || + op == CAIRO_OPERATOR_ADD)) { + op = PIXMAN_OP_SRC; + } else if (op == CAIRO_OPERATOR_SOURCE) { + op = PIXMAN_OP_LERP; + } else { + op = _pixman_operator (op); + } + + r->compositor = NULL; + r->mask = NULL; + r->src = _pixman_image_for_pattern (dst, source, FALSE, + &composite->unbounded, + &composite->source_sample_area, + &src_x, &src_y); + if (unlikely (r->src == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + r->opacity = 1.0; + if (composite->mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID) { + r->opacity = composite->mask_pattern.solid.color.alpha; + } else { + r->mask = _pixman_image_for_pattern (dst, + &composite->mask_pattern.base, + TRUE, + &composite->unbounded, + &composite->mask_sample_area, + &mask_x, &mask_y); + if (unlikely (r->mask == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + /* XXX Component-alpha? */ + if ((dst->base.content & CAIRO_CONTENT_COLOR) == 0 && + _cairo_pattern_is_opaque (source, &composite->source_sample_area)) + { + pixman_image_unref (r->src); + r->src = r->mask; + src_x = mask_x; + src_y = mask_y; + r->mask = NULL; + } + } + + if (composite->is_bounded) { + if (r->opacity == 1.) + r->base.render_rows = _cairo_image_bounded_opaque_spans; + else + r->base.render_rows = _cairo_image_bounded_spans; + r->base.finish = NULL; + } else { + if (needs_clip) + r->base.render_rows = _cairo_image_clipped_spans; + else + r->base.render_rows = _cairo_image_unbounded_spans; + r->base.finish = _cairo_image_finish_unbounded_spans; + r->extents = composite->unbounded; + r->extents.height += r->extents.y; + } + + r->compositor = + pixman_image_create_compositor (op, r->src, r->mask, dst->pixman_image, + composite->unbounded.x + src_x, + composite->unbounded.y + src_y, + composite->unbounded.x + mask_x, + composite->unbounded.y + mask_y, + composite->unbounded.x, + composite->unbounded.y, + composite->unbounded.width, + composite->unbounded.height); + if (unlikely (r->compositor == NULL)) + return CAIRO_INT_STATUS_NOTHING_TO_DO; + + return CAIRO_STATUS_SUCCESS; +} + +static void +span_renderer_fini (cairo_abstract_span_renderer_t *_r, + cairo_int_status_t status) +{ + cairo_image_span_renderer_t *r = (cairo_image_span_renderer_t *) _r; + + if (status == CAIRO_INT_STATUS_SUCCESS && r->base.finish) + r->base.finish (r); + + if (r->compositor) + pixman_image_compositor_destroy (r->compositor); + + if (r->src) + pixman_image_unref (r->src); + if (r->mask) + pixman_image_unref (r->mask); +} +#else +typedef struct _cairo_image_span_renderer { + cairo_span_renderer_t base; + + cairo_rectangle_int_t extents; + + float opacity; + int stride; + uint8_t *data; + + const cairo_composite_rectangles_t *composite; + pixman_image_t *src, *mask; + int src_x, src_y; + + uint8_t op; + + uint8_t buf[sizeof(cairo_abstract_span_renderer_t)-128]; +} cairo_image_span_renderer_t; +COMPILE_TIME_ASSERT (sizeof (cairo_image_span_renderer_t) <= sizeof (cairo_abstract_span_renderer_t)); + +static cairo_status_t +_cairo_image_spans (void *abstract_renderer, + int y, int height, + const cairo_half_open_span_t *spans, + unsigned num_spans) +{ + cairo_image_span_renderer_t *r = abstract_renderer; + uint8_t *mask, *row; + int len; + + if (num_spans == 0) + return CAIRO_STATUS_SUCCESS; + + mask = r->data + (y - r->extents.y) * r->stride; + mask += spans[0].x - r->extents.x; + row = mask; + + do { + len = spans[1].x - spans[0].x; + if (spans[0].coverage) { + *row++ = r->opacity * spans[0].coverage; + if (--len) + memset (row, row[-1], len); + } + row += len; + spans++; + } while (--num_spans > 1); + + len = row - mask; + row = mask; + while (--height) { + mask += r->stride; + memcpy (mask, row, len); + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_image_spans_and_zero (void *abstract_renderer, + int y, int height, + const cairo_half_open_span_t *spans, + unsigned num_spans) +{ + cairo_image_span_renderer_t *r = abstract_renderer; + uint8_t *mask; + int len; + + mask = r->data; + if (y > r->extents.y) { + len = (y - r->extents.y) * r->stride; + memset (mask, 0, len); + mask += len; + } + + r->extents.y = y + height; + r->data = mask + height * r->stride; + if (num_spans == 0) { + memset (mask, 0, height * r->stride); + } else { + uint8_t *row = mask; + + if (spans[0].x != r->extents.x) { + len = spans[0].x - r->extents.x; + memset (row, 0, len); + row += len; + } + + do { + len = spans[1].x - spans[0].x; + *row++ = r->opacity * spans[0].coverage; + if (len > 1) { + memset (row, row[-1], --len); + row += len; + } + spans++; + } while (--num_spans > 1); + + if (spans[0].x != r->extents.x + r->extents.width) { + len = r->extents.x + r->extents.width - spans[0].x; + memset (row, 0, len); + } + + row = mask; + while (--height) { + mask += r->stride; + memcpy (mask, row, r->extents.width); + } + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_image_finish_spans_and_zero (void *abstract_renderer) +{ + cairo_image_span_renderer_t *r = abstract_renderer; + + if (r->extents.y < r->extents.height) + memset (r->data, 0, (r->extents.height - r->extents.y) * r->stride); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +span_renderer_init (cairo_abstract_span_renderer_t *_r, + const cairo_composite_rectangles_t *composite, + cairo_bool_t needs_clip) +{ + cairo_image_span_renderer_t *r = (cairo_image_span_renderer_t *)_r; + cairo_image_surface_t *dst = (cairo_image_surface_t *)composite->surface; + const cairo_pattern_t *source = &composite->source_pattern.base; + cairo_operator_t op = composite->op; + + r->composite = composite; + r->mask = NULL; + r->src = NULL; + + if (needs_clip) + return CAIRO_INT_STATUS_UNSUPPORTED; + + if (op == CAIRO_OPERATOR_CLEAR) { + source = &_cairo_pattern_white.base; + op = PIXMAN_OP_OUT_REVERSE; + } else if (dst->base.is_clear && + (op == CAIRO_OPERATOR_SOURCE || + op == CAIRO_OPERATOR_OVER || + op == CAIRO_OPERATOR_ADD)) { + op = PIXMAN_OP_SRC; + } else if (op == CAIRO_OPERATOR_SOURCE) { +#if PIXMAN_HAS_OP_LERP + op = PIXMAN_OP_LERP; +#else + return CAIRO_INT_STATUS_UNSUPPORTED; +#endif + } else { + op = _pixman_operator (op); + } + r->op = op; + + r->src = _pixman_image_for_pattern (dst, source, FALSE, + &composite->unbounded, + &composite->source_sample_area, + &r->src_x, &r->src_y); + if (unlikely (r->src == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + r->opacity = 1.0; + if (composite->mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID) { + r->opacity = composite->mask_pattern.solid.color.alpha; + } else { + pixman_image_t *mask; + int mask_x, mask_y; + + mask = _pixman_image_for_pattern (dst, + &composite->mask_pattern.base, + TRUE, + &composite->unbounded, + &composite->mask_sample_area, + &mask_x, &mask_y); + if (unlikely (mask == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + /* XXX Component-alpha? */ + if ((dst->base.content & CAIRO_CONTENT_COLOR) == 0 && + _cairo_pattern_is_opaque (source, &composite->source_sample_area)) + { + pixman_image_unref (r->src); + r->src = mask; + r->src_x = mask_x; + r->src_y = mask_y; + mask = NULL; + } + + if (mask) { + pixman_image_unref (mask); + return CAIRO_INT_STATUS_UNSUPPORTED; + } + } + + r->extents = composite->unbounded; + r->stride = (r->extents.width + 3) & ~3; + if (r->extents.height * r->stride > (int)sizeof (r->buf)) { + r->mask = pixman_image_create_bits (PIXMAN_a8, + r->extents.width, + r->extents.height, + NULL, 0); + + r->base.render_rows = _cairo_image_spans; + r->base.finish = NULL; + } else { + r->mask = pixman_image_create_bits (PIXMAN_a8, + r->extents.width, + r->extents.height, + (uint32_t *)r->buf, r->stride); + + r->base.render_rows = _cairo_image_spans_and_zero; + r->base.finish = _cairo_image_finish_spans_and_zero; + } + if (unlikely (r->mask == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + r->data = (uint8_t *) pixman_image_get_data (r->mask); + r->stride = pixman_image_get_stride (r->mask); + + r->extents.height += r->extents.y; + return CAIRO_STATUS_SUCCESS; +} + +static void +span_renderer_fini (cairo_abstract_span_renderer_t *_r, + cairo_int_status_t status) +{ + cairo_image_span_renderer_t *r = (cairo_image_span_renderer_t *) _r; + + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + const cairo_composite_rectangles_t *composite = r->composite; + + if (r->base.finish) + r->base.finish (r); + + pixman_image_composite32 (r->op, r->src, r->mask, + to_pixman_image (composite->surface), + composite->unbounded.x + r->src_x, + composite->unbounded.y + r->src_y, + 0, 0, + composite->unbounded.x, + composite->unbounded.y, + composite->unbounded.width, + composite->unbounded.height); + } + + if (r->src) + pixman_image_unref (r->src); + if (r->mask) + pixman_image_unref (r->mask); +} +#endif + +const cairo_compositor_t * +_cairo_image_spans_compositor_get (void) +{ + static cairo_spans_compositor_t compositor; + + if (compositor.base.delegate == NULL) { + _cairo_spans_compositor_init (&compositor, + _cairo_image_traps_compositor_get()); + + //compositor.acquire = acquire; + //compositor.release = release; + compositor.fill_boxes = fill_boxes; + compositor.pattern_to_surface = _cairo_image_source_create_for_pattern; + //compositor.check_composite_boxes = check_composite_boxes; + compositor.composite_boxes = composite_boxes; + //compositor.check_span_renderer = check_span_renderer; + compositor.renderer_init = span_renderer_init; + compositor.renderer_fini = span_renderer_fini; + } + + return &compositor.base; +} diff --git a/src/cairo-image-mask-compositor.c b/src/cairo-image-mask-compositor.c new file mode 100644 index 00000000..33fd6dd8 --- /dev/null +++ b/src/cairo-image-mask-compositor.c @@ -0,0 +1,408 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2003 University of Southern California + * Copyright © 2009,2010,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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +/* This compositor is slightly pointless. Just exists for testing + * and as skeleton code. + */ + +#include "cairoint.h" + +#include "cairo-image-surface-private.h" + +#include "cairo-compositor-private.h" +#include "cairo-region-private.h" + +static cairo_int_status_t +acquire (void *abstract_dst) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +release (void *abstract_dst) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +set_clip_region (void *_surface, + cairo_region_t *region) +{ + cairo_image_surface_t *surface = _surface; + pixman_region32_t *rgn = region ? ®ion->rgn : NULL; + + if (! pixman_image_set_clip_region32 (surface->pixman_image, rgn)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_bool_t +has_snapshot (void *_dst, + const cairo_pattern_t *pattern) +{ + return FALSE; +} + +static cairo_int_status_t +draw_image (void *_dst, + cairo_image_surface_t *image, + int src_x, int src_y, + int width, int height, + int dst_x, int dst_y) +{ + cairo_image_surface_t *dst = (cairo_image_surface_t *)_dst; + + pixman_image_composite32 (PIXMAN_OP_SRC, + image->pixman_image, NULL, dst->pixman_image, + src_x, src_y, + 0, 0, + dst_x, dst_y, + width, height); + return CAIRO_STATUS_SUCCESS; +} + +static inline uint32_t +color_to_uint32 (const cairo_color_t *color) +{ + return + (color->alpha_short >> 8 << 24) | + (color->red_short >> 8 << 16) | + (color->green_short & 0xff00) | + (color->blue_short >> 8); +} + +static inline cairo_bool_t +color_to_pixel (const cairo_color_t *color, + double opacity, + pixman_format_code_t format, + uint32_t *pixel) +{ + cairo_color_t opacity_color; + uint32_t c; + + if (!(format == PIXMAN_a8r8g8b8 || + format == PIXMAN_x8r8g8b8 || + format == PIXMAN_a8b8g8r8 || + format == PIXMAN_x8b8g8r8 || + format == PIXMAN_b8g8r8a8 || + format == PIXMAN_b8g8r8x8 || + format == PIXMAN_r5g6b5 || + format == PIXMAN_b5g6r5 || + format == PIXMAN_a8)) + { + return FALSE; + } + + if (opacity != 1.0) { + _cairo_color_init_rgba (&opacity_color, + color->red, + color->green, + color->blue, + color->alpha * opacity); + color = &opacity_color; + } + c = color_to_uint32 (color); + + if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_ABGR) { + c = ((c & 0xff000000) >> 0) | + ((c & 0x00ff0000) >> 16) | + ((c & 0x0000ff00) >> 0) | + ((c & 0x000000ff) << 16); + } + + if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_BGRA) { + c = ((c & 0xff000000) >> 24) | + ((c & 0x00ff0000) >> 8) | + ((c & 0x0000ff00) << 8) | + ((c & 0x000000ff) << 24); + } + + if (format == PIXMAN_a8) { + c = c >> 24; + } else if (format == PIXMAN_r5g6b5 || format == PIXMAN_b5g6r5) { + c = ((((c) >> 3) & 0x001f) | + (((c) >> 5) & 0x07e0) | + (((c) >> 8) & 0xf800)); + } + + *pixel = c; + return TRUE; +} + +static cairo_int_status_t +fill_rectangles (void *_dst, + cairo_operator_t op, + const cairo_color_t *color, + cairo_rectangle_int_t *rects, + int num_rects) +{ + cairo_image_surface_t *dst = _dst; + uint32_t pixel; + int i; + + if (! color_to_pixel (color, 1.0, dst->pixman_format, &pixel)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + for (i = 0; i < num_rects; i++) { + pixman_fill ((uint32_t *) dst->data, dst->stride / sizeof (uint32_t), + PIXMAN_FORMAT_BPP (dst->pixman_format), + rects[i].x, rects[i].y, + rects[i].width, rects[i].height, + pixel); + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +fill_boxes (void *_dst, + cairo_operator_t op, + const cairo_color_t *color, + cairo_boxes_t *boxes) +{ + cairo_image_surface_t *dst = _dst; + struct _cairo_boxes_chunk *chunk; + uint32_t pixel; + int i; + + assert (boxes->is_pixel_aligned); + + if (! color_to_pixel (color, 1.0, dst->pixman_format, &pixel)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x); + int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y); + int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x); + int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y); + pixman_fill ((uint32_t *) dst->data, dst->stride / sizeof (uint32_t), + PIXMAN_FORMAT_BPP (dst->pixman_format), + x1, y1, x2 - x1, y2 - y1, + pixel); + } + } + + return CAIRO_STATUS_SUCCESS; +} + +static pixman_op_t +_pixman_operator (cairo_operator_t op) +{ + switch ((int) op) { + case CAIRO_OPERATOR_CLEAR: + return PIXMAN_OP_CLEAR; + + case CAIRO_OPERATOR_SOURCE: + return PIXMAN_OP_SRC; + case CAIRO_OPERATOR_OVER: + return PIXMAN_OP_OVER; + case CAIRO_OPERATOR_IN: + return PIXMAN_OP_IN; + case CAIRO_OPERATOR_OUT: + return PIXMAN_OP_OUT; + case CAIRO_OPERATOR_ATOP: + return PIXMAN_OP_ATOP; + + case CAIRO_OPERATOR_DEST: + return PIXMAN_OP_DST; + case CAIRO_OPERATOR_DEST_OVER: + return PIXMAN_OP_OVER_REVERSE; + case CAIRO_OPERATOR_DEST_IN: + return PIXMAN_OP_IN_REVERSE; + case CAIRO_OPERATOR_DEST_OUT: + return PIXMAN_OP_OUT_REVERSE; + case CAIRO_OPERATOR_DEST_ATOP: + return PIXMAN_OP_ATOP_REVERSE; + + case CAIRO_OPERATOR_XOR: + return PIXMAN_OP_XOR; + case CAIRO_OPERATOR_ADD: + return PIXMAN_OP_ADD; + case CAIRO_OPERATOR_SATURATE: + return PIXMAN_OP_SATURATE; + + case CAIRO_OPERATOR_MULTIPLY: + return PIXMAN_OP_MULTIPLY; + case CAIRO_OPERATOR_SCREEN: + return PIXMAN_OP_SCREEN; + case CAIRO_OPERATOR_OVERLAY: + return PIXMAN_OP_OVERLAY; + case CAIRO_OPERATOR_DARKEN: + return PIXMAN_OP_DARKEN; + case CAIRO_OPERATOR_LIGHTEN: + return PIXMAN_OP_LIGHTEN; + case CAIRO_OPERATOR_COLOR_DODGE: + return PIXMAN_OP_COLOR_DODGE; + case CAIRO_OPERATOR_COLOR_BURN: + return PIXMAN_OP_COLOR_BURN; + case CAIRO_OPERATOR_HARD_LIGHT: + return PIXMAN_OP_HARD_LIGHT; + case CAIRO_OPERATOR_SOFT_LIGHT: + return PIXMAN_OP_SOFT_LIGHT; + case CAIRO_OPERATOR_DIFFERENCE: + return PIXMAN_OP_DIFFERENCE; + case CAIRO_OPERATOR_EXCLUSION: + return PIXMAN_OP_EXCLUSION; + case CAIRO_OPERATOR_HSL_HUE: + return PIXMAN_OP_HSL_HUE; + case CAIRO_OPERATOR_HSL_SATURATION: + return PIXMAN_OP_HSL_SATURATION; + case CAIRO_OPERATOR_HSL_COLOR: + return PIXMAN_OP_HSL_COLOR; + case CAIRO_OPERATOR_HSL_LUMINOSITY: + return PIXMAN_OP_HSL_LUMINOSITY; + + default: + ASSERT_NOT_REACHED; + return PIXMAN_OP_OVER; + } +} + +static cairo_int_status_t +composite (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height) +{ + cairo_image_surface_t *dst = _dst; + cairo_pixman_source_t *src = (cairo_pixman_source_t *)abstract_src; + cairo_pixman_source_t *mask = (cairo_pixman_source_t *)abstract_mask; + if (mask) { + pixman_image_composite32 (_pixman_operator (op), + src->pixman_image, mask->pixman_image, dst->pixman_image, + src_x, src_y, + mask_x, mask_y, + dst_x, dst_y, + width, height); + } else { + pixman_image_composite32 (_pixman_operator (op), + src->pixman_image, NULL, dst->pixman_image, + src_x, src_y, + 0, 0, + dst_x, dst_y, + width, height); + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_boxes (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + cairo_boxes_t *boxes) +{ + cairo_image_surface_t *dst = _dst; + cairo_pixman_source_t *src = (cairo_pixman_source_t *)abstract_src; + cairo_pixman_source_t *mask = (cairo_pixman_source_t *)abstract_mask; + struct _cairo_boxes_chunk *chunk; + int i; + + assert (boxes->is_pixel_aligned); + + op = _pixman_operator (op); + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x); + int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y); + int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x); + int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y); + + if (mask) { + pixman_image_composite32 (op, + src->pixman_image, mask->pixman_image, dst->pixman_image, + x1 + src_x, y1 + src_y, + x1 + mask_x, y1 + mask_y, + x1 + dst_x, y1 + dst_y, + x2 - x1, y2 - y1); + } else { + pixman_image_composite32 (op, + src->pixman_image, NULL, dst->pixman_image, + x1 + src_x, y1 + src_y, + 0, 0, + x1 + dst_x, y1 + dst_y, + x2 - x1, y2 - y1); + } + } + } + + return CAIRO_STATUS_SUCCESS; +} + +const cairo_compositor_t * +_cairo_image_mask_compositor_get (void) +{ + static cairo_mask_compositor_t compositor; + + if (compositor.base.delegate == NULL) { + _cairo_mask_compositor_init (&compositor, + _cairo_image_traps_compositor_get ()); + compositor.acquire = acquire; + compositor.release = release; + compositor.set_clip_region = set_clip_region; + compositor.pattern_to_surface = _cairo_pixman_source_create_for_pattern; + compositor.has_snapshot = has_snapshot; + compositor.draw_image = draw_image; + compositor.fill_rectangles = fill_rectangles; + compositor.fill_boxes = fill_boxes; + //compositor.check_composite = check_composite; + compositor.composite = composite; + //compositor.check_composite_boxes = check_composite_boxes; + compositor.composite_boxes = composite_boxes; + } + + return &compositor.base; +} diff --git a/src/cairo-image-source.c b/src/cairo-image-source.c new file mode 100644 index 00000000..7c1eb826 --- /dev/null +++ b/src/cairo-image-source.c @@ -0,0 +1,975 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2003 University of Southern California + * Copyright © 2009,2010,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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +/* The purpose of this file/surface is to simply translate a pattern + * to a pixman_image_t and thence to feed it back to the general + * compositor interface. + */ + +#include "cairoint.h" + +#include "cairo-image-surface-private.h" + +#include "cairo-compositor-private.h" +#include "cairo-error-private.h" +#include "cairo-pattern-private.h" +#include "cairo-paginated-private.h" +#include "cairo-recording-surface-private.h" +#include "cairo-surface-observer-private.h" +#include "cairo-surface-snapshot-private.h" +#include "cairo-surface-subsurface-private.h" + +#define PIXMAN_MAX_INT ((pixman_fixed_1 >> 1) - pixman_fixed_e) /* need to ensure deltas also fit */ + +#if CAIRO_NO_MUTEX +#define PIXMAN_HAS_ATOMIC_OPS 1 +#endif + +#if PIXMAN_HAS_ATOMIC_OPS +static pixman_image_t *__pixman_transparent_image; +static pixman_image_t *__pixman_black_image; +static pixman_image_t *__pixman_white_image; + +static pixman_image_t * +_pixman_transparent_image (void) +{ + pixman_image_t *image; + + image = __pixman_transparent_image; + if (unlikely (image == NULL)) { + pixman_color_t color; + + color.red = 0x00; + color.green = 0x00; + color.blue = 0x00; + color.alpha = 0x00; + + image = pixman_image_create_solid_fill (&color); + if (unlikely (image == NULL)) + return NULL; + + if (_cairo_atomic_ptr_cmpxchg (&__pixman_transparent_image, + NULL, image)) + { + pixman_image_ref (image); + } + } else { + pixman_image_ref (image); + } + + return image; +} + +static pixman_image_t * +_pixman_black_image (void) +{ + pixman_image_t *image; + + image = __pixman_black_image; + if (unlikely (image == NULL)) { + pixman_color_t color; + + color.red = 0x00; + color.green = 0x00; + color.blue = 0x00; + color.alpha = 0xffff; + + image = pixman_image_create_solid_fill (&color); + if (unlikely (image == NULL)) + return NULL; + + if (_cairo_atomic_ptr_cmpxchg (&__pixman_black_image, + NULL, image)) + { + pixman_image_ref (image); + } + } else { + pixman_image_ref (image); + } + + return image; +} + +static pixman_image_t * +_pixman_white_image (void) +{ + pixman_image_t *image; + + image = __pixman_white_image; + if (unlikely (image == NULL)) { + pixman_color_t color; + + color.red = 0xffff; + color.green = 0xffff; + color.blue = 0xffff; + color.alpha = 0xffff; + + image = pixman_image_create_solid_fill (&color); + if (unlikely (image == NULL)) + return NULL; + + if (_cairo_atomic_ptr_cmpxchg (&__pixman_white_image, + NULL, image)) + { + pixman_image_ref (image); + } + } else { + pixman_image_ref (image); + } + + return image; +} + +static uint32_t +hars_petruska_f54_1_random (void) +{ +#define rol(x,k) ((x << k) | (x >> (32-k))) + static uint32_t x; + return x = (x ^ rol (x, 5) ^ rol (x, 24)) + 0x37798849; +#undef rol +} + +static struct { + cairo_color_t color; + pixman_image_t *image; +} cache[16]; +static int n_cached; + +#else /* !PIXMAN_HAS_ATOMIC_OPS */ +static pixman_image_t * +_pixman_transparent_image (void) +{ + return _pixman_image_for_color (CAIRO_COLOR_TRANSPARENT); +} + +static pixman_image_t * +_pixman_black_image (void) +{ + return _pixman_image_for_color (CAIRO_COLOR_BLACK); +} + +static pixman_image_t * +_pixman_white_image (void) +{ + return _pixman_image_for_color (CAIRO_COLOR_WHITE); +} +#endif /* !PIXMAN_HAS_ATOMIC_OPS */ + + +pixman_image_t * +_pixman_image_for_color (const cairo_color_t *cairo_color) +{ + pixman_color_t color; + pixman_image_t *image; + +#if PIXMAN_HAS_ATOMIC_OPS + int i; + + if (CAIRO_COLOR_IS_CLEAR (cairo_color)) + return _pixman_transparent_image (); + + if (CAIRO_COLOR_IS_OPAQUE (cairo_color)) { + if (cairo_color->red_short <= 0x00ff && + cairo_color->green_short <= 0x00ff && + cairo_color->blue_short <= 0x00ff) + { + return _pixman_black_image (); + } + + if (cairo_color->red_short >= 0xff00 && + cairo_color->green_short >= 0xff00 && + cairo_color->blue_short >= 0xff00) + { + return _pixman_white_image (); + } + } + + CAIRO_MUTEX_LOCK (_cairo_image_solid_cache_mutex); + for (i = 0; i < n_cached; i++) { + if (_cairo_color_equal (&cache[i].color, cairo_color)) { + image = pixman_image_ref (cache[i].image); + goto UNLOCK; + } + } +#endif + + color.red = cairo_color->red_short; + color.green = cairo_color->green_short; + color.blue = cairo_color->blue_short; + color.alpha = cairo_color->alpha_short; + + image = pixman_image_create_solid_fill (&color); +#if PIXMAN_HAS_ATOMIC_OPS + if (image == NULL) + goto UNLOCK; + + if (n_cached < ARRAY_LENGTH (cache)) { + i = n_cached++; + } else { + i = hars_petruska_f54_1_random () % ARRAY_LENGTH (cache); + pixman_image_unref (cache[i].image); + } + cache[i].image = pixman_image_ref (image); + cache[i].color = *cairo_color; + +UNLOCK: + CAIRO_MUTEX_UNLOCK (_cairo_image_solid_cache_mutex); +#endif + return image; +} + + +void +_cairo_image_reset_static_data (void) +{ +#if PIXMAN_HAS_ATOMIC_OPS + while (n_cached) + pixman_image_unref (cache[--n_cached].image); + + if (__pixman_transparent_image) { + pixman_image_unref (__pixman_transparent_image); + __pixman_transparent_image = NULL; + } + + if (__pixman_black_image) { + pixman_image_unref (__pixman_black_image); + __pixman_black_image = NULL; + } + + if (__pixman_white_image) { + pixman_image_unref (__pixman_white_image); + __pixman_white_image = NULL; + } +#endif +} + +static pixman_image_t * +_pixman_image_for_gradient (const cairo_gradient_pattern_t *pattern, + const cairo_rectangle_int_t *extents, + int *ix, int *iy) +{ + pixman_image_t *pixman_image; + pixman_gradient_stop_t pixman_stops_static[2]; + pixman_gradient_stop_t *pixman_stops = pixman_stops_static; + pixman_transform_t pixman_transform; + cairo_matrix_t matrix; + cairo_circle_double_t extremes[2]; + pixman_point_fixed_t p1, p2; + unsigned int i; + cairo_int_status_t status; + + if (pattern->n_stops > ARRAY_LENGTH(pixman_stops_static)) { + pixman_stops = _cairo_malloc_ab (pattern->n_stops, + sizeof(pixman_gradient_stop_t)); + if (unlikely (pixman_stops == NULL)) + return NULL; + } + + for (i = 0; i < pattern->n_stops; i++) { + pixman_stops[i].x = _cairo_fixed_16_16_from_double (pattern->stops[i].offset); + pixman_stops[i].color.red = pattern->stops[i].color.red_short; + pixman_stops[i].color.green = pattern->stops[i].color.green_short; + pixman_stops[i].color.blue = pattern->stops[i].color.blue_short; + pixman_stops[i].color.alpha = pattern->stops[i].color.alpha_short; + } + + _cairo_gradient_pattern_fit_to_range (pattern, PIXMAN_MAX_INT >> 1, &matrix, extremes); + + p1.x = _cairo_fixed_16_16_from_double (extremes[0].center.x); + p1.y = _cairo_fixed_16_16_from_double (extremes[0].center.y); + p2.x = _cairo_fixed_16_16_from_double (extremes[1].center.x); + p2.y = _cairo_fixed_16_16_from_double (extremes[1].center.y); + + if (pattern->base.type == CAIRO_PATTERN_TYPE_LINEAR) { + pixman_image = pixman_image_create_linear_gradient (&p1, &p2, + pixman_stops, + pattern->n_stops); + } else { + pixman_fixed_t r1, r2; + + r1 = _cairo_fixed_16_16_from_double (extremes[0].radius); + r2 = _cairo_fixed_16_16_from_double (extremes[1].radius); + + pixman_image = pixman_image_create_radial_gradient (&p1, &p2, r1, r2, + pixman_stops, + pattern->n_stops); + } + + if (pixman_stops != pixman_stops_static) + free (pixman_stops); + + if (unlikely (pixman_image == NULL)) + return NULL; + + *ix = *iy = 0; + status = _cairo_matrix_to_pixman_matrix_offset (&matrix, pattern->base.filter, + extents->x + extents->width/2., + extents->y + extents->height/2., + &pixman_transform, ix, iy); + if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) { + if (unlikely (status != CAIRO_INT_STATUS_SUCCESS) || + ! pixman_image_set_transform (pixman_image, &pixman_transform)) + { + pixman_image_unref (pixman_image); + return NULL; + } + } + + { + pixman_repeat_t pixman_repeat; + + switch (pattern->base.extend) { + default: + case CAIRO_EXTEND_NONE: + pixman_repeat = PIXMAN_REPEAT_NONE; + break; + case CAIRO_EXTEND_REPEAT: + pixman_repeat = PIXMAN_REPEAT_NORMAL; + break; + case CAIRO_EXTEND_REFLECT: + pixman_repeat = PIXMAN_REPEAT_REFLECT; + break; + case CAIRO_EXTEND_PAD: + pixman_repeat = PIXMAN_REPEAT_PAD; + break; + } + + pixman_image_set_repeat (pixman_image, pixman_repeat); + } + + return pixman_image; +} + +static pixman_image_t * +_pixman_image_for_mesh (const cairo_mesh_pattern_t *pattern, + const cairo_rectangle_int_t *extents, + int *tx, int *ty) +{ + pixman_image_t *image; + int width, height; + + *tx = -extents->x; + *ty = -extents->y; + width = extents->width; + height = extents->height; + + image = pixman_image_create_bits (PIXMAN_a8r8g8b8, width, height, NULL, 0); + if (unlikely (image == NULL)) + return NULL; + + _cairo_mesh_pattern_rasterize (pattern, + pixman_image_get_data (image), + width, height, + pixman_image_get_stride (image), + *tx, *ty); + return image; +} + +struct acquire_source_cleanup { + cairo_surface_t *surface; + cairo_image_surface_t *image; + void *image_extra; +}; + +static void +_acquire_source_cleanup (pixman_image_t *pixman_image, + void *closure) +{ + struct acquire_source_cleanup *data = closure; + + _cairo_surface_release_source_image (data->surface, + data->image, + data->image_extra); + free (data); +} + +static uint16_t +expand_channel (uint16_t v, uint32_t bits) +{ + int offset = 16 - bits; + while (offset > 0) { + v |= v >> bits; + offset -= bits; + bits += bits; + } + return v; +} + +static pixman_image_t * +_pixel_to_solid (cairo_image_surface_t *image, int x, int y) +{ + uint32_t pixel; + pixman_color_t color; + + switch (image->format) { + default: + case CAIRO_FORMAT_INVALID: + ASSERT_NOT_REACHED; + return NULL; + + case CAIRO_FORMAT_A1: + pixel = *(uint8_t *) (image->data + y * image->stride + x/8); + return pixel & (1 << (x&7)) ? _pixman_black_image () : _pixman_transparent_image (); + + case CAIRO_FORMAT_A8: + color.alpha = *(uint8_t *) (image->data + y * image->stride + x); + color.alpha |= color.alpha << 8; + if (color.alpha == 0) + return _pixman_transparent_image (); + if (color.alpha == 0xffff) + return _pixman_black_image (); + + color.red = color.green = color.blue = 0; + return pixman_image_create_solid_fill (&color); + + case CAIRO_FORMAT_RGB16_565: + pixel = *(uint16_t *) (image->data + y * image->stride + 2 * x); + if (pixel == 0) + return _pixman_black_image (); + if (pixel == 0xffff) + return _pixman_white_image (); + + color.alpha = 0xffff; + color.red = expand_channel ((pixel >> 11 & 0x1f) << 11, 5); + color.green = expand_channel ((pixel >> 5 & 0x3f) << 10, 6); + color.blue = expand_channel ((pixel & 0x1f) << 11, 5); + return pixman_image_create_solid_fill (&color); + + case CAIRO_FORMAT_RGB30: + pixel = *(uint32_t *) (image->data + y * image->stride + 4 * x); + pixel &= 0x3fffffff; /* ignore alpha bits */ + if (pixel == 0) + return _pixman_black_image (); + if (pixel == 0x3fffffff) + return _pixman_white_image (); + + /* convert 10bpc to 16bpc */ + color.alpha = 0xffff; + color.red = expand_channel((pixel >> 20) & 0x3fff, 10); + color.green = expand_channel((pixel >> 10) & 0x3fff, 10); + color.blue = expand_channel(pixel & 0x3fff, 10); + return pixman_image_create_solid_fill (&color); + + case CAIRO_FORMAT_ARGB32: + case CAIRO_FORMAT_RGB24: + pixel = *(uint32_t *) (image->data + y * image->stride + 4 * x); + color.alpha = image->format == CAIRO_FORMAT_ARGB32 ? (pixel >> 24) | (pixel >> 16 & 0xff00) : 0xffff; + if (color.alpha == 0) + return _pixman_transparent_image (); + if (pixel == 0xffffffff) + return _pixman_white_image (); + if (color.alpha == 0xffff && (pixel & 0xffffff) == 0) + return _pixman_black_image (); + + color.red = (pixel >> 16 & 0xff) | (pixel >> 8 & 0xff00); + color.green = (pixel >> 8 & 0xff) | (pixel & 0xff00); + color.blue = (pixel & 0xff) | (pixel << 8 & 0xff00); + return pixman_image_create_solid_fill (&color); + } +} + +static cairo_bool_t +_pixman_image_set_properties (pixman_image_t *pixman_image, + const cairo_pattern_t *pattern, + const cairo_rectangle_int_t *extents, + int *ix,int *iy) +{ + pixman_transform_t pixman_transform; + cairo_int_status_t status; + + status = _cairo_matrix_to_pixman_matrix_offset (&pattern->matrix, + pattern->filter, + extents->x + extents->width/2., + extents->y + extents->height/2., + &pixman_transform, ix, iy); + if (status == CAIRO_INT_STATUS_NOTHING_TO_DO) + { + /* If the transform is an identity, we don't need to set it + * and we can use any filtering, so choose the fastest one. */ + pixman_image_set_filter (pixman_image, PIXMAN_FILTER_NEAREST, NULL, 0); + } + else if (unlikely (status != CAIRO_INT_STATUS_SUCCESS || + ! pixman_image_set_transform (pixman_image, + &pixman_transform))) + { + return FALSE; + } + else + { + pixman_filter_t pixman_filter; + + switch (pattern->filter) { + case CAIRO_FILTER_FAST: + pixman_filter = PIXMAN_FILTER_FAST; + break; + case CAIRO_FILTER_GOOD: + pixman_filter = PIXMAN_FILTER_GOOD; + break; + case CAIRO_FILTER_BEST: + pixman_filter = PIXMAN_FILTER_BEST; + break; + case CAIRO_FILTER_NEAREST: + pixman_filter = PIXMAN_FILTER_NEAREST; + break; + case CAIRO_FILTER_BILINEAR: + pixman_filter = PIXMAN_FILTER_BILINEAR; + break; + case CAIRO_FILTER_GAUSSIAN: + /* XXX: The GAUSSIAN value has no implementation in cairo + * whatsoever, so it was really a mistake to have it in the + * API. We could fix this by officially deprecating it, or + * else inventing semantics and providing an actual + * implementation for it. */ + default: + pixman_filter = PIXMAN_FILTER_BEST; + } + + pixman_image_set_filter (pixman_image, pixman_filter, NULL, 0); + } + + { + pixman_repeat_t pixman_repeat; + + switch (pattern->extend) { + default: + case CAIRO_EXTEND_NONE: + pixman_repeat = PIXMAN_REPEAT_NONE; + break; + case CAIRO_EXTEND_REPEAT: + pixman_repeat = PIXMAN_REPEAT_NORMAL; + break; + case CAIRO_EXTEND_REFLECT: + pixman_repeat = PIXMAN_REPEAT_REFLECT; + break; + case CAIRO_EXTEND_PAD: + pixman_repeat = PIXMAN_REPEAT_PAD; + break; + } + + pixman_image_set_repeat (pixman_image, pixman_repeat); + } + + if (pattern->has_component_alpha) + pixman_image_set_component_alpha (pixman_image, TRUE); + + return TRUE; +} + +static pixman_image_t * +_pixman_image_for_recording (cairo_image_surface_t *dst, + const cairo_surface_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *ix, int *iy) +{ + cairo_surface_t *source, *clone; + cairo_rectangle_int_t limit; + pixman_image_t *pixman_image; + cairo_status_t status; + cairo_extend_t extend; + cairo_matrix_t *m, matrix; + int tx = 0, ty = 0; + + *ix = *iy = 0; + + source = pattern->surface; + if (_cairo_surface_is_subsurface (source)) + source = _cairo_surface_subsurface_get_target_with_offset (source, &tx, &ty); + if (_cairo_surface_is_snapshot (source)) + source = _cairo_surface_snapshot_get_target (source); + if (_cairo_surface_is_observer (source)) + source = _cairo_surface_observer_get_target (source); + if (_cairo_surface_is_paginated (source)) + source = _cairo_paginated_surface_get_target (source); + + extend = pattern->base.extend; + if (_cairo_surface_get_extents (source, &limit)) { + if (sample->x >= limit.x && + sample->y >= limit.y && + sample->x + sample->width <= limit.x + limit.width && + sample->y + sample->height <= limit.y + limit.height) + { + extend = CAIRO_EXTEND_NONE; + } + else if (extend == CAIRO_EXTEND_NONE && + (sample->x + sample->width <= limit.x || + sample->x >= limit.x + limit.width || + sample->y + sample->height <= limit.y || + sample->y >= limit.y + limit.height)) + { + return _pixman_transparent_image (); + } + } else + extend = CAIRO_EXTEND_NONE; + + if (extents == CAIRO_EXTEND_NONE) + limit = *extents; + + clone = cairo_image_surface_create (dst->format, limit.width, limit.height); + cairo_surface_set_device_offset (clone, limit.x, limit.y); + + m = NULL; + if (extend == CAIRO_EXTEND_NONE) { + m = &matrix; + cairo_matrix_multiply (m, + &dst->base.device_transform, + &pattern->base.matrix); + if (tx | ty) + cairo_matrix_translate (m, tx, ty); + } else { + /* XXX extract scale factor for repeating patterns */ + } + + status = _cairo_recording_surface_replay_with_clip (source, m, clone, NULL); + if (unlikely (status)) { + cairo_surface_destroy (clone); + return NULL; + } + + pixman_image = pixman_image_ref (((cairo_image_surface_t *)clone)->pixman_image); + cairo_surface_destroy (clone); + + if (extend != CAIRO_EXTEND_NONE) { + if (! _pixman_image_set_properties (pixman_image, + &pattern->base, extents, + ix, iy)) { + pixman_image_unref (pixman_image); + pixman_image= NULL; + } + } + + + return pixman_image; +} + +static pixman_image_t * +_pixman_image_for_surface (cairo_image_surface_t *dst, + const cairo_surface_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *ix, int *iy) +{ + cairo_extend_t extend = pattern->base.extend; + pixman_image_t *pixman_image; + + *ix = *iy = 0; + pixman_image = NULL; + if (pattern->surface->type == CAIRO_SURFACE_TYPE_RECORDING) + return _pixman_image_for_recording(dst, pattern, + is_mask, extents, sample, + ix, iy); + + if (pattern->surface->type == CAIRO_SURFACE_TYPE_IMAGE && + (! is_mask || ! pattern->base.has_component_alpha || + (pattern->surface->content & CAIRO_CONTENT_COLOR) == 0)) + { + cairo_image_surface_t *source = (cairo_image_surface_t *) pattern->surface; + cairo_surface_type_t type; + + if (_cairo_surface_is_snapshot (&source->base)) + source = (cairo_image_surface_t *) _cairo_surface_snapshot_get_target (&source->base); + + type = source->base.backend->type; + if (type == CAIRO_SURFACE_TYPE_IMAGE) { + if (extend != CAIRO_EXTEND_NONE && + sample->x >= 0 && + sample->y >= 0 && + sample->x + sample->width <= source->width && + sample->y + sample->height <= source->height) + { + extend = CAIRO_EXTEND_NONE; + } + + if (sample->width == 1 && sample->height == 1) { + if (sample->x < 0 || + sample->y < 0 || + sample->x >= source->width || + sample->y >= source->height) + { + if (extend == CAIRO_EXTEND_NONE) + return _pixman_transparent_image (); + } + else + { + pixman_image = _pixel_to_solid (source, + sample->x, sample->y); + if (pixman_image) + return pixman_image; + } + } + +#if PIXMAN_HAS_ATOMIC_OPS + /* avoid allocating a 'pattern' image if we can reuse the original */ + *ix = *iy = 0; + if (extend == CAIRO_EXTEND_NONE && + _cairo_matrix_is_pixman_translation (&pattern->base.matrix, + pattern->base.filter, + ix, iy)) + { + return pixman_image_ref (source->pixman_image); + } +#endif + + pixman_image = pixman_image_create_bits (source->pixman_format, + source->width, + source->height, + (uint32_t *) source->data, + source->stride); + if (unlikely (pixman_image == NULL)) + return NULL; + } else if (type == CAIRO_SURFACE_TYPE_SUBSURFACE) { + cairo_surface_subsurface_t *sub; + cairo_bool_t is_contained = FALSE; + + sub = (cairo_surface_subsurface_t *) source; + source = (cairo_image_surface_t *) sub->target; + + if (sample->x >= 0 && + sample->y >= 0 && + sample->x + sample->width <= sub->extents.width && + sample->y + sample->height <= sub->extents.height) + { + is_contained = TRUE; + } + + if (sample->width == 1 && sample->height == 1) { + if (is_contained) { + pixman_image = _pixel_to_solid (source, + sub->extents.x + sample->x, + sub->extents.y + sample->y); + if (pixman_image) + return pixman_image; + } else { + if (extend == CAIRO_EXTEND_NONE) + return _pixman_transparent_image (); + } + } + +#if PIXMAN_HAS_ATOMIC_OPS + *ix = sub->extents.x; + *iy = sub->extents.y; + if (is_contained && + _cairo_matrix_is_pixman_translation (&pattern->base.matrix, + pattern->base.filter, + ix, iy)) + { + return pixman_image_ref (source->pixman_image); + } +#endif + + /* Avoid sub-byte offsets, force a copy in that case. */ + if (PIXMAN_FORMAT_BPP (source->pixman_format) >= 8) { + void *data = source->data + + sub->extents.x * PIXMAN_FORMAT_BPP(source->pixman_format)/8 + + sub->extents.y * source->stride; + pixman_image = pixman_image_create_bits (source->pixman_format, + sub->extents.width, + sub->extents.height, + data, + source->stride); + if (unlikely (pixman_image == NULL)) + return NULL; + } + } + } + +#if PIXMAN_HAS_ATOMIC_OPS + *ix = *iy = 0; +#endif + if (pixman_image == NULL) { + struct acquire_source_cleanup *cleanup; + cairo_image_surface_t *image; + void *extra; + cairo_status_t status; + + status = _cairo_surface_acquire_source_image (pattern->surface, &image, &extra); + if (unlikely (status)) + return NULL; + + if (sample->x >= 0 && sample->y >= 0 && + sample->x + sample->width <= image->width && + sample->y + sample->height <= image->height) + { + extend = CAIRO_EXTEND_NONE; + } + + if (sample->width == 1 && sample->height == 1) { + if (sample->x < 0 || + sample->y < 0 || + sample->x >= image->width || + sample->y >= image->height) + { + if (extend == CAIRO_EXTEND_NONE) { + pixman_image = _pixman_transparent_image (); + _cairo_surface_release_source_image (pattern->surface, image, extra); + return pixman_image; + } + } + else + { + pixman_image = _pixel_to_solid (image, sample->x, sample->y); + if (pixman_image) { + _cairo_surface_release_source_image (pattern->surface, image, extra); + return pixman_image; + } + } + } + + pixman_image = pixman_image_create_bits (image->pixman_format, + image->width, + image->height, + (uint32_t *) image->data, + image->stride); + if (unlikely (pixman_image == NULL)) { + _cairo_surface_release_source_image (pattern->surface, image, extra); + return NULL; + } + + cleanup = malloc (sizeof (*cleanup)); + if (unlikely (cleanup == NULL)) { + _cairo_surface_release_source_image (pattern->surface, image, extra); + pixman_image_unref (pixman_image); + return NULL; + } + + cleanup->surface = pattern->surface; + cleanup->image = image; + cleanup->image_extra = extra; + pixman_image_set_destroy_function (pixman_image, + _acquire_source_cleanup, cleanup); + } + + if (! _pixman_image_set_properties (pixman_image, + &pattern->base, extents, + ix, iy)) { + pixman_image_unref (pixman_image); + pixman_image= NULL; + } + + return pixman_image; +} + +pixman_image_t * +_pixman_image_for_pattern (cairo_image_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *tx, int *ty) +{ + *tx = *ty = 0; + + if (pattern == NULL) + return _pixman_white_image (); + + switch (pattern->type) { + default: + ASSERT_NOT_REACHED; + case CAIRO_PATTERN_TYPE_SOLID: + return _pixman_image_for_color (&((const cairo_solid_pattern_t *) pattern)->color); + + case CAIRO_PATTERN_TYPE_RADIAL: + case CAIRO_PATTERN_TYPE_LINEAR: + return _pixman_image_for_gradient ((const cairo_gradient_pattern_t *) pattern, + extents, tx, ty); + + case CAIRO_PATTERN_TYPE_MESH: + return _pixman_image_for_mesh ((const cairo_mesh_pattern_t *) pattern, + extents, tx, ty); + + case CAIRO_PATTERN_TYPE_SURFACE: + return _pixman_image_for_surface (dst, + (const cairo_surface_pattern_t *) pattern, + is_mask, extents, sample, + tx, ty); + + } +} + +static cairo_status_t +_cairo_image_source_finish (void *abstract_surface) +{ + cairo_image_source_t *source = abstract_surface; + + pixman_image_unref (source->pixman_image); + return CAIRO_STATUS_SUCCESS; +} + +static const cairo_surface_backend_t cairo_image_source_backend = { + CAIRO_SURFACE_TYPE_IMAGE, + _cairo_image_source_finish, + NULL, /* read-only wrapper */ +}; + +cairo_surface_t * +_cairo_image_source_create_for_pattern (cairo_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y) +{ + cairo_image_source_t *source; + + source = malloc (sizeof (cairo_image_source_t)); + if (unlikely (source == NULL)) + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + + source->pixman_image = + _pixman_image_for_pattern ((cairo_image_surface_t *)dst, + pattern, is_mask, + extents, sample, + src_x, src_y); + if (unlikely (source->pixman_image == NULL)) { + free (source); + return _cairo_surface_create_in_error (CAIRO_STATUS_NO_MEMORY); + } + + _cairo_surface_init (&source->base, + &cairo_image_source_backend, + NULL, /* device */ + CAIRO_CONTENT_COLOR_ALPHA); + + source->is_opaque_solid = + pattern == NULL || _cairo_pattern_is_opaque_solid (pattern); + + return &source->base; +} diff --git a/src/cairo-image-spans-compositor.c b/src/cairo-image-spans-compositor.c new file mode 100644 index 00000000..5718b555 --- /dev/null +++ b/src/cairo-image-spans-compositor.c @@ -0,0 +1,131 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2003 University of Southern California + * Copyright © 2009,2010,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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#include "cairoint.h" + +#include "cairo-compositor-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-spans-compositor-private.h" + +typedef struct _cairo_image_span_renderer { + cairo_span_renderer_t base; + + pixman_image_compositor_t *compositor; + pixman_image_t *src; + float opacity; + cairo_rectangle_int_t extents; +} cairo_image_span_renderer_t; + +static cairo_status_t +_cairo_image_span_renderer_init (cairo_abstract_span_renderer_t *_r, + cairo_surface_t *dst, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, int src_y; + float opacity, + const cairo_composite_rectangles_t *composite, + cairo_bool_t needs_clip) +{ + cairo_image_span_renderer_t *r = (cairo_image_span_renderer_t *)_r; + cairo_pixman_source_t *src = (cairo_pixman_source_t *)_src; + int src_x, src_y; + + if (op == CAIRO_OPERATOR_CLEAR) { + op = CAIRO_OPERATOR_DEST_OUT; + pattern = NULL; + } + + r->src = ((cairo_pixman_source_t *) src)->pixman_image; + r->opacity = opacity; + + if (composite->is_bounded) { + if (opacity == 1.) + r->base.render_rows = _cairo_image_bounded_opaque_spans; + else + r->base.render_rows = _cairo_image_bounded_spans; + r->base.finish = NULL; + } else { + if (needs_clip) + r->base.render_rows = _cairo_image_clipped_spans; + else + r->base.render_rows = _cairo_image_unbounded_spans; + r->base.finish = _cairo_image_finish_unbounded_spans; + r->extents = composite->unbounded; + r->extents.height += r->extents.y; + + } + r->compositor = + pixman_image_create_compositor (_pixman_operator (op), + r->src, NULL, dst->pixman_image, + composite->bounded.x + src_x, + composite->bounded.y + src_y, + 0, 0, + composite->bounded.x, + composite->bounded.y, + composite->bounded.width, + composite->bounded.height); + if (unlikely (r->compositor == NULL)) + return CAIRO_INT_STATUS_NOTHING_TO_DO; + + return CAIRO_STATUS_SUCCESS; +} + +static void +_cairo_image_span_renderer_fini (cairo_abstract_span_renderer_t *_r) +{ + cairo_image_span_renderer_t *r = (cairo_image_span_renderer_t *) r; + pixman_image_compositor_destroy (r->compositor); +} + +const cairo_compositor_t * +_cairo_image_spans_compositor_get (void) +{ + static cairo_spans_compositor_t compositor; + + if (compositor.base.delegate == NULL) { + /* Can't fallback to the mask compositor as that will simply + * call the spans-compositor again to render the mask! + */ + _cairo_spans_compositor_init (&compositor, + _cairo_image_traps_compositor_get()); + + } + + return &compositor.base; +} diff --git a/src/cairo-image-surface-private.h b/src/cairo-image-surface-private.h index 56a1dc40..227a447c 100644 --- a/src/cairo-image-surface-private.h +++ b/src/cairo-image-surface-private.h @@ -44,9 +44,13 @@ CAIRO_BEGIN_DECLS +/* The canonical image backend */ struct _cairo_image_surface { cairo_surface_t base; + pixman_image_t *pixman_image; + const cairo_compositor_t *compositor; + pixman_format_code_t pixman_format; cairo_format_t format; unsigned char *data; @@ -56,20 +60,55 @@ struct _cairo_image_surface { int stride; int depth; - pixman_image_t *pixman_image; - unsigned owns_data : 1; unsigned transparency : 2; unsigned color : 2; }; -extern const cairo_private cairo_surface_backend_t _cairo_image_surface_backend; +/* A wrapper for holding pixman images returned by create_for_pattern */ +typedef struct _cairo_image_source { + cairo_surface_t base; + + pixman_image_t *pixman_image; + unsigned is_opaque_solid : 1; +} cairo_image_source_t; + +cairo_private extern const cairo_surface_backend_t _cairo_image_surface_backend; + +cairo_private const cairo_compositor_t * +_cairo_image_mask_compositor_get (void); + +cairo_private const cairo_compositor_t * +_cairo_image_traps_compositor_get (void); + +cairo_private const cairo_compositor_t * +_cairo_image_spans_compositor_get (void); cairo_private void _cairo_image_surface_init (cairo_image_surface_t *surface, pixman_image_t *pixman_image, pixman_format_code_t pixman_format); +cairo_private cairo_surface_t * +_cairo_image_surface_map_to_image (void *abstract_other, + const cairo_rectangle_int_t *extents); + +cairo_private cairo_int_status_t +_cairo_image_surface_unmap_image (void *abstract_surface, + cairo_image_surface_t *image); +cairo_private cairo_status_t +_cairo_image_surface_acquire_source_image (void *abstract_surface, + cairo_image_surface_t **image_out, + void **image_extra); + +cairo_private void +_cairo_image_surface_release_source_image (void *abstract_surface, + cairo_image_surface_t *image, + void *image_extra); + +cairo_private cairo_surface_t * +_cairo_image_surface_snapshot (void *abstract_surface); + cairo_private_no_warn cairo_bool_t _cairo_image_surface_get_extents (void *abstract_surface, cairo_rectangle_int_t *rectangle); @@ -78,9 +117,52 @@ cairo_private void _cairo_image_surface_get_font_options (void *abstract_surface, cairo_font_options_t *options); +cairo_private cairo_surface_t * +_cairo_image_source_create_for_pattern (cairo_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y); + cairo_private cairo_status_t _cairo_image_surface_finish (void *abstract_surface); +cairo_private pixman_image_t * +_pixman_image_for_color (const cairo_color_t *cairo_color); + +cairo_private pixman_image_t * +_pixman_image_for_pattern (cairo_image_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *tx, int *ty); + +cairo_private void +_pixman_image_add_traps (pixman_image_t *image, + int dst_x, int dst_y, + cairo_traps_t *traps); + +cairo_private void +_pixman_image_add_tristrip (pixman_image_t *image, + int dst_x, int dst_y, + cairo_tristrip_t *strip); + +/** + * _cairo_surface_is_image: + * @surface: a #cairo_surface_t + * + * Checks if a surface is an #cairo_image_surface_t + * + * Return value: %TRUE if the surface is an image surface + **/ +static inline cairo_bool_t +_cairo_surface_is_image (const cairo_surface_t *surface) +{ + return surface->backend == &_cairo_image_surface_backend; +} + CAIRO_END_DECLS #endif /* CAIRO_IMAGE_SURFACE_PRIVATE_H */ diff --git a/src/cairo-image-surface.c b/src/cairo-image-surface.c index bda05eb9..6adbdd61 100644 --- a/src/cairo-image-surface.c +++ b/src/cairo-image-surface.c @@ -2,7 +2,7 @@ /* cairo - a vector graphics library with display and print output * * Copyright © 2003 University of Southern California - * Copyright © 2009,2010 Intel Corporation + * Copyright © 2009,2010,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 @@ -42,6 +42,7 @@ #include "cairo-boxes-private.h" #include "cairo-clip-private.h" #include "cairo-composite-rectangles-private.h" +#include "cairo-compositor-private.h" #include "cairo-default-context-private.h" #include "cairo-error-private.h" #include "cairo-image-surface-private.h" @@ -57,7 +58,6 @@ * mainly determined by coordinates of things sent to pixman at the * moment being in 16.16 format. */ #define MAX_IMAGE_SIZE 32767 -#define PIXMAN_MAX_INT ((pixman_fixed_1 >> 1) - pixman_fixed_e) /* need to ensure deltas also fit */ /** * SECTION:cairo-image @@ -80,9 +80,6 @@ * @Since: 1.8 */ -static pixman_image_t * -_pixman_image_for_solid (const cairo_solid_pattern_t *pattern); - static cairo_bool_t _cairo_image_surface_is_size_valid (int width, int height) { @@ -165,6 +162,8 @@ _cairo_image_surface_init (cairo_image_surface_t *surface, surface->depth = pixman_image_get_depth (pixman_image); surface->base.is_clear = surface->width == 0 || surface->height == 0; + + surface->compositor = _cairo_image_spans_compositor_get (); } cairo_surface_t * @@ -391,7 +390,7 @@ cairo_image_surface_create (cairo_format_t format, } slim_hidden_def (cairo_image_surface_create); -cairo_surface_t * + cairo_surface_t * _cairo_image_surface_create_with_content (cairo_content_t content, int width, int height) @@ -427,7 +426,7 @@ _cairo_image_surface_create_with_content (cairo_content_t content, * * Since: 1.6 **/ -int + int cairo_format_stride_for_width (cairo_format_t format, int width) { @@ -489,7 +488,7 @@ slim_hidden_def (cairo_format_stride_for_width); * See cairo_surface_set_user_data() for a means of attaching a * destroy-notification fallback to the surface if necessary. **/ -cairo_surface_t * + cairo_surface_t * cairo_image_surface_create_for_data (unsigned char *data, cairo_format_t format, int width, @@ -545,7 +544,7 @@ slim_hidden_def (cairo_image_surface_create_for_data); * * Since: 1.2 **/ -unsigned char * + unsigned char * cairo_image_surface_get_data (cairo_surface_t *surface) { cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface; @@ -569,7 +568,7 @@ slim_hidden_def (cairo_image_surface_get_data); * * Since: 1.2 **/ -cairo_format_t + cairo_format_t cairo_image_surface_get_format (cairo_surface_t *surface) { cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface; @@ -591,7 +590,7 @@ slim_hidden_def (cairo_image_surface_get_format); * * Return value: the width of the surface in pixels. **/ -int + int cairo_image_surface_get_width (cairo_surface_t *surface) { cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface; @@ -613,7 +612,7 @@ slim_hidden_def (cairo_image_surface_get_width); * * Return value: the height of the surface in pixels. **/ -int + int cairo_image_surface_get_height (cairo_surface_t *surface) { cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface; @@ -640,7 +639,7 @@ slim_hidden_def (cairo_image_surface_get_height); * * Since: 1.2 **/ -int + int cairo_image_surface_get_stride (cairo_surface_t *surface) { @@ -655,7 +654,7 @@ cairo_image_surface_get_stride (cairo_surface_t *surface) } slim_hidden_def (cairo_image_surface_get_stride); -cairo_format_t + cairo_format_t _cairo_format_from_content (cairo_content_t content) { switch (content) { @@ -671,7 +670,7 @@ _cairo_format_from_content (cairo_content_t content) return CAIRO_FORMAT_INVALID; } -cairo_content_t + cairo_content_t _cairo_content_from_format (cairo_format_t format) { switch (format) { @@ -694,7 +693,7 @@ _cairo_content_from_format (cairo_format_t format) return CAIRO_CONTENT_COLOR_ALPHA; } -int + int _cairo_format_bits_per_pixel (cairo_format_t format) { switch (format) { @@ -715,7 +714,7 @@ _cairo_format_bits_per_pixel (cairo_format_t format) } } -static cairo_surface_t * + static cairo_surface_t * _cairo_image_surface_create_similar (void *abstract_other, cairo_content_t content, int width, @@ -737,7 +736,7 @@ _cairo_image_surface_create_similar (void *abstract_other, width, height); } -static cairo_surface_t * +cairo_surface_t * _cairo_image_surface_snapshot (void *abstract_surface) { cairo_image_surface_t *image = abstract_surface; @@ -766,8 +765,7 @@ _cairo_image_surface_snapshot (void *abstract_surface) return &clone->base; } - -static cairo_surface_t * +cairo_surface_t * _cairo_image_surface_map_to_image (void *abstract_other, const cairo_rectangle_int_t *extents) { @@ -790,7 +788,7 @@ _cairo_image_surface_map_to_image (void *abstract_other, return surface; } -static cairo_int_status_t +cairo_int_status_t _cairo_image_surface_unmap_image (void *abstract_surface, cairo_image_surface_t *image) { @@ -821,7 +819,7 @@ _cairo_image_surface_assume_ownership_of_data (cairo_image_surface_t *surface) surface->owns_data = TRUE; } -static cairo_status_t +cairo_status_t _cairo_image_surface_acquire_source_image (void *abstract_surface, cairo_image_surface_t **image_out, void **image_extra) @@ -832,2601 +830,13 @@ _cairo_image_surface_acquire_source_image (void *abstract_sur return CAIRO_STATUS_SUCCESS; } -static void +void _cairo_image_surface_release_source_image (void *abstract_surface, cairo_image_surface_t *image, void *image_extra) { } -/* XXX: I think we should fix pixman to match the names/order of the - * cairo operators, but that will likely be better done at the same - * time the X server is ported to pixman, (which will change a lot of - * things in pixman I think). - */ -static pixman_op_t -_pixman_operator (cairo_operator_t op) -{ - switch (op) { - case CAIRO_OPERATOR_CLEAR: - return PIXMAN_OP_CLEAR; - - case CAIRO_OPERATOR_SOURCE: - return PIXMAN_OP_SRC; - case CAIRO_OPERATOR_OVER: - return PIXMAN_OP_OVER; - case CAIRO_OPERATOR_IN: - return PIXMAN_OP_IN; - case CAIRO_OPERATOR_OUT: - return PIXMAN_OP_OUT; - case CAIRO_OPERATOR_ATOP: - return PIXMAN_OP_ATOP; - - case CAIRO_OPERATOR_DEST: - return PIXMAN_OP_DST; - case CAIRO_OPERATOR_DEST_OVER: - return PIXMAN_OP_OVER_REVERSE; - case CAIRO_OPERATOR_DEST_IN: - return PIXMAN_OP_IN_REVERSE; - case CAIRO_OPERATOR_DEST_OUT: - return PIXMAN_OP_OUT_REVERSE; - case CAIRO_OPERATOR_DEST_ATOP: - return PIXMAN_OP_ATOP_REVERSE; - - case CAIRO_OPERATOR_XOR: - return PIXMAN_OP_XOR; - case CAIRO_OPERATOR_ADD: - return PIXMAN_OP_ADD; - case CAIRO_OPERATOR_SATURATE: - return PIXMAN_OP_SATURATE; - - case CAIRO_OPERATOR_MULTIPLY: - return PIXMAN_OP_MULTIPLY; - case CAIRO_OPERATOR_SCREEN: - return PIXMAN_OP_SCREEN; - case CAIRO_OPERATOR_OVERLAY: - return PIXMAN_OP_OVERLAY; - case CAIRO_OPERATOR_DARKEN: - return PIXMAN_OP_DARKEN; - case CAIRO_OPERATOR_LIGHTEN: - return PIXMAN_OP_LIGHTEN; - case CAIRO_OPERATOR_COLOR_DODGE: - return PIXMAN_OP_COLOR_DODGE; - case CAIRO_OPERATOR_COLOR_BURN: - return PIXMAN_OP_COLOR_BURN; - case CAIRO_OPERATOR_HARD_LIGHT: - return PIXMAN_OP_HARD_LIGHT; - case CAIRO_OPERATOR_SOFT_LIGHT: - return PIXMAN_OP_SOFT_LIGHT; - case CAIRO_OPERATOR_DIFFERENCE: - return PIXMAN_OP_DIFFERENCE; - case CAIRO_OPERATOR_EXCLUSION: - return PIXMAN_OP_EXCLUSION; - case CAIRO_OPERATOR_HSL_HUE: - return PIXMAN_OP_HSL_HUE; - case CAIRO_OPERATOR_HSL_SATURATION: - return PIXMAN_OP_HSL_SATURATION; - case CAIRO_OPERATOR_HSL_COLOR: - return PIXMAN_OP_HSL_COLOR; - case CAIRO_OPERATOR_HSL_LUMINOSITY: - return PIXMAN_OP_HSL_LUMINOSITY; - - default: - ASSERT_NOT_REACHED; - return PIXMAN_OP_OVER; - } -} - -static cairo_status_t -_cairo_image_surface_set_clip_region (cairo_image_surface_t *surface, - cairo_region_t *region) -{ - if (! pixman_image_set_clip_region32 (surface->pixman_image, ®ion->rgn)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - return CAIRO_STATUS_SUCCESS; -} - -static void -_cairo_image_surface_unset_clip_region (cairo_image_surface_t *surface) -{ - pixman_image_set_clip_region32 (surface->pixman_image, NULL); -} - -#if PIXMAN_HAS_ATOMIC_OPS -static pixman_image_t *__pixman_transparent_image; -static pixman_image_t *__pixman_black_image; -static pixman_image_t *__pixman_white_image; - -static pixman_image_t * -_pixman_transparent_image (void) -{ - pixman_image_t *image; - - image = __pixman_transparent_image; - if (unlikely (image == NULL)) { - pixman_color_t color; - - color.red = 0x00; - color.green = 0x00; - color.blue = 0x00; - color.alpha = 0x00; - - image = pixman_image_create_solid_fill (&color); - if (unlikely (image == NULL)) - return NULL; - - if (_cairo_atomic_ptr_cmpxchg (&__pixman_transparent_image, - NULL, image)) - { - pixman_image_ref (image); - } - } else { - pixman_image_ref (image); - } - - return image; -} - -static pixman_image_t * -_pixman_black_image (void) -{ - pixman_image_t *image; - - image = __pixman_black_image; - if (unlikely (image == NULL)) { - pixman_color_t color; - - color.red = 0x00; - color.green = 0x00; - color.blue = 0x00; - color.alpha = 0xffff; - - image = pixman_image_create_solid_fill (&color); - if (unlikely (image == NULL)) - return NULL; - - if (_cairo_atomic_ptr_cmpxchg (&__pixman_black_image, - NULL, image)) - { - pixman_image_ref (image); - } - } else { - pixman_image_ref (image); - } - - return image; -} - -static pixman_image_t * -_pixman_white_image (void) -{ - pixman_image_t *image; - - image = __pixman_white_image; - if (unlikely (image == NULL)) { - pixman_color_t color; - - color.red = 0xffff; - color.green = 0xffff; - color.blue = 0xffff; - color.alpha = 0xffff; - - image = pixman_image_create_solid_fill (&color); - if (unlikely (image == NULL)) - return NULL; - - if (_cairo_atomic_ptr_cmpxchg (&__pixman_white_image, - NULL, image)) - { - pixman_image_ref (image); - } - } else { - pixman_image_ref (image); - } - - return image; -} - -static uint32_t -hars_petruska_f54_1_random (void) -{ -#define rol(x,k) ((x << k) | (x >> (32-k))) - static uint32_t x; - return x = (x ^ rol (x, 5) ^ rol (x, 24)) + 0x37798849; -#undef rol -} - -static struct { - cairo_color_t color; - pixman_image_t *image; -} cache[16]; -static int n_cached; - -#else /* !PIXMAN_HAS_ATOMIC_OPS */ -static pixman_image_t * -_pixman_transparent_image (void) -{ - return _pixman_image_for_solid (&_cairo_pattern_clear); -} - -static pixman_image_t * -_pixman_black_image (void) -{ - return _pixman_image_for_solid (&_cairo_pattern_black); -} - -static pixman_image_t * -_pixman_white_image (void) -{ - return _pixman_image_for_solid (&_cairo_pattern_white); -} -#endif /* !PIXMAN_HAS_ATOMIC_OPS */ - -void -_cairo_image_reset_static_data (void) -{ -#if PIXMAN_HAS_ATOMIC_OPS - while (n_cached) - pixman_image_unref (cache[--n_cached].image); - - if (__pixman_transparent_image) { - pixman_image_unref (__pixman_transparent_image); - __pixman_transparent_image = NULL; - } - - if (__pixman_black_image) { - pixman_image_unref (__pixman_black_image); - __pixman_black_image = NULL; - } - - if (__pixman_white_image) { - pixman_image_unref (__pixman_white_image); - __pixman_white_image = NULL; - } -#endif -} - -static pixman_image_t * -_pixman_image_for_solid (const cairo_solid_pattern_t *pattern) -{ - pixman_color_t color; - pixman_image_t *image; - -#if PIXMAN_HAS_ATOMIC_OPS - int i; - - if (pattern->color.alpha_short <= 0x00ff) - return _pixman_transparent_image (); - - if (pattern->color.alpha_short >= 0xff00) { - if (pattern->color.red_short <= 0x00ff && - pattern->color.green_short <= 0x00ff && - pattern->color.blue_short <= 0x00ff) - { - return _pixman_black_image (); - } - - if (pattern->color.red_short >= 0xff00 && - pattern->color.green_short >= 0xff00 && - pattern->color.blue_short >= 0xff00) - { - return _pixman_white_image (); - } - } - - CAIRO_MUTEX_LOCK (_cairo_image_solid_cache_mutex); - for (i = 0; i < n_cached; i++) { - if (_cairo_color_equal (&cache[i].color, &pattern->color)) { - image = pixman_image_ref (cache[i].image); - goto UNLOCK; - } - } -#endif - - color.red = pattern->color.red_short; - color.green = pattern->color.green_short; - color.blue = pattern->color.blue_short; - color.alpha = pattern->color.alpha_short; - - image = pixman_image_create_solid_fill (&color); -#if PIXMAN_HAS_ATOMIC_OPS - if (image == NULL) - goto UNLOCK; - - if (n_cached < ARRAY_LENGTH (cache)) { - i = n_cached++; - } else { - i = hars_petruska_f54_1_random () % ARRAY_LENGTH (cache); - pixman_image_unref (cache[i].image); - } - cache[i].image = pixman_image_ref (image); - cache[i].color = pattern->color; - -UNLOCK: - CAIRO_MUTEX_UNLOCK (_cairo_image_solid_cache_mutex); -#endif - return image; -} - -static pixman_image_t * -_pixman_image_for_gradient (const cairo_gradient_pattern_t *pattern, - const cairo_rectangle_int_t *extents, - int *ix, int *iy) -{ - pixman_image_t *pixman_image; - pixman_gradient_stop_t pixman_stops_static[2]; - pixman_gradient_stop_t *pixman_stops = pixman_stops_static; - pixman_transform_t pixman_transform; - cairo_matrix_t matrix; - cairo_circle_double_t extremes[2]; - pixman_point_fixed_t p1, p2; - unsigned int i; - cairo_int_status_t status; - - if (pattern->n_stops > ARRAY_LENGTH(pixman_stops_static)) { - pixman_stops = _cairo_malloc_ab (pattern->n_stops, - sizeof(pixman_gradient_stop_t)); - if (unlikely (pixman_stops == NULL)) - return NULL; - } - - for (i = 0; i < pattern->n_stops; i++) { - pixman_stops[i].x = _cairo_fixed_16_16_from_double (pattern->stops[i].offset); - pixman_stops[i].color.red = pattern->stops[i].color.red_short; - pixman_stops[i].color.green = pattern->stops[i].color.green_short; - pixman_stops[i].color.blue = pattern->stops[i].color.blue_short; - pixman_stops[i].color.alpha = pattern->stops[i].color.alpha_short; - } - - _cairo_gradient_pattern_fit_to_range (pattern, PIXMAN_MAX_INT >> 1, &matrix, extremes); - - p1.x = _cairo_fixed_16_16_from_double (extremes[0].center.x); - p1.y = _cairo_fixed_16_16_from_double (extremes[0].center.y); - p2.x = _cairo_fixed_16_16_from_double (extremes[1].center.x); - p2.y = _cairo_fixed_16_16_from_double (extremes[1].center.y); - - if (pattern->base.type == CAIRO_PATTERN_TYPE_LINEAR) { - pixman_image = pixman_image_create_linear_gradient (&p1, &p2, - pixman_stops, - pattern->n_stops); - } else { - pixman_fixed_t r1, r2; - - r1 = _cairo_fixed_16_16_from_double (extremes[0].radius); - r2 = _cairo_fixed_16_16_from_double (extremes[1].radius); - - pixman_image = pixman_image_create_radial_gradient (&p1, &p2, r1, r2, - pixman_stops, - pattern->n_stops); - } - - if (pixman_stops != pixman_stops_static) - free (pixman_stops); - - if (unlikely (pixman_image == NULL)) - return NULL; - - *ix = *iy = 0; - status = _cairo_matrix_to_pixman_matrix_offset (&matrix, pattern->base.filter, - extents->x + extents->width/2., - extents->y + extents->height/2., - &pixman_transform, ix, iy); - if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) { - if (unlikely (status != CAIRO_INT_STATUS_SUCCESS) || - ! pixman_image_set_transform (pixman_image, &pixman_transform)) - { - pixman_image_unref (pixman_image); - return NULL; - } - } - - { - pixman_repeat_t pixman_repeat; - - switch (pattern->base.extend) { - default: - case CAIRO_EXTEND_NONE: - pixman_repeat = PIXMAN_REPEAT_NONE; - break; - case CAIRO_EXTEND_REPEAT: - pixman_repeat = PIXMAN_REPEAT_NORMAL; - break; - case CAIRO_EXTEND_REFLECT: - pixman_repeat = PIXMAN_REPEAT_REFLECT; - break; - case CAIRO_EXTEND_PAD: - pixman_repeat = PIXMAN_REPEAT_PAD; - break; - } - - pixman_image_set_repeat (pixman_image, pixman_repeat); - } - - return pixman_image; -} - -struct acquire_source_cleanup { - cairo_surface_t *surface; - cairo_image_surface_t *image; - void *image_extra; -}; - -static void -_acquire_source_cleanup (pixman_image_t *pixman_image, - void *closure) -{ - struct acquire_source_cleanup *data = closure; - - _cairo_surface_release_source_image (data->surface, - data->image, - data->image_extra); - free (data); -} - -static cairo_filter_t -sampled_area (const cairo_surface_pattern_t *pattern, - const cairo_rectangle_int_t *extents, - cairo_rectangle_int_t *sample) -{ - cairo_filter_t filter; - double x1, x2, y1, y2; - double pad; - - x1 = extents->x; - y1 = extents->y; - x2 = extents->x + (int) extents->width; - y2 = extents->y + (int) extents->height; - - _cairo_matrix_transform_bounding_box (&pattern->base.matrix, - &x1, &y1, &x2, &y2, - NULL); - - filter = _cairo_pattern_analyze_filter (&pattern->base, &pad); - sample->x = floor (x1 - pad); - sample->y = floor (y1 - pad); - sample->width = ceil (x2 + pad) - sample->x; - sample->height = ceil (y2 + pad) - sample->y; - - return filter; -} - -static uint16_t -expand_channel (uint16_t v, uint32_t bits) -{ - int offset = 16 - bits; - while (offset > 0) { - v |= v >> bits; - offset -= bits; - bits += bits; - } - return v; -} - -static pixman_image_t * -_pixel_to_solid (cairo_image_surface_t *image, int x, int y) -{ - uint32_t pixel; - pixman_color_t color; - - switch (image->format) { - default: - ASSERT_NOT_REACHED; - return NULL; - - case CAIRO_FORMAT_INVALID: - return NULL; - - case CAIRO_FORMAT_A1: - pixel = *(uint8_t *) (image->data + y * image->stride + x/8); - return pixel & (1 << (x&7)) ? _pixman_black_image () : _pixman_transparent_image (); - - case CAIRO_FORMAT_A8: - color.alpha = *(uint8_t *) (image->data + y * image->stride + x); - color.alpha |= color.alpha << 8; - if (color.alpha == 0) - return _pixman_transparent_image (); - if (color.alpha == 0xffff) - return _pixman_black_image (); - - color.red = color.green = color.blue = 0; - return pixman_image_create_solid_fill (&color); - - case CAIRO_FORMAT_RGB16_565: - pixel = *(uint16_t *) (image->data + y * image->stride + 2 * x); - if (pixel == 0) - return _pixman_black_image (); - if (pixel == 0xffff) - return _pixman_white_image (); - - color.alpha = 0xffff; - color.red = expand_channel ((pixel >> 11 & 0x1f) << 11, 5); - color.green = expand_channel ((pixel >> 5 & 0x3f) << 10, 6); - color.blue = expand_channel ((pixel & 0x1f) << 11, 5); - return pixman_image_create_solid_fill (&color); - - case CAIRO_FORMAT_RGB30: - pixel = *(uint32_t *) (image->data + y * image->stride + 4 * x); - pixel &= 0x3fffffff; /* ignore alpha bits */ - if (pixel == 0) - return _pixman_black_image (); - if (pixel == 0x3fffffff) - return _pixman_white_image (); - - /* convert 10bpc to 16bpc */ - color.alpha = 0xffff; - color.red = expand_channel((pixel >> 20) & 0x3fff, 10); - color.green = expand_channel((pixel >> 10) & 0x3fff, 10); - color.blue = expand_channel(pixel & 0x3fff, 10); - return pixman_image_create_solid_fill (&color); - - case CAIRO_FORMAT_ARGB32: - case CAIRO_FORMAT_RGB24: - pixel = *(uint32_t *) (image->data + y * image->stride + 4 * x); - color.alpha = image->format == CAIRO_FORMAT_ARGB32 ? (pixel >> 24) | (pixel >> 16 & 0xff00) : 0xffff; - if (color.alpha == 0) - return _pixman_transparent_image (); - if (pixel == 0xffffffff) - return _pixman_white_image (); - if (color.alpha == 0xffff && (pixel & 0xffffff) == 0) - return _pixman_black_image (); - - color.red = (pixel >> 16 & 0xff) | (pixel >> 8 & 0xff00); - color.green = (pixel >> 8 & 0xff) | (pixel & 0xff00); - color.blue = (pixel & 0xff) | (pixel << 8 & 0xff00); - return pixman_image_create_solid_fill (&color); - } -} - -static pixman_image_t * -_pixman_image_for_surface (const cairo_surface_pattern_t *pattern, - cairo_bool_t is_mask, - const cairo_rectangle_int_t *extents, - cairo_matrix_t *dst_device_transform, - int *ix, int *iy) -{ - pixman_transform_t pixman_transform; - pixman_image_t *pixman_image; - cairo_matrix_t m; - cairo_rectangle_int_t sample; - cairo_extend_t extend; - cairo_filter_t filter; - cairo_int_status_t status; - cairo_bool_t undo_src_transform = FALSE; - - extend = pattern->base.extend; - filter = sampled_area (pattern, extents, &sample); - - *ix = *iy = 0; - pixman_image = NULL; - if (pattern->surface->type == CAIRO_SURFACE_TYPE_IMAGE && - (! is_mask || ! pattern->base.has_component_alpha || - (pattern->surface->content & CAIRO_CONTENT_COLOR) == 0)) - { - cairo_image_surface_t *source = (cairo_image_surface_t *) pattern->surface; - cairo_surface_type_t type; - - if (_cairo_surface_is_snapshot (&source->base)) - source = (cairo_image_surface_t *) _cairo_surface_snapshot_get_target (&source->base); - - type = source->base.backend->type; - if (type == CAIRO_SURFACE_TYPE_IMAGE) { - if (extend != CAIRO_EXTEND_NONE && - sample.x >= 0 && - sample.y >= 0 && - sample.x + sample.width <= source->width && - sample.y + sample.height <= source->height) - { - extend = CAIRO_EXTEND_NONE; - } - - if (sample.width == 1 && sample.height == 1) { - if (sample.x < 0 || - sample.y < 0 || - sample.x >= source->width || - sample.y >= source->height) - { - if (extend == CAIRO_EXTEND_NONE) - return _pixman_transparent_image (); - } - else - { - pixman_image = _pixel_to_solid (source, sample.x, sample.y); - if (pixman_image) - return pixman_image; - } - } - -#if PIXMAN_HAS_ATOMIC_OPS - /* avoid allocating a 'pattern' image if we can reuse the original */ - *ix = *iy = 0; - if (extend == CAIRO_EXTEND_NONE && - _cairo_matrix_is_pixman_translation (&pattern->base.matrix, - filter, ix, iy)) - { - return pixman_image_ref (source->pixman_image); - } -#endif - - pixman_image = pixman_image_create_bits (source->pixman_format, - source->width, - source->height, - (uint32_t *) source->data, - source->stride); - if (unlikely (pixman_image == NULL)) - return NULL; - } else if (type == CAIRO_SURFACE_TYPE_SUBSURFACE) { - cairo_surface_subsurface_t *sub; - cairo_bool_t is_contained = FALSE; - - sub = (cairo_surface_subsurface_t *) source; - source = (cairo_image_surface_t *) sub->target; - - if (sample.x >= 0 && - sample.y >= 0 && - sample.x + sample.width <= sub->extents.width && - sample.y + sample.height <= sub->extents.height) - { - is_contained = TRUE; - } - - if (sample.width == 1 && sample.height == 1) { - if (is_contained) { - pixman_image = _pixel_to_solid (source, - sub->extents.x + sample.x, - sub->extents.y + sample.y); - if (pixman_image) - return pixman_image; - } else { - if (extend == CAIRO_EXTEND_NONE) - return _pixman_transparent_image (); - } - } - -#if PIXMAN_HAS_ATOMIC_OPS - *ix = sub->extents.x; - *iy = sub->extents.y; - if (is_contained && - _cairo_matrix_is_pixman_translation (&pattern->base.matrix, - filter, ix, iy)) - { - return pixman_image_ref (source->pixman_image); - } -#endif - - /* Avoid sub-byte offsets, force a copy in that case. */ - if (PIXMAN_FORMAT_BPP (source->pixman_format) >= 8) { - void *data = source->data - + sub->extents.x * PIXMAN_FORMAT_BPP(source->pixman_format)/8 - + sub->extents.y * source->stride; - pixman_image = pixman_image_create_bits (source->pixman_format, - sub->extents.width, - sub->extents.height, - data, - source->stride); - if (unlikely (pixman_image == NULL)) - return NULL; - } - } - } - -#if PIXMAN_HAS_ATOMIC_OPS - *ix = *iy = 0; -#endif - - if (pixman_image == NULL) { - struct acquire_source_cleanup *cleanup; - cairo_image_surface_t *image; - void *extra; - cairo_status_t status; - - status = _cairo_surface_acquire_source_image_transformed (pattern->surface, dst_device_transform, &image, &extra); - if (unlikely (status)) - return NULL; - - if (sample.width == 1 && sample.height == 1) { - if (sample.x < 0 || - sample.y < 0 || - sample.x >= image->width || - sample.y >= image->height) - { - if (extend == CAIRO_EXTEND_NONE) { - pixman_image = _pixman_transparent_image (); - _cairo_surface_release_source_image (pattern->surface, image, extra); - return pixman_image; - } - } - else - { - pixman_image = _pixel_to_solid (image, sample.x, sample.y); - if (pixman_image) - { - _cairo_surface_release_source_image (pattern->surface, image, extra); - return pixman_image; - } - } - } - - pixman_image = pixman_image_create_bits (image->pixman_format, - image->width, - image->height, - (uint32_t *) image->data, - image->stride); - if (unlikely (pixman_image == NULL)) { - _cairo_surface_release_source_image (pattern->surface, image, extra); - return NULL; - } - - cleanup = malloc (sizeof (*cleanup)); - if (unlikely (cleanup == NULL)) { - _cairo_surface_release_source_image (pattern->surface, image, extra); - pixman_image_unref (pixman_image); - return NULL; - } - - cleanup->surface = pattern->surface; - cleanup->image = image; - cleanup->image_extra = extra; - pixman_image_set_destroy_function (pixman_image, - _acquire_source_cleanup, cleanup); - undo_src_transform = TRUE; - } - - m = pattern->base.matrix; - if (undo_src_transform) { - cairo_matrix_t sm; - - cairo_matrix_init_scale (&sm, - dst_device_transform->xx, - dst_device_transform->yy); - cairo_matrix_multiply (&m, &m, &sm); - } - - status = _cairo_matrix_to_pixman_matrix_offset (&m, filter, - extents->x + extents->width/2., - extents->y + extents->height/2., - &pixman_transform, ix, iy); - if (status == CAIRO_INT_STATUS_NOTHING_TO_DO) - { - /* If the transform is an identity, we don't need to set it - * and we can use any filtering, so choose the fastest one. */ - pixman_image_set_filter (pixman_image, PIXMAN_FILTER_NEAREST, NULL, 0); - } - else if (unlikely (status != CAIRO_INT_STATUS_SUCCESS || - ! pixman_image_set_transform (pixman_image, - &pixman_transform))) - { - pixman_image_unref (pixman_image); - return NULL; - } - else - { - pixman_filter_t pixman_filter; - - switch (filter) { - case CAIRO_FILTER_FAST: - pixman_filter = PIXMAN_FILTER_FAST; - break; - case CAIRO_FILTER_GOOD: - pixman_filter = PIXMAN_FILTER_GOOD; - break; - case CAIRO_FILTER_BEST: - pixman_filter = PIXMAN_FILTER_BEST; - break; - case CAIRO_FILTER_NEAREST: - pixman_filter = PIXMAN_FILTER_NEAREST; - break; - case CAIRO_FILTER_BILINEAR: - pixman_filter = PIXMAN_FILTER_BILINEAR; - break; - case CAIRO_FILTER_GAUSSIAN: - /* XXX: The GAUSSIAN value has no implementation in cairo - * whatsoever, so it was really a mistake to have it in the - * API. We could fix this by officially deprecating it, or - * else inventing semantics and providing an actual - * implementation for it. */ - default: - pixman_filter = PIXMAN_FILTER_BEST; - } - - pixman_image_set_filter (pixman_image, pixman_filter, NULL, 0); - } - - { - pixman_repeat_t pixman_repeat; - - switch (extend) { - default: - case CAIRO_EXTEND_NONE: - pixman_repeat = PIXMAN_REPEAT_NONE; - break; - case CAIRO_EXTEND_REPEAT: - pixman_repeat = PIXMAN_REPEAT_NORMAL; - break; - case CAIRO_EXTEND_REFLECT: - pixman_repeat = PIXMAN_REPEAT_REFLECT; - break; - case CAIRO_EXTEND_PAD: - pixman_repeat = PIXMAN_REPEAT_PAD; - break; - } - - pixman_image_set_repeat (pixman_image, pixman_repeat); - } - - if (pattern->base.has_component_alpha) - pixman_image_set_component_alpha (pixman_image, TRUE); - - return pixman_image; -} - -static pixman_image_t * -_pixman_image_for_pattern (const cairo_pattern_t *pattern, - cairo_bool_t is_mask, - const cairo_rectangle_int_t *extents, - cairo_matrix_t *dst_device_transform, - int *tx, int *ty) -{ - *tx = *ty = 0; - - if (pattern == NULL) - return _pixman_white_image (); - - switch (pattern->type) { - default: - ASSERT_NOT_REACHED; - case CAIRO_PATTERN_TYPE_SOLID: - return _pixman_image_for_solid ((const cairo_solid_pattern_t *) pattern); - - case CAIRO_PATTERN_TYPE_RADIAL: - case CAIRO_PATTERN_TYPE_LINEAR: - return _pixman_image_for_gradient ((const cairo_gradient_pattern_t *) pattern, - extents, tx, ty); - - case CAIRO_PATTERN_TYPE_SURFACE: - return _pixman_image_for_surface ((const cairo_surface_pattern_t *) pattern, - is_mask, extents, dst_device_transform, tx, ty); - - case CAIRO_PATTERN_TYPE_MESH: { - cairo_surface_t *image; - pixman_image_t *r; - void * data; - int width, height, stride; - - *tx = -extents->x; - *ty = -extents->y; - width = extents->width; - height = extents->height; - - image = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height); - if (unlikely (image->status)) - return NULL; - - stride = cairo_image_surface_get_stride (image); - data = cairo_image_surface_get_data (image); - - _cairo_mesh_pattern_rasterize ((cairo_mesh_pattern_t *) pattern, - data, width, height, stride, *tx, *ty); - r = pixman_image_ref (((cairo_image_surface_t *)image)->pixman_image); - cairo_surface_destroy (image); - return r; - } - } -} - -static cairo_status_t -_cairo_image_surface_fixup_unbounded (cairo_image_surface_t *dst, - const cairo_composite_rectangles_t *rects, - cairo_clip_t *clip) -{ - cairo_surface_t *clip_surface = NULL; - pixman_image_t *mask = NULL; - pixman_box32_t boxes[4]; - int i, mask_x = 0, mask_y = 0, n_boxes = 0; - cairo_status_t status = CAIRO_STATUS_SUCCESS; - - if (clip != NULL) { - int clip_x, clip_y; - - clip_surface = _cairo_clip_get_surface (clip, &dst->base, &clip_x, &clip_y); - if (unlikely (clip_surface->status)) - return clip_surface->status; - - mask = ((cairo_image_surface_t *) clip_surface)->pixman_image; - mask_x = -clip_x; - mask_y = -clip_y; - } else { - if (rects->bounded.width == rects->unbounded.width && - rects->bounded.height == rects->unbounded.height) - { - return CAIRO_STATUS_SUCCESS; - } - } - - /* wholly unbounded? */ - if (rects->bounded.width == 0 || rects->bounded.height == 0) { - int x = rects->unbounded.x; - int y = rects->unbounded.y; - int width = rects->unbounded.width; - int height = rects->unbounded.height; - - if (mask != NULL) { - pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, - mask, NULL, dst->pixman_image, - x + mask_x, y + mask_y, - 0, 0, - x, y, - width, height); - } else { - pixman_color_t color = { 0, }; - pixman_box32_t box = { x, y, x + width, y + height }; - - if (! pixman_image_fill_boxes (PIXMAN_OP_CLEAR, - dst->pixman_image, - &color, - 1, &box)) - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - cairo_surface_destroy (clip_surface); - return status; - } - - /* top */ - if (rects->bounded.y != rects->unbounded.y) { - boxes[n_boxes].x1 = rects->unbounded.x; - boxes[n_boxes].y1 = rects->unbounded.y; - boxes[n_boxes].x2 = rects->unbounded.x + rects->unbounded.width; - boxes[n_boxes].y2 = rects->bounded.y; - n_boxes++; - } - - /* left */ - if (rects->bounded.x != rects->unbounded.x) { - boxes[n_boxes].x1 = rects->unbounded.x; - boxes[n_boxes].y1 = rects->bounded.y; - boxes[n_boxes].x2 = rects->bounded.x; - boxes[n_boxes].y2 = rects->bounded.y + rects->bounded.height; - n_boxes++; - } - - /* right */ - if (rects->bounded.x + rects->bounded.width != rects->unbounded.x + rects->unbounded.width) { - boxes[n_boxes].x1 = rects->bounded.x + rects->bounded.width; - boxes[n_boxes].y1 = rects->bounded.y; - boxes[n_boxes].x2 = rects->unbounded.x + rects->unbounded.width; - boxes[n_boxes].y2 = rects->bounded.y + rects->bounded.height; - n_boxes++; - } - - /* bottom */ - if (rects->bounded.y + rects->bounded.height != rects->unbounded.y + rects->unbounded.height) { - boxes[n_boxes].x1 = rects->unbounded.x; - boxes[n_boxes].y1 = rects->bounded.y + rects->bounded.height; - boxes[n_boxes].x2 = rects->unbounded.x + rects->unbounded.width; - boxes[n_boxes].y2 = rects->unbounded.y + rects->unbounded.height; - n_boxes++; - } - - if (mask != NULL) { - for (i = 0; i < n_boxes; i++) { - pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, - mask, NULL, dst->pixman_image, - boxes[i].x1 + mask_x, boxes[i].y1 + mask_y, - 0, 0, - boxes[i].x1, boxes[i].y1, - boxes[i].x2 - boxes[i].x1, boxes[i].y2 - boxes[i].y1); - } - } else { - pixman_color_t color = { 0, }; - - if (! pixman_image_fill_boxes (PIXMAN_OP_CLEAR, - dst->pixman_image, - &color, - n_boxes, - boxes)) - { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - } - - cairo_surface_destroy (clip_surface); - return status; -} - -static cairo_status_t -_cairo_image_surface_fixup_unbounded_boxes (cairo_image_surface_t *dst, - const cairo_composite_rectangles_t *extents, - cairo_region_t *clip_region, - cairo_boxes_t *boxes) -{ - cairo_boxes_t clear; - cairo_box_t box; - cairo_status_t status; - struct _cairo_boxes_chunk *chunk; - int i; - - if (boxes->num_boxes <= 1 && clip_region == NULL) - return _cairo_image_surface_fixup_unbounded (dst, extents, NULL); - - _cairo_boxes_init (&clear); - - box.p1.x = _cairo_fixed_from_int (extents->unbounded.x + extents->unbounded.width); - box.p1.y = _cairo_fixed_from_int (extents->unbounded.y); - box.p2.x = _cairo_fixed_from_int (extents->unbounded.x); - box.p2.y = _cairo_fixed_from_int (extents->unbounded.y + extents->unbounded.height); - - if (clip_region == NULL) { - cairo_boxes_t tmp; - - _cairo_boxes_init (&tmp); - - status = _cairo_boxes_add (&tmp, CAIRO_ANTIALIAS_DEFAULT, &box); - assert (status == CAIRO_STATUS_SUCCESS); - - tmp.chunks.next = &boxes->chunks; - tmp.num_boxes += boxes->num_boxes; - - status = _cairo_bentley_ottmann_tessellate_boxes (&tmp, - CAIRO_FILL_RULE_WINDING, - &clear); - - tmp.chunks.next = NULL; - } else { - pixman_box32_t *pbox; - - pbox = pixman_region32_rectangles (&clip_region->rgn, &i); - _cairo_boxes_limit (&clear, (cairo_box_t *) pbox, i); - - status = _cairo_boxes_add (&clear, CAIRO_ANTIALIAS_DEFAULT, &box); - assert (status == CAIRO_STATUS_SUCCESS); - - for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { - for (i = 0; i < chunk->count; i++) { - status = _cairo_boxes_add (&clear, - CAIRO_ANTIALIAS_DEFAULT, - &chunk->base[i]); - if (unlikely (status)) { - _cairo_boxes_fini (&clear); - return status; - } - } - } - - status = _cairo_bentley_ottmann_tessellate_boxes (&clear, - CAIRO_FILL_RULE_WINDING, - &clear); - } - - if (likely (status == CAIRO_STATUS_SUCCESS)) { - for (chunk = &clear.chunks; chunk != NULL; chunk = chunk->next) { - for (i = 0; i < chunk->count; i++) { - int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x); - int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y); - int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x); - int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y); - - pixman_fill ((uint32_t *) dst->data, dst->stride / sizeof (uint32_t), - PIXMAN_FORMAT_BPP (dst->pixman_format), - x1, y1, x2 - x1, y2 - y1, - 0); - } - } - } - - _cairo_boxes_fini (&clear); - - return status; -} - -static cairo_bool_t -can_reduce_alpha_op (cairo_operator_t op) -{ - int iop = op; - switch (iop) { - case CAIRO_OPERATOR_OVER: - case CAIRO_OPERATOR_SOURCE: - case CAIRO_OPERATOR_ADD: - return TRUE; - default: - return FALSE; - } -} - -static cairo_bool_t -reduce_alpha_op (cairo_image_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *pattern) -{ - return dst->base.is_clear && - dst->base.content == CAIRO_CONTENT_ALPHA && - _cairo_pattern_is_opaque_solid (pattern) && - can_reduce_alpha_op (op); -} - -/* low level compositor */ -typedef cairo_status_t -(*image_draw_func_t) (void *closure, - pixman_image_t *dst, - pixman_format_code_t dst_format, - cairo_operator_t op, - const cairo_pattern_t *src, - int dst_x, - int dst_y, - cairo_matrix_t *dst_device_transform, - const cairo_composite_rectangles_t *extents); - -static pixman_image_t * -_create_composite_mask_pattern (cairo_composite_rectangles_t *extents, - image_draw_func_t draw_func, - void *draw_closure, - cairo_image_surface_t *dst) -{ - cairo_region_t *clip_region = _cairo_clip_get_region (extents->clip); - cairo_bool_t need_clip_surface = ! _cairo_clip_is_region (extents->clip); - pixman_image_t *mask; - cairo_status_t status; - - if (clip_region != NULL && cairo_region_num_rectangles (clip_region) == 1) - clip_region = NULL; - - mask = pixman_image_create_bits (PIXMAN_a8, extents->bounded.width, extents->bounded.height, - NULL, 0); - if (unlikely (mask == NULL)) - return NULL; - - /* Is it worth setting the clip region here? */ - if (clip_region != NULL) { - pixman_bool_t ret; - - pixman_region32_translate (&clip_region->rgn, -extents->bounded.x, -extents->bounded.y); - ret = pixman_image_set_clip_region32 (mask, &clip_region->rgn); - pixman_region32_translate (&clip_region->rgn, extents->bounded.x, extents->bounded.y); - - if (! ret) { - pixman_image_unref (mask); - return NULL; - } - } - - status = draw_func (draw_closure, - mask, PIXMAN_a8, - CAIRO_OPERATOR_ADD, NULL, - extents->bounded.x, extents->bounded.y, - &dst->base.device_transform, - extents); - if (unlikely (status)) { - pixman_image_unref (mask); - return NULL; - } - - if (need_clip_surface) { - cairo_surface_t *tmp; - - tmp = _cairo_image_surface_create_for_pixman_image (mask, PIXMAN_a8); - if (unlikely (tmp->status)) { - pixman_image_unref (mask); - return NULL; - } - - pixman_image_ref (mask); - - status = _cairo_clip_combine_with_surface (extents->clip, tmp, - extents->bounded.x, - extents->bounded.y); - cairo_surface_destroy (tmp); - if (unlikely (status)) { - pixman_image_unref (mask); - return NULL; - } - } - - if (clip_region != NULL) - pixman_image_set_clip_region (mask, NULL); - - return mask; -} - -/* Handles compositing with a clip surface when the operator allows - * us to combine the clip with the mask - */ -static cairo_status_t -_clip_and_composite_with_mask (cairo_composite_rectangles_t *extents, - cairo_operator_t op, - const cairo_pattern_t *pattern, - image_draw_func_t draw_func, - void *draw_closure, - cairo_image_surface_t *dst) -{ - pixman_image_t *mask; - - mask = _create_composite_mask_pattern (extents, draw_func, draw_closure, dst); - if (unlikely (mask == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - if (pattern == NULL) { - if (dst->pixman_format == PIXMAN_a8) { - pixman_image_composite32 (_pixman_operator (op), - mask, NULL, dst->pixman_image, - 0, 0, 0, 0, - extents->bounded.x, extents->bounded.y, - extents->bounded.width, extents->bounded.height); - } else { - pixman_image_t *src; - - src = _pixman_white_image (); - if (unlikely (src == NULL)) { - pixman_image_unref (mask); - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - pixman_image_composite32 (_pixman_operator (op), - src, mask, dst->pixman_image, - 0, 0, 0, 0, - extents->bounded.x, extents->bounded.y, - extents->bounded.width, extents->bounded.height); - pixman_image_unref (src); - } - } else { - pixman_image_t *src; - int src_x, src_y; - - src = _pixman_image_for_pattern (pattern, FALSE, &extents->bounded, - &dst->base.device_transform, - &src_x, &src_y); - if (unlikely (src == NULL)) { - pixman_image_unref (mask); - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - pixman_image_composite32 (_pixman_operator (op), - src, mask, dst->pixman_image, - extents->bounded.x + src_x, extents->bounded.y + src_y, - 0, 0, - extents->bounded.x, extents->bounded.y, - extents->bounded.width, extents->bounded.height); - pixman_image_unref (src); - } - - pixman_image_unref (mask); - - return CAIRO_STATUS_SUCCESS; -} - -/* Handles compositing with a clip surface when we have to do the operation - * in two pieces and combine them together. - */ -static cairo_status_t -_clip_and_composite_combine (cairo_composite_rectangles_t *extents, - cairo_operator_t op, - const cairo_pattern_t *src, - image_draw_func_t draw_func, - void *draw_closure, - cairo_image_surface_t *dst) -{ - pixman_image_t *tmp; - cairo_surface_t *clip_surface; - int clip_x, clip_y; - cairo_status_t status; - - tmp = pixman_image_create_bits (dst->pixman_format, - extents->bounded.width, - extents->bounded.height, - NULL, 0); - if (unlikely (tmp == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - if (src == NULL) { - status = (*draw_func) (draw_closure, - tmp, dst->pixman_format, - CAIRO_OPERATOR_ADD, NULL, - extents->bounded.x, extents->bounded.y, - &dst->base.device_transform, - extents); - } else { - /* Initialize the temporary surface from the destination surface */ - if (! dst->base.is_clear) { - pixman_image_composite32 (PIXMAN_OP_SRC, - dst->pixman_image, NULL, tmp, - extents->bounded.x, - extents->bounded.y, - 0, 0, - 0, 0, - extents->bounded.width, - extents->bounded.height); - } - - status = (*draw_func) (draw_closure, - tmp, dst->pixman_format, - op, src, - extents->bounded.x, extents->bounded.y, - &dst->base.device_transform, - extents); - } - if (unlikely (status)) - goto CLEANUP_SURFACE; - - clip_surface = _cairo_clip_get_surface (extents->clip, &dst->base, - &clip_x, &clip_y); - if (unlikely (clip_surface->status)) - goto CLEANUP_SURFACE; - - if (! dst->base.is_clear) { -#if PIXMAN_HAS_OP_LERP - pixman_image_composite32 (PIXMAN_OP_LERP, - tmp, - ((cairo_image_surface_t *) clip_surface)->pixman_image, - dst->pixman_image, - 0, 0, - extents->bounded.x - clip_x, - extents->bounded.y - clip_y, - extents->bounded.x, extents->bounded.y, - extents->bounded.width, extents->bounded.height); -#else - /* Punch the clip out of the destination */ - pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, - ((cairo_image_surface_t *) clip_surface)->pixman_image, - NULL, dst->pixman_image, - extents->bounded.x - clip_x, - extents->bounded.y - clip_y, - 0, 0, - extents->bounded.x, extents->bounded.y, - extents->bounded.width, extents->bounded.height); - - /* Now add the two results together */ - pixman_image_composite32 (PIXMAN_OP_ADD, - tmp, - ((cairo_image_surface_t *) clip_surface)->pixman_image, - dst->pixman_image, - 0, 0, - extents->bounded.x - clip_x, - extents->bounded.y - clip_y, - extents->bounded.x, extents->bounded.y, - extents->bounded.width, extents->bounded.height); -#endif - } else { - pixman_image_composite32 (PIXMAN_OP_SRC, - tmp, - ((cairo_image_surface_t *) clip_surface)->pixman_image, - dst->pixman_image, - 0, 0, - extents->bounded.x - clip_x, - extents->bounded.y - clip_y, - extents->bounded.x, extents->bounded.y, - extents->bounded.width, extents->bounded.height); - } - - cairo_surface_destroy (clip_surface); - CLEANUP_SURFACE: - pixman_image_unref (tmp); - - return status; -} - -/* Handles compositing for %CAIRO_OPERATOR_SOURCE, which is special; it's - * defined as (src IN mask IN clip) ADD (dst OUT (mask IN clip)) - */ -static cairo_status_t -_clip_and_composite_source (cairo_composite_rectangles_t *extents, - const cairo_pattern_t *pattern, - image_draw_func_t draw_func, - void *draw_closure, - cairo_image_surface_t *dst) -{ - pixman_image_t *mask, *src; - int src_x, src_y; - - if (pattern == NULL) { - cairo_status_t status; - - status = draw_func (draw_closure, - dst->pixman_image, dst->pixman_format, - CAIRO_OPERATOR_SOURCE, NULL, - extents->bounded.x, extents->bounded.y, - &dst->base.device_transform, - extents); - if (unlikely (status)) - return status; - - if (! _cairo_clip_is_region (extents->clip)) - status = _cairo_clip_combine_with_surface (extents->clip, - &dst->base, 0, 0); - - return status; - } - - /* Create a surface that is mask IN clip */ - mask = _create_composite_mask_pattern (extents, draw_func, draw_closure, dst); - if (unlikely (mask == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - src = _pixman_image_for_pattern (pattern, FALSE, &extents->bounded, - &dst->base.device_transform, - &src_x, &src_y); - if (unlikely (src == NULL)) { - pixman_image_unref (mask); - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - if (! dst->base.is_clear) { -#if PIXMAN_HAS_OP_LERP - pixman_image_composite32 (PIXMAN_OP_LERP, - src, mask, dst->pixman_image, - extents->bounded.x + src_x, extents->bounded.y + src_y, - 0, 0, - extents->bounded.x, extents->bounded.y, - extents->bounded.width, extents->bounded.height); -#else - /* Compute dest' = dest OUT (mask IN clip) */ - pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, - mask, NULL, dst->pixman_image, - 0, 0, 0, 0, - extents->bounded.x, extents->bounded.y, - extents->bounded.width, extents->bounded.height); - - /* Now compute (src IN (mask IN clip)) ADD dest' */ - pixman_image_composite32 (PIXMAN_OP_ADD, - src, mask, dst->pixman_image, - extents->bounded.x + src_x, extents->bounded.y + src_y, - 0, 0, - extents->bounded.x, extents->bounded.y, - extents->bounded.width, extents->bounded.height); -#endif - } else { - pixman_image_composite32 (PIXMAN_OP_SRC, - src, mask, dst->pixman_image, - extents->bounded.x + src_x, extents->bounded.y + src_y, - 0, 0, - extents->bounded.x, extents->bounded.y, - extents->bounded.width, extents->bounded.height); - } - - pixman_image_unref (src); - pixman_image_unref (mask); - - return CAIRO_STATUS_SUCCESS; -} - -enum { - NEED_CLIP_REGION = 0x1, - NEED_CLIP_SURFACE = 0x2, - FORCE_CLIP_REGION = 0x4, -}; - -static cairo_bool_t -need_bounded_clip (cairo_composite_rectangles_t *extents) -{ - unsigned int flags = NEED_CLIP_REGION; - if (! _cairo_clip_is_region (extents->clip)) - flags |= NEED_CLIP_SURFACE; - return flags; -} - -static cairo_bool_t -need_unbounded_clip (cairo_composite_rectangles_t *extents) -{ - unsigned int flags = 0; - if (! extents->is_bounded) { - flags |= NEED_CLIP_REGION; - if (! _cairo_clip_is_region (extents->clip)) - flags |= NEED_CLIP_SURFACE; - } - if (extents->clip->path != NULL) - flags |= NEED_CLIP_SURFACE; - return flags; -} - - -static cairo_status_t -_clip_and_composite (cairo_image_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src, - image_draw_func_t draw_func, - void *draw_closure, - cairo_composite_rectangles_t*extents, - unsigned int need_clip) -{ - cairo_region_t *clip_region = NULL; - cairo_status_t status; - - if (need_clip & NEED_CLIP_REGION) { - clip_region = _cairo_clip_get_region (extents->clip); - if ((need_clip & FORCE_CLIP_REGION) == 0 && - cairo_region_contains_rectangle (clip_region, - &extents->unbounded) == CAIRO_REGION_OVERLAP_IN) - clip_region = NULL; - if (clip_region != NULL) { - status = _cairo_image_surface_set_clip_region (dst, clip_region); - if (unlikely (status)) - return status; - } - } - - if (reduce_alpha_op (dst, op, src)) { - op = CAIRO_OPERATOR_ADD; - src = NULL; - } - - if (op == CAIRO_OPERATOR_SOURCE) { - status = _clip_and_composite_source (extents, src, - draw_func, draw_closure, dst); - } else { - if (op == CAIRO_OPERATOR_CLEAR) { - src = NULL; - op = CAIRO_OPERATOR_DEST_OUT; - } - - if (need_clip & NEED_CLIP_SURFACE) { - if (extents->is_bounded) { - status = _clip_and_composite_with_mask (extents, op, src, - draw_func, draw_closure, - dst); - } else { - status = _clip_and_composite_combine (extents, op, src, - draw_func, draw_closure, - dst); - } - } else { - status = draw_func (draw_closure, - dst->pixman_image, dst->pixman_format, - op, src, - 0, 0, - &dst->base.device_transform, - extents); - } - } - - if (status == CAIRO_STATUS_SUCCESS && ! extents->is_bounded) { - status = _cairo_image_surface_fixup_unbounded (dst, extents, - need_clip & NEED_CLIP_SURFACE ? extents->clip : NULL); - } - - if (clip_region != NULL) - _cairo_image_surface_unset_clip_region (dst); - - return status; -} - -#define CAIRO_FIXED_16_16_MIN _cairo_fixed_from_int (-32768) -#define CAIRO_FIXED_16_16_MAX _cairo_fixed_from_int (32767) - -static cairo_bool_t -_line_exceeds_16_16 (const cairo_line_t *line) -{ - return - line->p1.x <= CAIRO_FIXED_16_16_MIN || - line->p1.x >= CAIRO_FIXED_16_16_MAX || - - line->p2.x <= CAIRO_FIXED_16_16_MIN || - line->p2.x >= CAIRO_FIXED_16_16_MAX || - - line->p1.y <= CAIRO_FIXED_16_16_MIN || - line->p1.y >= CAIRO_FIXED_16_16_MAX || - - line->p2.y <= CAIRO_FIXED_16_16_MIN || - line->p2.y >= CAIRO_FIXED_16_16_MAX; -} - -static void -_project_line_x_onto_16_16 (const cairo_line_t *line, - cairo_fixed_t top, - cairo_fixed_t bottom, - pixman_line_fixed_t *out) -{ - cairo_point_double_t p1, p2; - double m; - - p1.x = _cairo_fixed_to_double (line->p1.x); - p1.y = _cairo_fixed_to_double (line->p1.y); - - p2.x = _cairo_fixed_to_double (line->p2.x); - p2.y = _cairo_fixed_to_double (line->p2.y); - - m = (p2.x - p1.x) / (p2.y - p1.y); - out->p1.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (top - line->p1.y)); - out->p2.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (bottom - line->p1.y)); -} - - -typedef struct { - cairo_trapezoid_t *traps; - int num_traps; - cairo_antialias_t antialias; -} composite_traps_info_t; - -static void -_pixman_image_add_traps (pixman_image_t *image, - int dst_x, int dst_y, - composite_traps_info_t *info) -{ - cairo_trapezoid_t *t = info->traps; - int num_traps = info->num_traps; - while (num_traps--) { - pixman_trapezoid_t trap; - - /* top/bottom will be clamped to surface bounds */ - trap.top = _cairo_fixed_to_16_16 (t->top); - trap.bottom = _cairo_fixed_to_16_16 (t->bottom); - - /* However, all the other coordinates will have been left untouched so - * as not to introduce numerical error. Recompute them if they - * exceed the 16.16 limits. - */ - if (unlikely (_line_exceeds_16_16 (&t->left))) { - _project_line_x_onto_16_16 (&t->left, t->top, t->bottom, &trap.left); - trap.left.p1.y = trap.top; - trap.left.p2.y = trap.bottom; - } else { - trap.left.p1.x = _cairo_fixed_to_16_16 (t->left.p1.x); - trap.left.p1.y = _cairo_fixed_to_16_16 (t->left.p1.y); - trap.left.p2.x = _cairo_fixed_to_16_16 (t->left.p2.x); - trap.left.p2.y = _cairo_fixed_to_16_16 (t->left.p2.y); - } - - if (unlikely (_line_exceeds_16_16 (&t->right))) { - _project_line_x_onto_16_16 (&t->right, t->top, t->bottom, &trap.right); - trap.right.p1.y = trap.top; - trap.right.p2.y = trap.bottom; - } else { - trap.right.p1.x = _cairo_fixed_to_16_16 (t->right.p1.x); - trap.right.p1.y = _cairo_fixed_to_16_16 (t->right.p1.y); - trap.right.p2.x = _cairo_fixed_to_16_16 (t->right.p2.x); - trap.right.p2.y = _cairo_fixed_to_16_16 (t->right.p2.y); - } - - pixman_rasterize_trapezoid (image, &trap, -dst_x, -dst_y); - - t++; - } -} - -static cairo_status_t -_composite_traps (void *closure, - pixman_image_t *dst, - pixman_format_code_t dst_format, - cairo_operator_t op, - const cairo_pattern_t *pattern, - int dst_x, - int dst_y, - cairo_matrix_t *dst_device_transform, - const cairo_composite_rectangles_t *extents) -{ - composite_traps_info_t *info = closure; - pixman_image_t *src, *mask; - pixman_format_code_t format; - int src_x = 0, src_y = 0; - cairo_status_t status; - - /* Special case adding trapezoids onto a mask surface; we want to avoid - * creating an intermediate temporary mask unnecessarily. - * - * We make the assumption here that the portion of the trapezoids - * contained within the surface is bounded by [dst_x,dst_y,width,height]; - * the Cairo core code passes bounds based on the trapezoid extents. - */ - format = info->antialias == CAIRO_ANTIALIAS_NONE ? PIXMAN_a1 : PIXMAN_a8; - if (dst_format == format && - (pattern == NULL || - (op == CAIRO_OPERATOR_ADD && _cairo_pattern_is_opaque_solid (pattern)))) - { - _pixman_image_add_traps (dst, dst_x, dst_y, info); - return CAIRO_STATUS_SUCCESS; - } - - src = _pixman_image_for_pattern (pattern, FALSE, &extents->bounded, - dst_device_transform, - &src_x, &src_y); - if (unlikely (src == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - mask = pixman_image_create_bits (format, - extents->bounded.width, - extents->bounded.height, - NULL, 0); - if (unlikely (mask == NULL)) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto CLEANUP_SOURCE; - } - - _pixman_image_add_traps (mask, extents->bounded.x, extents->bounded.y, info); - pixman_image_composite32 (_pixman_operator (op), - src, mask, dst, - extents->bounded.x + src_x, extents->bounded.y + src_y, - 0, 0, - extents->bounded.x - dst_x, extents->bounded.y - dst_y, - extents->bounded.width, extents->bounded.height); - - pixman_image_unref (mask); - - status = CAIRO_STATUS_SUCCESS; - CLEANUP_SOURCE: - pixman_image_unref (src); - - return status; -} - -static inline uint32_t -color_to_uint32 (const cairo_color_t *color) -{ - return - (color->alpha_short >> 8 << 24) | - (color->red_short >> 8 << 16) | - (color->green_short & 0xff00) | - (color->blue_short >> 8); -} - -static inline cairo_bool_t -color_to_pixel (const cairo_color_t *color, - pixman_format_code_t format, - uint32_t *pixel) -{ - uint32_t c; - - if (!(format == PIXMAN_a8r8g8b8 || - format == PIXMAN_x8r8g8b8 || - format == PIXMAN_a8b8g8r8 || - format == PIXMAN_x8b8g8r8 || - format == PIXMAN_b8g8r8a8 || - format == PIXMAN_b8g8r8x8 || - format == PIXMAN_r5g6b5 || - format == PIXMAN_b5g6r5 || - format == PIXMAN_a8)) - { - return FALSE; - } - - c = color_to_uint32 (color); - - if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_ABGR) { - c = ((c & 0xff000000) >> 0) | - ((c & 0x00ff0000) >> 16) | - ((c & 0x0000ff00) >> 0) | - ((c & 0x000000ff) << 16); - } - - if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_BGRA) { - c = ((c & 0xff000000) >> 24) | - ((c & 0x00ff0000) >> 8) | - ((c & 0x0000ff00) << 8) | - ((c & 0x000000ff) << 24); - } - - if (format == PIXMAN_a8) { - c = c >> 24; - } else if (format == PIXMAN_r5g6b5 || format == PIXMAN_b5g6r5) { - c = ((((c) >> 3) & 0x001f) | - (((c) >> 5) & 0x07e0) | - (((c) >> 8) & 0xf800)); - } - - *pixel = c; - return TRUE; -} - -static inline cairo_bool_t -pattern_to_pixel (const cairo_solid_pattern_t *solid, - cairo_operator_t op, - pixman_format_code_t format, - uint32_t *pixel) -{ - if (op == CAIRO_OPERATOR_CLEAR) { - *pixel = 0; - return TRUE; - } - - if (solid->base.type != CAIRO_PATTERN_TYPE_SOLID) - return FALSE; - - if (op == CAIRO_OPERATOR_OVER) { - if (solid->color.alpha_short >= 0xff00) - op = CAIRO_OPERATOR_SOURCE; - } - - if (op != CAIRO_OPERATOR_SOURCE) - return FALSE; - - return color_to_pixel (&solid->color, format, pixel); -} - -typedef struct _fill_span { - cairo_span_renderer_t base; - - uint8_t *mask_data; - pixman_image_t *src, *dst, *mask; -} fill_span_renderer_t; - -static cairo_status_t -_fill_span (void *abstract_renderer, - int y, int height, - const cairo_half_open_span_t *spans, - unsigned num_spans) -{ - fill_span_renderer_t *renderer = abstract_renderer; - uint8_t *row; - unsigned i; - - if (num_spans == 0) - return CAIRO_STATUS_SUCCESS; - - row = renderer->mask_data - spans[0].x; - for (i = 0; i < num_spans - 1; i++) { - /* We implement setting the most common single pixel wide - * span case to avoid the overhead of a memset call. - * Open coding setting longer spans didn't show a - * noticeable improvement over memset. - */ - if (spans[i+1].x == spans[i].x + 1) { - row[spans[i].x] = spans[i].coverage; - } else { - memset (row + spans[i].x, - spans[i].coverage, - spans[i+1].x - spans[i].x); - } - } - - do { - pixman_image_composite32 (PIXMAN_OP_OVER, - renderer->src, renderer->mask, renderer->dst, - 0, 0, 0, 0, - spans[0].x, y++, - spans[i].x - spans[0].x, 1); - } while (--height); - - return CAIRO_STATUS_SUCCESS; -} - -/* avoid using region code to re-validate boxes */ -static cairo_status_t -_fill_unaligned_boxes (cairo_image_surface_t *dst, - const cairo_pattern_t *pattern, - uint32_t pixel, - const cairo_boxes_t *boxes, - const cairo_composite_rectangles_t *extents) -{ - uint8_t buf[CAIRO_STACK_BUFFER_SIZE]; - fill_span_renderer_t renderer; - cairo_rectangular_scan_converter_t converter; - const struct _cairo_boxes_chunk *chunk; - cairo_status_t status; - int i; - - /* XXX - * using composite for fill: - * spiral-box-nonalign-evenodd-fill.512 2201957 2.202 - * spiral-box-nonalign-nonzero-fill.512 336726 0.337 - * spiral-box-pixalign-evenodd-fill.512 352256 0.352 - * spiral-box-pixalign-nonzero-fill.512 147056 0.147 - * using fill: - * spiral-box-nonalign-evenodd-fill.512 3174565 3.175 - * spiral-box-nonalign-nonzero-fill.512 182710 0.183 - * spiral-box-pixalign-evenodd-fill.512 353863 0.354 - * spiral-box-pixalign-nonzero-fill.512 147402 0.147 - * - * cairo-perf-trace seems to favour using fill. - */ - - renderer.base.render_rows = _fill_span; - renderer.dst = dst->pixman_image; - - if ((unsigned) extents->bounded.width <= sizeof (buf)) { - renderer.mask = pixman_image_create_bits (PIXMAN_a8, - extents->bounded.width, 1, - (uint32_t *) buf, - sizeof (buf)); - } else { - renderer.mask = pixman_image_create_bits (PIXMAN_a8, - extents->bounded.width, 1, - NULL, 0); - } - if (unlikely (renderer.mask == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - renderer.mask_data = (uint8_t *) pixman_image_get_data (renderer.mask); - - renderer.src = _pixman_image_for_solid ((const cairo_solid_pattern_t *) pattern); - if (unlikely (renderer.src == NULL)) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto CLEANUP_MASK; - } - - _cairo_rectangular_scan_converter_init (&converter, &extents->bounded); - - /* first blit any aligned part of the boxes */ - for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { - const cairo_box_t *box = chunk->base; - - for (i = 0; i < chunk->count; i++) { - int x1 = _cairo_fixed_integer_ceil (box[i].p1.x); - int y1 = _cairo_fixed_integer_ceil (box[i].p1.y); - int x2 = _cairo_fixed_integer_floor (box[i].p2.x); - int y2 = _cairo_fixed_integer_floor (box[i].p2.y); - - if (x2 > x1 && y2 > y1) { - cairo_box_t b; - - pixman_fill ((uint32_t *) dst->data, - dst->stride / sizeof (uint32_t), - PIXMAN_FORMAT_BPP (dst->pixman_format), - x1, y1, x2 - x1, y2 - y1, - pixel); - - /* - * Corners have to be included only once if the rects - * are passed to the rectangular scan converter - * because it can only handle disjoint rectangles. - */ - - /* top (including top-left and top-right corners) */ - if (! _cairo_fixed_is_integer (box[i].p1.y)) { - b.p1.x = box[i].p1.x; - b.p1.y = box[i].p1.y; - b.p2.x = box[i].p2.x; - b.p2.y = _cairo_fixed_from_int (y1); - - status = _cairo_rectangular_scan_converter_add_box (&converter, &b, 1); - if (unlikely (status)) - goto CLEANUP_CONVERTER; - } - - /* left (no corners) */ - if (! _cairo_fixed_is_integer (box[i].p1.x)) { - b.p1.x = box[i].p1.x; - b.p1.y = _cairo_fixed_from_int (y1); - b.p2.x = _cairo_fixed_from_int (x1); - b.p2.y = _cairo_fixed_from_int (y2); - - status = _cairo_rectangular_scan_converter_add_box (&converter, &b, 1); - if (unlikely (status)) - goto CLEANUP_CONVERTER; - } - - /* right (no corners) */ - if (! _cairo_fixed_is_integer (box[i].p2.x)) { - b.p1.x = _cairo_fixed_from_int (x2); - b.p1.y = _cairo_fixed_from_int (y1); - b.p2.x = box[i].p2.x; - b.p2.y = _cairo_fixed_from_int (y2); - - status = _cairo_rectangular_scan_converter_add_box (&converter, &b, 1); - if (unlikely (status)) - goto CLEANUP_CONVERTER; - } - - /* bottom (including bottom-left and bottom-right corners) */ - if (! _cairo_fixed_is_integer (box[i].p2.y)) { - b.p1.x = box[i].p1.x; - b.p1.y = _cairo_fixed_from_int (y2); - b.p2.x = box[i].p2.x; - b.p2.y = box[i].p2.y; - - status = _cairo_rectangular_scan_converter_add_box (&converter, &b, 1); - if (unlikely (status)) - goto CLEANUP_CONVERTER; - } - } else { - status = _cairo_rectangular_scan_converter_add_box (&converter, &box[i], 1); - if (unlikely (status)) - goto CLEANUP_CONVERTER; - } - } - } - - status = converter.base.generate (&converter.base, &renderer.base); - - CLEANUP_CONVERTER: - converter.base.destroy (&converter.base); - pixman_image_unref (renderer.src); - CLEANUP_MASK: - pixman_image_unref (renderer.mask); - - return status; -} - -typedef struct _cairo_image_surface_span_renderer { - cairo_span_renderer_t base; - - uint8_t *mask_data; - uint32_t mask_stride; -} cairo_image_surface_span_renderer_t; - -static cairo_status_t -_cairo_image_surface_span (void *abstract_renderer, - int y, int height, - const cairo_half_open_span_t *spans, - unsigned num_spans) -{ - cairo_image_surface_span_renderer_t *renderer = abstract_renderer; - uint8_t *row; - unsigned i; - - if (num_spans == 0) - return CAIRO_STATUS_SUCCESS; - - /* XXX will it be quicker to repeat the sparse memset, - * or perform a simpler memcpy? - * The fairly dense spiral benchmarks suggests that the sparse - * memset is a win there as well. - */ - row = renderer->mask_data + y * renderer->mask_stride; - do { - for (i = 0; i < num_spans - 1; i++) { - if (! spans[i].coverage) - continue; - - /* We implement setting rendering the most common single - * pixel wide span case to avoid the overhead of a memset - * call. Open coding setting longer spans didn't show a - * noticeable improvement over memset. */ - if (spans[i+1].x == spans[i].x + 1) { - row[spans[i].x] = spans[i].coverage; - } else { - memset (row + spans[i].x, - spans[i].coverage, - spans[i+1].x - spans[i].x); - } - } - row += renderer->mask_stride; - } while (--height); - - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_composite_unaligned_boxes (cairo_image_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *pattern, - const cairo_boxes_t *boxes, - const cairo_composite_rectangles_t *extents) -{ - uint8_t buf[CAIRO_STACK_BUFFER_SIZE]; - cairo_image_surface_span_renderer_t renderer; - cairo_rectangular_scan_converter_t converter; - pixman_image_t *mask, *src; - cairo_status_t status; - const struct _cairo_boxes_chunk *chunk; - int i, src_x, src_y; - - /* The below code breaks for operator source. This can best be seen with - * multiple boxes where black is drawn to dst outside of the boxes. */ - if (op == CAIRO_OPERATOR_SOURCE) - return CAIRO_INT_STATUS_UNSUPPORTED; - - i = CAIRO_STRIDE_FOR_WIDTH_BPP (extents->bounded.width, 8) * extents->bounded.height; - if ((unsigned) i <= sizeof (buf)) { - mask = pixman_image_create_bits (PIXMAN_a8, - extents->bounded.width, - extents->bounded.height, - (uint32_t *) buf, - CAIRO_STRIDE_FOR_WIDTH_BPP (extents->bounded.width, 8)); - memset (buf, 0, i); - } else { - mask = pixman_image_create_bits (PIXMAN_a8, - extents->bounded.width, - extents->bounded.height, - NULL, 0); - } - if (unlikely (mask == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - renderer.base.render_rows = _cairo_image_surface_span; - renderer.mask_stride = pixman_image_get_stride (mask); - renderer.mask_data = (uint8_t *) pixman_image_get_data (mask); - renderer.mask_data -= extents->bounded.y * renderer.mask_stride + extents->bounded.x; - - _cairo_rectangular_scan_converter_init (&converter, &extents->bounded); - - for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { - const cairo_box_t *box = chunk->base; - - for (i = 0; i < chunk->count; i++) { - status = _cairo_rectangular_scan_converter_add_box (&converter, &box[i], 1); - if (unlikely (status)) - goto CLEANUP; - } - } - - status = converter.base.generate (&converter.base, &renderer.base); - if (unlikely (status)) - goto CLEANUP; - - src = _pixman_image_for_pattern (pattern, FALSE, &extents->bounded, - &dst->base.device_transform, - &src_x, &src_y); - if (unlikely (src == NULL)) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto CLEANUP; - } - - pixman_image_composite32 (_pixman_operator (op), - src, mask, dst->pixman_image, - extents->bounded.x + src_x, extents->bounded.y + src_y, - 0, 0, - extents->bounded.x, extents->bounded.y, - extents->bounded.width, extents->bounded.height); - pixman_image_unref (src); - - CLEANUP: - converter.base.destroy (&converter.base); - pixman_image_unref (mask); - - return status; -} - -static cairo_bool_t -is_recording_pattern (const cairo_pattern_t *pattern) -{ - cairo_surface_t *surface; - - if (pattern->type != CAIRO_PATTERN_TYPE_SURFACE) - return FALSE; - - surface = ((const cairo_surface_pattern_t *) pattern)->surface; - if (_cairo_surface_is_paginated (surface)) - surface = _cairo_paginated_surface_get_recording (surface); - if (_cairo_surface_is_snapshot (surface)) - surface = _cairo_surface_snapshot_get_target (surface); - return _cairo_surface_is_recording (surface); -} - -static cairo_surface_t * -recording_pattern_get_surface (const cairo_pattern_t *pattern) -{ - cairo_surface_t *surface; - - surface = ((const cairo_surface_pattern_t *) pattern)->surface; - if (_cairo_surface_is_paginated (surface)) - surface = _cairo_paginated_surface_get_recording (surface); - if (_cairo_surface_is_snapshot (surface)) - surface = _cairo_surface_snapshot_get_target (surface); - return surface; -} - -static cairo_bool_t -op_reduces_to_source (cairo_operator_t op, - cairo_image_surface_t *dst) -{ - if (op == CAIRO_OPERATOR_SOURCE) - return TRUE; - - if (dst->base.is_clear) - return op == CAIRO_OPERATOR_OVER || op == CAIRO_OPERATOR_ADD; - - return FALSE; -} - -static cairo_bool_t -recording_pattern_contains_sample (const cairo_pattern_t *pattern, - const cairo_rectangle_int_t *extents) -{ - cairo_rectangle_int_t area; - cairo_recording_surface_t *surface; - - if (! is_recording_pattern (pattern)) - return FALSE; - - if (pattern->extend == CAIRO_EXTEND_NONE) - return TRUE; - - surface = (cairo_recording_surface_t *) recording_pattern_get_surface (pattern); - if (surface->unbounded) - return TRUE; - - sampled_area ((cairo_surface_pattern_t *) pattern, extents, &area); - if (area.x >= surface->extents.x && - area.y >= surface->extents.y && - area.x + area.width <= surface->extents.x + surface->extents.width && - area.y + area.height <= surface->extents.y + surface->extents.height) - { - return TRUE; - } - - return FALSE; -} - -static cairo_status_t -_composite_boxes (cairo_image_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_boxes_t *boxes, - const cairo_composite_rectangles_t *extents) -{ - cairo_region_t *clip_region = _cairo_clip_get_region (extents->clip); - cairo_bool_t need_clip_mask = extents->clip->path != NULL; - cairo_status_t status; - struct _cairo_boxes_chunk *chunk; - uint32_t pixel; - int i; - - if (need_clip_mask && - (op == CAIRO_OPERATOR_SOURCE || ! extents->is_bounded)) - { - return CAIRO_INT_STATUS_UNSUPPORTED; - } - - if (clip_region != NULL && cairo_region_num_rectangles (clip_region) == 1) - clip_region = NULL; - - if (! boxes->is_pixel_aligned) { - if (need_clip_mask) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (pattern_to_pixel ((cairo_solid_pattern_t *) pattern, op, - dst->pixman_format, &pixel)) - { - return _fill_unaligned_boxes (dst, pattern, pixel, boxes, extents); - } - else - { - return _composite_unaligned_boxes (dst, op, pattern, boxes, extents); - } - } - - /* Are we just copying a recording surface? */ - if (! need_clip_mask && - op_reduces_to_source (op, dst) && - recording_pattern_contains_sample (pattern, &extents->bounded)) - { - cairo_clip_t *recording_clip; - - /* XXX could also do tiling repeat modes... */ - - /* first clear the area about to be overwritten */ - if (! dst->base.is_clear) { - for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { - cairo_box_t *box = chunk->base; - - for (i = 0; i < chunk->count; i++) { - int x1 = _cairo_fixed_integer_part (box[i].p1.x); - int y1 = _cairo_fixed_integer_part (box[i].p1.y); - int x2 = _cairo_fixed_integer_part (box[i].p2.x); - int y2 = _cairo_fixed_integer_part (box[i].p2.y); - - if (x2 == x1 || y2 == y1) - continue; - - pixman_fill ((uint32_t *) dst->data, - dst->stride / sizeof (uint32_t), - PIXMAN_FORMAT_BPP (dst->pixman_format), - x1, y1, x2 - x1, y2 - y1, - 0); - } - } - } - - recording_clip = _cairo_clip_from_boxes (boxes); - status = _cairo_recording_surface_replay_with_clip (recording_pattern_get_surface (pattern), - &pattern->matrix, - &dst->base, - recording_clip); - _cairo_clip_destroy (recording_clip); - - return status; - } - - status = CAIRO_STATUS_SUCCESS; - if (! need_clip_mask && - pattern_to_pixel ((cairo_solid_pattern_t *) pattern, op, dst->pixman_format, - &pixel)) - { - for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { - cairo_box_t *box = chunk->base; - - for (i = 0; i < chunk->count; i++) { - int x1 = _cairo_fixed_integer_part (box[i].p1.x); - int y1 = _cairo_fixed_integer_part (box[i].p1.y); - int x2 = _cairo_fixed_integer_part (box[i].p2.x); - int y2 = _cairo_fixed_integer_part (box[i].p2.y); - - if (x2 == x1 || y2 == y1) - continue; - - pixman_fill ((uint32_t *) dst->data, dst->stride / sizeof (uint32_t), - PIXMAN_FORMAT_BPP (dst->pixman_format), - x1, y1, x2 - x1, y2 - y1, - pixel); - } - } - } - else - { - cairo_surface_t *clip_surface = NULL; - pixman_image_t *src = NULL, *mask = NULL; - int src_x, src_y, mask_x = 0, mask_y = 0; - pixman_op_t pixman_op = _pixman_operator (op); - - if (need_clip_mask) { - int clip_x, clip_y; - - clip_surface = _cairo_clip_get_surface (extents->clip, - &dst->base, - &clip_x, &clip_y); - if (unlikely (clip_surface->status)) - return clip_surface->status; - - mask_x = -clip_x; - mask_y = -clip_y; - - if (op == CAIRO_OPERATOR_CLEAR) { - pattern = NULL; - pixman_op = PIXMAN_OP_OUT_REVERSE; - } - - mask = ((cairo_image_surface_t *) clip_surface)->pixman_image; - } - - if (pattern != NULL) { - src = _pixman_image_for_pattern (pattern, FALSE, &extents->bounded, - &dst->base.device_transform, - &src_x, &src_y); - if (unlikely (src == NULL)) { - cairo_surface_destroy (clip_surface); - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - } else { - src = mask; - src_x = mask_x; - src_y = mask_y; - mask = NULL; - } - - for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { - const cairo_box_t *box = chunk->base; - - for (i = 0; i < chunk->count; i++) { - int x1 = _cairo_fixed_integer_part (box[i].p1.x); - int y1 = _cairo_fixed_integer_part (box[i].p1.y); - int x2 = _cairo_fixed_integer_part (box[i].p2.x); - int y2 = _cairo_fixed_integer_part (box[i].p2.y); - - if (x2 == x1 || y2 == y1) - continue; - - pixman_image_composite32 (pixman_op, - src, mask, dst->pixman_image, - x1 + src_x, y1 + src_y, - x1 + mask_x, y1 + mask_y, - x1, y1, - x2 - x1, y2 - y1); - } - } - - cairo_surface_destroy (clip_surface); - if (pattern != NULL) - pixman_image_unref (src); - - if (! extents->is_bounded) { - status = - _cairo_image_surface_fixup_unbounded_boxes (dst, extents, - clip_region, boxes); - } - } - - return status; -} - -static cairo_status_t -_clip_and_composite_polygon (cairo_image_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_polygon_t *polygon, - cairo_fill_rule_t fill_rule, - cairo_antialias_t antialias, - cairo_composite_rectangles_t *extents); - -static cairo_status_t -_clip_and_composite_boxes (cairo_image_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_boxes_t *boxes, - cairo_composite_rectangles_t *extents) -{ - cairo_traps_t traps; - cairo_int_status_t status; - composite_traps_info_t info; - - if (boxes->num_boxes == 0 && extents->is_bounded) - return CAIRO_STATUS_SUCCESS; - - /* Can we reduce drawing through a clip-mask to simply drawing the clip? */ - if (extents->clip->path != NULL && extents->is_bounded) { - cairo_polygon_t polygon; - cairo_fill_rule_t fill_rule; - cairo_antialias_t antialias; - cairo_clip_t *clip; - - clip = _cairo_clip_copy (extents->clip); - clip = _cairo_clip_intersect_boxes (clip, boxes); - status = _cairo_clip_get_polygon (clip, &polygon, - &fill_rule, &antialias); - _cairo_clip_path_destroy (clip->path); - clip->path = NULL; - if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { - cairo_clip_t *saved_clip = extents->clip; - extents->clip = clip; - status = _clip_and_composite_polygon (dst, op, src, - &polygon, - fill_rule, - antialias, - extents); - if (extents->clip != clip) - clip = NULL; - extents->clip = saved_clip; - _cairo_polygon_fini (&polygon); - } - if (clip) - _cairo_clip_destroy (clip); - - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - } - - /* Use a fast path if the boxes are pixel aligned */ - status = _composite_boxes (dst, op, src, boxes, extents); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - - /* Otherwise render via a mask and composite in the usual fashion. */ - status = _cairo_traps_init_boxes (&traps, boxes); - if (unlikely (status)) - return status; - - info.num_traps = traps.num_traps; - info.traps = traps.traps; - info.antialias = CAIRO_ANTIALIAS_DEFAULT; - status = _clip_and_composite (dst, op, src, - _composite_traps, &info, - extents, need_unbounded_clip (extents)); - - _cairo_traps_fini (&traps); - return status; -} - -static cairo_bool_t -_mono_edge_is_vertical (const cairo_line_t *line) -{ - return _cairo_fixed_integer_round_down (line->p1.x) == _cairo_fixed_integer_round_down (line->p2.x); -} - -static cairo_bool_t -_traps_are_pixel_aligned (cairo_traps_t *traps, - cairo_antialias_t antialias) -{ - int i; - - if (antialias == CAIRO_ANTIALIAS_NONE) { - for (i = 0; i < traps->num_traps; i++) { - if (! _mono_edge_is_vertical (&traps->traps[i].left) || - ! _mono_edge_is_vertical (&traps->traps[i].right)) - { - traps->maybe_region = FALSE; - return FALSE; - } - } - } else { - for (i = 0; i < traps->num_traps; i++) { - if (traps->traps[i].left.p1.x != traps->traps[i].left.p2.x || - traps->traps[i].right.p1.x != traps->traps[i].right.p2.x || - ! _cairo_fixed_is_integer (traps->traps[i].top) || - ! _cairo_fixed_is_integer (traps->traps[i].bottom) || - ! _cairo_fixed_is_integer (traps->traps[i].left.p1.x) || - ! _cairo_fixed_is_integer (traps->traps[i].right.p1.x)) - { - traps->maybe_region = FALSE; - return FALSE; - } - } - } - - return TRUE; -} - -static void -_boxes_for_traps (cairo_boxes_t *boxes, - cairo_traps_t *traps, - cairo_antialias_t antialias) -{ - int i; - - _cairo_boxes_init (boxes); - - boxes->num_boxes = traps->num_traps; - boxes->chunks.base = (cairo_box_t *) traps->traps; - boxes->chunks.count = traps->num_traps; - boxes->chunks.size = traps->num_traps; - - if (antialias != CAIRO_ANTIALIAS_NONE) { - for (i = 0; i < traps->num_traps; i++) { - /* Note the traps and boxes alias so we need to take the local copies first. */ - cairo_fixed_t x1 = traps->traps[i].left.p1.x; - cairo_fixed_t x2 = traps->traps[i].right.p1.x; - cairo_fixed_t y1 = traps->traps[i].top; - cairo_fixed_t y2 = traps->traps[i].bottom; - - boxes->chunks.base[i].p1.x = x1; - boxes->chunks.base[i].p1.y = y1; - boxes->chunks.base[i].p2.x = x2; - boxes->chunks.base[i].p2.y = y2; - - if (boxes->is_pixel_aligned) { - boxes->is_pixel_aligned = - _cairo_fixed_is_integer (x1) && _cairo_fixed_is_integer (y1) && - _cairo_fixed_is_integer (x2) && _cairo_fixed_is_integer (y2); - } - } - } else { - boxes->is_pixel_aligned = TRUE; - - for (i = 0; i < traps->num_traps; i++) { - /* Note the traps and boxes alias so we need to take the local copies first. */ - cairo_fixed_t x1 = traps->traps[i].left.p1.x; - cairo_fixed_t x2 = traps->traps[i].right.p1.x; - cairo_fixed_t y1 = traps->traps[i].top; - cairo_fixed_t y2 = traps->traps[i].bottom; - - /* round down here to match Pixman's behavior when using traps. */ - boxes->chunks.base[i].p1.x = _cairo_fixed_round_down (x1); - boxes->chunks.base[i].p1.y = _cairo_fixed_round_down (y1); - boxes->chunks.base[i].p2.x = _cairo_fixed_round_down (x2); - boxes->chunks.base[i].p2.y = _cairo_fixed_round_down (y2); - } - } -} - -static cairo_status_t -_clip_and_composite_trapezoids (cairo_image_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_traps_t *traps, - cairo_antialias_t antialias, - cairo_composite_rectangles_t *extents) -{ - composite_traps_info_t info; - cairo_bool_t need_clip_surface = FALSE; - cairo_status_t status; - - if (traps->num_traps == 0 && extents->is_bounded) - return CAIRO_STATUS_SUCCESS; - - need_clip_surface = ! _cairo_clip_is_region (extents->clip); - - if (traps->has_intersections) { - if (traps->is_rectangular) - status = _cairo_bentley_ottmann_tessellate_rectangular_traps (traps, CAIRO_FILL_RULE_WINDING); - else if (traps->is_rectilinear) - status = _cairo_bentley_ottmann_tessellate_rectilinear_traps (traps, CAIRO_FILL_RULE_WINDING); - else - status = _cairo_bentley_ottmann_tessellate_traps (traps, CAIRO_FILL_RULE_WINDING); - if (unlikely (status)) - return status; - } - - /* Use a fast path if the trapezoids consist of a simple region, - * but we can only do this if we do not have a clip surface, or can - * substitute the mask with the clip. - */ - if (traps->maybe_region && _traps_are_pixel_aligned (traps, antialias) && - (! need_clip_surface || - (extents->is_bounded && op != CAIRO_OPERATOR_SOURCE))) - { - cairo_boxes_t boxes; - - _boxes_for_traps (&boxes, traps, antialias); - return _clip_and_composite_boxes (dst, op, src, - &boxes, extents); - } - - /* No fast path, exclude self-intersections and clip trapezoids. */ - /* Otherwise render the trapezoids to a mask and composite in the usual - * fashion. - */ - info.traps = traps->traps; - info.num_traps = traps->num_traps; - info.antialias = antialias; - return _clip_and_composite (dst, op, src, - _composite_traps, &info, - extents, need_unbounded_clip (extents)); -} - /* high level image interface */ cairo_bool_t _cairo_image_surface_get_extents (void *abstract_surface, @@ -3449,235 +859,10 @@ _cairo_image_surface_paint (void *abstract_surface, const cairo_clip_t *clip) { cairo_image_surface_t *surface = abstract_surface; - cairo_rectangle_int_t unbounded; - cairo_composite_rectangles_t extents; - cairo_status_t status; - cairo_boxes_t boxes; - - _cairo_image_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_paint (&extents, &unbounded, - op, source, - clip); - if (unlikely (status)) - return status; - - /* If the clip cannot be reduced to a set of boxes, we will need to - * use a clipmask. Paint is special as it is the only operation that - * does not implicitly use a mask, so we may be able to reduce this - * operation to a fill... - */ - - status = _cairo_clip_to_boxes (extents.clip, &boxes); - if (likely (status == CAIRO_STATUS_SUCCESS)) { - status = _clip_and_composite_boxes (surface, op, source, - &boxes, &extents); - _cairo_boxes_fini (&boxes); - } - - _cairo_composite_rectangles_fini (&extents); - - return status; -} - -static cairo_status_t -_composite_mask (void *closure, - pixman_image_t *dst, - pixman_format_code_t dst_format, - cairo_operator_t op, - const cairo_pattern_t *src_pattern, - int dst_x, - int dst_y, - cairo_matrix_t *dst_device_transform, - const cairo_composite_rectangles_t *extents) -{ - const cairo_pattern_t *mask_pattern = closure; - pixman_image_t *src, *mask = NULL; - int src_x = 0, src_y = 0; - int mask_x = 0, mask_y = 0; - - if (src_pattern != NULL) { - src = _pixman_image_for_pattern (src_pattern, FALSE, &extents->bounded, - dst_device_transform, - &src_x, &src_y); - if (unlikely (src == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - mask = _pixman_image_for_pattern (mask_pattern, TRUE, &extents->bounded, - dst_device_transform, - &mask_x, &mask_y); - if (unlikely (mask == NULL)) { - pixman_image_unref (src); - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - if (mask_pattern->has_component_alpha) - pixman_image_set_component_alpha (mask, TRUE); - } else { - src = _pixman_image_for_pattern (mask_pattern, FALSE, &extents->bounded, - dst_device_transform, - &src_x, &src_y); - if (unlikely (src == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - pixman_image_composite32 (_pixman_operator (op), src, mask, dst, - extents->bounded.x + src_x, extents->bounded.y + src_y, - extents->bounded.x + mask_x, extents->bounded.y + mask_y, - extents->bounded.x - dst_x, extents->bounded.y - dst_y, - extents->bounded.width, extents->bounded.height); - - if (mask != NULL) - pixman_image_unref (mask); - pixman_image_unref (src); - - return CAIRO_STATUS_SUCCESS; -} - -static void do_unaligned_row(void (*blt)(void *closure, - int16_t x, int16_t y, - int16_t w, int16_t h, - uint16_t coverage), - void *closure, - const cairo_box_t *b, - int tx, int y, int h, - uint16_t coverage) -{ - int x1 = _cairo_fixed_integer_part (b->p1.x) - tx; - int x2 = _cairo_fixed_integer_part (b->p2.x) - tx; - if (x2 > x1) { - if (! _cairo_fixed_is_integer (b->p1.x)) { - blt(closure, x1, y, 1, h, - coverage * (256 - _cairo_fixed_fractional_part (b->p1.x))); - x1++; - } - - if (x2 > x1) - blt(closure, x1, y, x2-x1, h, (coverage << 8) - (coverage >> 8)); - - if (! _cairo_fixed_is_integer (b->p2.x)) - blt(closure, x2, y, 1, h, - coverage * _cairo_fixed_fractional_part (b->p2.x)); - } else - blt(closure, x1, y, 1, h, - coverage * (b->p2.x - b->p1.x)); -} - -static void do_unaligned_box(void (*blt)(void *closure, - int16_t x, int16_t y, - int16_t w, int16_t h, - uint16_t coverage), - void *closure, - const cairo_box_t *b, int tx, int ty) -{ - int y1 = _cairo_fixed_integer_part (b->p1.y) - ty; - int y2 = _cairo_fixed_integer_part (b->p2.y) - ty; - if (y2 > y1) { - if (! _cairo_fixed_is_integer (b->p1.y)) { - do_unaligned_row(blt, closure, b, tx, y1, 1, - 256 - _cairo_fixed_fractional_part (b->p1.y)); - y1++; - } - - if (y2 > y1) - do_unaligned_row(blt, closure, b, tx, y1, y2-y1, 256); - - if (! _cairo_fixed_is_integer (b->p2.y)) - do_unaligned_row(blt, closure, b, tx, y2, 1, - _cairo_fixed_fractional_part (b->p2.y)); - } else - do_unaligned_row(blt, closure, b, tx, y1, 1, - b->p2.y - b->p1.y); -} - -struct composite_opacity_info { - uint8_t op; - pixman_image_t *dst; - pixman_image_t *src; - int src_x, src_y; - double opacity; -}; - -static void composite_opacity(void *closure, - int16_t x, int16_t y, - int16_t w, int16_t h, - uint16_t coverage) -{ - struct composite_opacity_info *info = closure; - pixman_color_t color; - pixman_image_t *mask; - - color.red = 0; - color.green = 0; - color.blue = 0; - color.alpha = coverage * info->opacity; - - mask = pixman_image_create_solid_fill (&color); - if (mask == NULL) - return; - - if (info->src) { - pixman_image_composite32 (info->op, - info->src, - mask, - info->dst, - x + info->src_x, y + info->src_y, - 0, 0, - x, y, - w, h); - } else { - pixman_image_composite32 (info->op, - mask, - NULL, - info->dst, - 0, 0, - 0, 0, - x, y, - w, h); - } - - pixman_image_unref (mask); + return _cairo_compositor_paint (surface->compositor, + &surface->base, op, source, clip); } -static cairo_status_t -_composite_opacity_boxes (void *closure, - pixman_image_t *dst, - pixman_format_code_t dst_format, - cairo_operator_t op, - const cairo_pattern_t *src_pattern, - int dst_x, - int dst_y, - cairo_matrix_t *dst_device_transform, - const cairo_composite_rectangles_t *extents) -{ - const cairo_solid_pattern_t *mask_pattern = closure; - struct composite_opacity_info info; - int i; - - info.op = _pixman_operator (op); - info.dst = dst; - - if (src_pattern != NULL) { - info.src = _pixman_image_for_pattern (src_pattern, TRUE, &extents->bounded, - dst_device_transform, - &info.src_x, &info.src_y); - if (unlikely (info.src == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } else - info.src = NULL; - - info.opacity = mask_pattern->color.alpha; - - /* XXX for lots of boxes create a clip region for the fully opaque areas */ - for (i = 0; i < extents->clip->num_boxes; i++) - do_unaligned_box(composite_opacity, &info, - &extents->clip->boxes[i], dst_x, dst_y); - if (info.src) - pixman_image_unref (info.src); - - return CAIRO_STATUS_SUCCESS; -} - - static cairo_int_status_t _cairo_image_surface_mask (void *abstract_surface, cairo_operator_t op, @@ -3686,225 +871,8 @@ _cairo_image_surface_mask (void *abstract_surface, const cairo_clip_t *clip) { cairo_image_surface_t *surface = abstract_surface; - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; - cairo_status_t status; - - _cairo_image_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_mask (&extents, &unbounded, - op, source, mask, clip); - if (unlikely (status)) - return status; - - if (mask->type == CAIRO_PATTERN_TYPE_SOLID && - extents.clip->path == NULL && - ! _cairo_clip_is_region (extents.clip)) - { - status = _clip_and_composite (surface, op, source, - _composite_opacity_boxes, (void *) mask, - &extents, need_bounded_clip (&extents)); - } else { - status = _clip_and_composite (surface, op, source, - _composite_mask, (void *) mask, - &extents, need_bounded_clip (&extents)); - } - - _cairo_composite_rectangles_fini (&extents); - - return status; -} - -typedef struct { - cairo_polygon_t *polygon; - cairo_fill_rule_t fill_rule; - cairo_antialias_t antialias; -} composite_spans_info_t; - -//#define USE_BOTOR_SCAN_CONVERTER -static cairo_status_t -_composite_spans (void *closure, - pixman_image_t *dst, - pixman_format_code_t dst_format, - cairo_operator_t op, - const cairo_pattern_t *pattern, - int dst_x, - int dst_y, - cairo_matrix_t *dst_device_transform, - const cairo_composite_rectangles_t *extents) -{ - uint8_t mask_buf[CAIRO_STACK_BUFFER_SIZE]; - composite_spans_info_t *info = closure; - cairo_image_surface_span_renderer_t renderer; -#if USE_BOTOR_SCAN_CONVERTER - cairo_box_t box; - cairo_botor_scan_converter_t converter; -#else - cairo_scan_converter_t *converter; -#endif - pixman_image_t *mask; - const cairo_rectangle_int_t *r = &extents->bounded; - cairo_status_t status; - -#if USE_BOTOR_SCAN_CONVERTER - box.p1.x = _cairo_fixed_from_int (r->x); - box.p1.y = _cairo_fixed_from_int (r->y); - box.p2.x = _cairo_fixed_from_int (r->x + r->width); - box.p2.y = _cairo_fixed_from_int (r->y + r->height); - _cairo_botor_scan_converter_init (&converter, &box, info->fill_rule); - status = converter.base.add_polygon (&converter.base, info->polygon); -#else - converter = _cairo_tor_scan_converter_create (r->x, r->y, - r->x + r->width, - r->y + r->height, - info->fill_rule); - status = converter->add_polygon (converter, info->polygon); -#endif - if (unlikely (status)) - goto CLEANUP_CONVERTER; - - /* TODO: support rendering to A1 surfaces (or: go add span - * compositing to pixman.) */ - - if (pattern == NULL && - dst_format == PIXMAN_a8 && - op == CAIRO_OPERATOR_SOURCE) - { - mask = dst; - dst = NULL; - } - else - { - int stride = CAIRO_STRIDE_FOR_WIDTH_BPP (r->width, 8); - uint8_t *data = mask_buf; - - if (r->height * stride <= (int) sizeof (mask_buf)) - memset (data, 0, r->height * stride); - else - data = NULL, stride = 0; - - mask = pixman_image_create_bits (PIXMAN_a8, - r->width, - r->height, - (uint32_t *) data, - stride); - if (unlikely (mask == NULL)) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto CLEANUP_CONVERTER; - } - } - - renderer.base.render_rows = _cairo_image_surface_span; - renderer.mask_stride = pixman_image_get_stride (mask); - renderer.mask_data = (uint8_t *) pixman_image_get_data (mask); - if (dst != NULL) - renderer.mask_data -= r->y * renderer.mask_stride + r->x; - else - renderer.mask_data -= dst_y * renderer.mask_stride + dst_x; - -#if USE_BOTOR_SCAN_CONVERTER - status = converter.base.generate (&converter.base, &renderer.base); -#else - status = converter->generate (converter, &renderer.base); -#endif - if (unlikely (status)) - goto CLEANUP_RENDERER; - - if (dst != NULL) { - pixman_image_t *src; - int src_x, src_y; - - src = _pixman_image_for_pattern (pattern, FALSE, r, - dst_device_transform, - &src_x, &src_y); - if (unlikely (src == NULL)) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto CLEANUP_RENDERER; - } - - pixman_image_composite32 (_pixman_operator (op), src, mask, dst, - r->x + src_x, r->y + src_y, - 0, 0, /* mask.x, mask.y */ - r->x - dst_x, r->y - dst_y, - r->width, r->height); - pixman_image_unref (src); - } - - CLEANUP_RENDERER: - if (dst != NULL) - pixman_image_unref (mask); - CLEANUP_CONVERTER: -#if USE_BOTOR_SCAN_CONVERTER - converter.base.destroy (&converter.base); -#else - converter->destroy (converter); -#endif - return status; -} - -static cairo_status_t -_clip_and_composite_polygon (cairo_image_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_polygon_t *polygon, - cairo_fill_rule_t fill_rule, - cairo_antialias_t antialias, - cairo_composite_rectangles_t *extents) -{ - cairo_status_t status; - - if (_cairo_polygon_is_empty (polygon)) { - cairo_boxes_t boxes; - - if (extents->is_bounded) - return CAIRO_STATUS_SUCCESS; - - status = _cairo_clip_to_boxes (extents->clip, &boxes); - if (likely (status == CAIRO_STATUS_SUCCESS)) { - extents->is_bounded = _cairo_operator_bounded_by_either (op); - extents->mask = extents->bounded = extents->unbounded; - status = _clip_and_composite_boxes (dst, - CAIRO_OPERATOR_CLEAR, - &_cairo_pattern_clear.base, - &boxes, extents); - _cairo_boxes_fini (&boxes); - } - - return status; - } - - _cairo_box_round_to_rectangle (&polygon->extents, &extents->mask); - if (! _cairo_rectangle_intersect (&extents->bounded, &extents->mask)) - return CAIRO_STATUS_SUCCESS; - - if (antialias != CAIRO_ANTIALIAS_NONE) { - composite_spans_info_t info; - - info.polygon = polygon; - info.fill_rule = fill_rule; - info.antialias = antialias; - - status = _clip_and_composite (dst, op, src, - _composite_spans, &info, - extents, need_unbounded_clip (extents)); - } else { - cairo_traps_t traps; - - _cairo_traps_init (&traps); - - /* Fall back to trapezoid fills. */ - status = _cairo_bentley_ottmann_tessellate_polygon (&traps, - polygon, - fill_rule); - if (likely (status == CAIRO_STATUS_SUCCESS)) { - status = _clip_and_composite_trapezoids (dst, op, src, - &traps, antialias, - extents); - } - - _cairo_traps_fini (&traps); - } - - return status; + return _cairo_compositor_mask (surface->compositor, + &surface->base, op, source, mask, clip); } static cairo_int_status_t @@ -3920,56 +888,10 @@ _cairo_image_surface_stroke (void *abstract_surface, const cairo_clip_t *clip) { cairo_image_surface_t *surface = abstract_surface; - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; - cairo_int_status_t status; - - _cairo_image_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_stroke (&extents, &unbounded, - op, source, - path, style, ctm, - clip); - if (unlikely (status)) - return status; - - status = CAIRO_INT_STATUS_UNSUPPORTED; - if (_cairo_path_fixed_stroke_is_rectilinear (path)) { - cairo_boxes_t boxes; - - _cairo_boxes_init_with_clip (&boxes, extents.clip); - status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path, - style, - ctm, - antialias, - &boxes); - if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { - status = _clip_and_composite_boxes (surface, op, source, - &boxes, &extents); - } - _cairo_boxes_fini (&boxes); - } - - if (status == CAIRO_INT_STATUS_UNSUPPORTED) { - cairo_polygon_t polygon; - - _cairo_polygon_init_with_clip (&polygon, extents.clip); - status = _cairo_path_fixed_stroke_to_polygon (path, - style, - ctm, ctm_inverse, - tolerance, - &polygon); - if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { - status = _clip_and_composite_polygon (surface, op, source, &polygon, - CAIRO_FILL_RULE_WINDING, - antialias, - &extents); - } - _cairo_polygon_fini (&polygon); - } - - _cairo_composite_rectangles_fini (&extents); - - return status; + return _cairo_compositor_stroke (surface->compositor, &surface->base, + op, source, path, + style, ctm, ctm_inverse, + tolerance, antialias, clip); } static cairo_int_status_t @@ -3983,291 +905,10 @@ _cairo_image_surface_fill (void *abstract_surface, const cairo_clip_t *clip) { cairo_image_surface_t *surface = abstract_surface; - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; - cairo_status_t status; - - _cairo_image_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_fill (&extents, &unbounded, - op, source, path, - clip); - if (unlikely (status)) - return status; - - if (_cairo_path_fixed_fill_is_rectilinear (path)) { - cairo_boxes_t boxes; - - _cairo_boxes_init_with_clip (&boxes, extents.clip); - status = _cairo_path_fixed_fill_rectilinear_to_boxes (path, - fill_rule, - antialias, - &boxes); - if (likely (status == CAIRO_STATUS_SUCCESS)) { - status = _clip_and_composite_boxes (surface, op, source, - &boxes, &extents); - } - _cairo_boxes_fini (&boxes); - } else { - cairo_polygon_t polygon; - - assert (! _cairo_path_fixed_fill_is_empty (path)); - - _cairo_polygon_init_with_clip (&polygon, extents.clip); - status = _cairo_path_fixed_fill_to_polygon (path, tolerance, &polygon); - if (likely (status == CAIRO_STATUS_SUCCESS)) { - status = _clip_and_composite_polygon (surface, op, source, &polygon, - fill_rule, antialias, - &extents); - } - _cairo_polygon_fini (&polygon); - } - - _cairo_composite_rectangles_fini (&extents); - - return status; -} - -typedef struct { - cairo_scaled_font_t *font; - cairo_glyph_t *glyphs; - int num_glyphs; -} composite_glyphs_info_t; - -static cairo_status_t -_composite_glyphs_via_mask (void *closure, - pixman_image_t *dst, - pixman_format_code_t dst_format, - cairo_operator_t op, - const cairo_pattern_t *pattern, - int dst_x, - int dst_y, - cairo_matrix_t *dst_device_transform, - const cairo_composite_rectangles_t *extents) -{ - composite_glyphs_info_t *info = closure; - cairo_scaled_font_t *font = info->font; - cairo_glyph_t *glyphs = info->glyphs; - int num_glyphs = info->num_glyphs; - pixman_image_t *mask = NULL; - pixman_image_t *src; - pixman_image_t *white; - pixman_format_code_t mask_format = 0; /* silence gcc */ - cairo_status_t status = CAIRO_STATUS_SUCCESS; /* silence gcc */ - int src_x, src_y; - int i; - - src = _pixman_image_for_pattern (pattern, FALSE, &extents->bounded, - dst_device_transform, - &src_x, &src_y); - if (unlikely (src == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - white = _pixman_white_image (); - if (unlikely (white == NULL)) { - pixman_image_unref (src); - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - _cairo_scaled_font_freeze_cache (font); - - for (i = 0; i < num_glyphs; i++) { - int x, y; - cairo_image_surface_t *glyph_surface; - cairo_scaled_glyph_t *scaled_glyph; - - status = _cairo_scaled_glyph_lookup (font, glyphs[i].index, - CAIRO_SCALED_GLYPH_INFO_SURFACE, - &scaled_glyph); - - if (unlikely (status)) - goto CLEANUP; - - glyph_surface = scaled_glyph->surface; - - if (glyph_surface->width == 0 || glyph_surface->height == 0) - continue; - - /* To start, create the mask using the format from the first - * glyph. Later we'll deal with different formats. */ - if (mask == NULL) { - mask_format = glyph_surface->pixman_format; - mask = pixman_image_create_bits (mask_format, - extents->bounded.width, - extents->bounded.height, - NULL, 0); - if (unlikely (mask == NULL)) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto CLEANUP; - } - - if (PIXMAN_FORMAT_RGB (mask_format)) - pixman_image_set_component_alpha (mask, TRUE); - } - - /* If we have glyphs of different formats, we "upgrade" the mask - * to the wider of the formats. */ - if (glyph_surface->pixman_format != mask_format && - PIXMAN_FORMAT_BPP (mask_format) < - PIXMAN_FORMAT_BPP (glyph_surface->pixman_format)) - { - pixman_image_t *new_mask; - - mask_format = glyph_surface->pixman_format; - new_mask = pixman_image_create_bits (mask_format, - extents->bounded.width, - extents->bounded.height, - NULL, 0); - if (unlikely (new_mask == NULL)) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto CLEANUP; - } - - pixman_image_composite32 (PIXMAN_OP_SRC, - white, mask, new_mask, - 0, 0, 0, 0, 0, 0, - extents->bounded.width, - extents->bounded.height); - - pixman_image_unref (mask); - mask = new_mask; - if (PIXMAN_FORMAT_RGB (mask_format)) - pixman_image_set_component_alpha (mask, TRUE); - } - - /* round glyph locations to the nearest pixel */ - /* XXX: FRAGILE: We're ignoring device_transform scaling here. A bug? */ - x = _cairo_lround (glyphs[i].x - - glyph_surface->base.device_transform.x0); - y = _cairo_lround (glyphs[i].y - - glyph_surface->base.device_transform.y0); - if (glyph_surface->pixman_format == mask_format) { - pixman_image_composite32 (PIXMAN_OP_ADD, - glyph_surface->pixman_image, NULL, mask, - 0, 0, 0, 0, - x - extents->bounded.x, y - extents->bounded.y, - glyph_surface->width, - glyph_surface->height); - } else { - pixman_image_composite32 (PIXMAN_OP_ADD, - white, glyph_surface->pixman_image, mask, - 0, 0, 0, 0, - x - extents->bounded.x, y - extents->bounded.y, - glyph_surface->width, - glyph_surface->height); - } - } - - pixman_image_composite32 (_pixman_operator (op), - src, mask, dst, - extents->bounded.x + src_x, extents->bounded.y + src_y, - 0, 0, - extents->bounded.x - dst_x, extents->bounded.y - dst_y, - extents->bounded.width, extents->bounded.height); - -CLEANUP: - _cairo_scaled_font_thaw_cache (font); - if (mask != NULL) - pixman_image_unref (mask); - pixman_image_unref (src); - pixman_image_unref (white); - - return status; -} - -static cairo_status_t -_composite_glyphs (void *closure, - pixman_image_t *dst, - pixman_format_code_t dst_format, - cairo_operator_t op, - const cairo_pattern_t *pattern, - int dst_x, - int dst_y, - cairo_matrix_t *dst_device_transform, - const cairo_composite_rectangles_t *extents) -{ - composite_glyphs_info_t *info = closure; - cairo_scaled_glyph_t *glyph_cache[64]; - pixman_op_t pixman_op = _pixman_operator (op); - pixman_image_t *src = NULL; - int src_x = 0, src_y = 0; - cairo_status_t status; - int i; - - if (pattern != NULL) { - src = _pixman_image_for_pattern (pattern, FALSE, &extents->bounded, - dst_device_transform, - &src_x, &src_y); - src_x -= dst_x; - src_y -= dst_y; - } else { - src = _pixman_white_image (); - } - if (unlikely (src == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - memset (glyph_cache, 0, sizeof (glyph_cache)); - status = CAIRO_STATUS_SUCCESS; - - _cairo_scaled_font_freeze_cache (info->font); - for (i = 0; i < info->num_glyphs; i++) { - int x, y; - cairo_image_surface_t *glyph_surface; - cairo_scaled_glyph_t *scaled_glyph; - unsigned long glyph_index = info->glyphs[i].index; - int cache_index = glyph_index % ARRAY_LENGTH (glyph_cache); - - scaled_glyph = glyph_cache[cache_index]; - if (scaled_glyph == NULL || - _cairo_scaled_glyph_index (scaled_glyph) != glyph_index) - { - status = _cairo_scaled_glyph_lookup (info->font, glyph_index, - CAIRO_SCALED_GLYPH_INFO_SURFACE, - &scaled_glyph); - - if (unlikely (status)) - break; - - glyph_cache[cache_index] = scaled_glyph; - } - - glyph_surface = scaled_glyph->surface; - if (glyph_surface->width && glyph_surface->height) { - int x1, y1, x2, y2; - - /* round glyph locations to the nearest pixel */ - /* XXX: FRAGILE: We're ignoring device_transform scaling here. A bug? */ - x = _cairo_lround (info->glyphs[i].x - - glyph_surface->base.device_transform.x0); - y = _cairo_lround (info->glyphs[i].y - - glyph_surface->base.device_transform.y0); - - x1 = x; - if (x1 < extents->bounded.x) - x1 = extents->bounded.x; - x2 = x + glyph_surface->width; - if (x2 > extents->bounded.x + extents->bounded.width) - x2 = extents->bounded.x + extents->bounded.width; - - y1 = y; - if (y1 < extents->bounded.y) - y1 = extents->bounded.y; - y2 = y + glyph_surface->height; - if (y2 > extents->bounded.y + extents->bounded.height) - y2 = extents->bounded.y + extents->bounded.height; - - pixman_image_composite32 (pixman_op, - src, glyph_surface->pixman_image, dst, - x1 + src_x, y1 + src_y, - x1 - x, y1 - y, - x1 - dst_x, y1 - dst_y, - x2 - x1, y2 - y1); - } - } - _cairo_scaled_font_thaw_cache (info->font); - - pixman_image_unref (src); - - return status; + return _cairo_compositor_fill (surface->compositor, &surface->base, + op, source, path, + fill_rule, tolerance, antialias, + clip); } static cairo_int_status_t @@ -4277,49 +918,13 @@ _cairo_image_surface_glyphs (void *abstract_surface, cairo_glyph_t *glyphs, int num_glyphs, cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip, - int *num_remaining) + const cairo_clip_t *clip) { cairo_image_surface_t *surface = abstract_surface; - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; - composite_glyphs_info_t glyph_info; - cairo_status_t status; - cairo_bool_t overlap; - unsigned int flags; - - _cairo_image_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_glyphs (&extents, &unbounded, - op, source, - scaled_font, - glyphs, num_glyphs, - clip, - &overlap); - if (unlikely (status)) - return status; - - glyph_info.font = scaled_font; - glyph_info.glyphs = glyphs; - glyph_info.num_glyphs = num_glyphs; - - flags = 0; - if (extents.mask.width > extents.unbounded.width || - extents.mask.height > extents.unbounded.height) - { - flags |= FORCE_CLIP_REGION; - } - status = _clip_and_composite (surface, op, source, - overlap || extents.is_bounded == 0 ? - _composite_glyphs_via_mask : - _composite_glyphs, - &glyph_info, - &extents, - need_bounded_clip (&extents) | flags); - - _cairo_composite_rectangles_fini (&extents); - - *num_remaining = 0; - return status; + return _cairo_compositor_glyphs (surface->compositor, &surface->base, + op, source, + glyphs, num_glyphs, scaled_font, + clip); } void @@ -4332,494 +937,6 @@ _cairo_image_surface_get_font_options (void *abstract_surface, _cairo_font_options_set_round_glyph_positions (options, CAIRO_ROUND_GLYPH_POS_ON); } -/* legacy interface kept for compatibility until surface-fallback is removed */ -static cairo_status_t -_cairo_image_surface_acquire_dest_image (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t **image_out, - cairo_rectangle_int_t *image_rect_out, - void **image_extra) -{ - cairo_image_surface_t *surface = abstract_surface; - - image_rect_out->x = 0; - image_rect_out->y = 0; - image_rect_out->width = surface->width; - image_rect_out->height = surface->height; - - *image_out = surface; - *image_extra = NULL; - - return CAIRO_STATUS_SUCCESS; -} - -static void -_cairo_image_surface_release_dest_image (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t *image, - cairo_rectangle_int_t *image_rect, - void *image_extra) -{ -} - -static cairo_status_t -_cairo_image_surface_clone_similar (void *abstract_surface, - cairo_surface_t *src, - int src_x, - int src_y, - int width, - int height, - int *clone_offset_x, - int *clone_offset_y, - cairo_surface_t **clone_out) -{ - cairo_image_surface_t *surface = abstract_surface; - - if (src->backend == surface->base.backend) { - *clone_offset_x = *clone_offset_y = 0; - *clone_out = cairo_surface_reference (src); - - return CAIRO_STATUS_SUCCESS; - } - - return CAIRO_INT_STATUS_UNSUPPORTED; -} - -static cairo_int_status_t -_cairo_image_surface_composite (cairo_operator_t op, - const cairo_pattern_t *src_pattern, - const cairo_pattern_t *mask_pattern, - void *abstract_dst, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region) -{ - cairo_image_surface_t *dst = abstract_dst; - cairo_composite_rectangles_t extents; - pixman_image_t *src; - int src_offset_x, src_offset_y; - cairo_status_t status; - - if (clip_region != NULL) { - status = _cairo_image_surface_set_clip_region (dst, clip_region); - if (unlikely (status)) - return status; - } - - extents.source.x = src_x; - extents.source.y = src_y; - extents.source.width = width; - extents.source.height = height; - - extents.mask.x = mask_x; - extents.mask.y = mask_y; - extents.mask.width = width; - extents.mask.height = height; - - extents.bounded.x = dst_x; - extents.bounded.y = dst_y; - extents.bounded.width = width; - extents.bounded.height = height; - - extents.unbounded.x = 0; - extents.unbounded.y = 0; - extents.unbounded.width = dst->width; - extents.unbounded.height = dst->height; - - if (clip_region != NULL) { - cairo_rectangle_int_t rect; - - cairo_region_get_extents (clip_region, &rect); - if (! _cairo_rectangle_intersect (&extents.unbounded, &rect)) - return CAIRO_STATUS_SUCCESS; - } - - extents.is_bounded = _cairo_operator_bounded_by_either (op); - - src = _pixman_image_for_pattern (src_pattern, FALSE, &extents.source, - &dst->base.device_transform, - &src_offset_x, &src_offset_y); - if (unlikely (src == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - status = CAIRO_STATUS_SUCCESS; - if (mask_pattern != NULL) { - pixman_image_t *mask; - int mask_offset_x, mask_offset_y; - - mask = _pixman_image_for_pattern (mask_pattern, TRUE, &extents.mask, - &dst->base.device_transform, - &mask_offset_x, &mask_offset_y); - if (unlikely (mask == NULL)) { - pixman_image_unref (src); - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - pixman_image_composite32 (_pixman_operator (op), - src, mask, dst->pixman_image, - src_x + src_offset_x, - src_y + src_offset_y, - mask_x + mask_offset_x, - mask_y + mask_offset_y, - dst_x, dst_y, width, height); - - pixman_image_unref (mask); - } else { - pixman_image_composite32 (_pixman_operator (op), - src, NULL, dst->pixman_image, - src_x + src_offset_x, - src_y + src_offset_y, - 0, 0, - dst_x, dst_y, width, height); - } - - pixman_image_unref (src); - - if (! extents.is_bounded) - status = _cairo_image_surface_fixup_unbounded (dst, &extents, NULL); - - if (clip_region != NULL) - _cairo_image_surface_unset_clip_region (dst); - - return status; -} - -static cairo_int_status_t -_cairo_image_surface_fill_rectangles (void *abstract_surface, - cairo_operator_t op, - const cairo_color_t *color, - cairo_rectangle_int_t *rects, - int num_rects) -{ - cairo_image_surface_t *surface = abstract_surface; - - pixman_color_t pixman_color; - pixman_box32_t stack_boxes[CAIRO_STACK_ARRAY_LENGTH (pixman_box32_t)]; - pixman_box32_t *pixman_boxes = stack_boxes; - int i; - - cairo_int_status_t status; - - if (CAIRO_INJECT_FAULT ()) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - pixman_color.red = color->red_short; - pixman_color.green = color->green_short; - pixman_color.blue = color->blue_short; - pixman_color.alpha = color->alpha_short; - - if (num_rects > ARRAY_LENGTH (stack_boxes)) { - pixman_boxes = _cairo_malloc_ab (num_rects, sizeof (pixman_box32_t)); - if (unlikely (pixman_boxes == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - for (i = 0; i < num_rects; i++) { - pixman_boxes[i].x1 = rects[i].x; - pixman_boxes[i].y1 = rects[i].y; - pixman_boxes[i].x2 = rects[i].x + rects[i].width; - pixman_boxes[i].y2 = rects[i].y + rects[i].height; - } - - status = CAIRO_STATUS_SUCCESS; - if (! pixman_image_fill_boxes (_pixman_operator (op), - surface->pixman_image, - &pixman_color, - num_rects, - pixman_boxes)) - { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - if (pixman_boxes != stack_boxes) - free (pixman_boxes); - - return status; -} - -static cairo_int_status_t -_cairo_image_surface_composite_trapezoids (cairo_operator_t op, - const cairo_pattern_t *pattern, - void *abstract_dst, - cairo_antialias_t antialias, - int src_x, - int src_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_trapezoid_t *traps, - int num_traps, - cairo_region_t *clip_region) -{ - cairo_image_surface_t *dst = abstract_dst; - cairo_composite_rectangles_t extents; - cairo_pattern_union_t source_pattern; - composite_traps_info_t info; - cairo_status_t status; - - if (height == 0 || width == 0) - return CAIRO_STATUS_SUCCESS; - - if (CAIRO_INJECT_FAULT ()) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - extents.source.x = src_x; - extents.source.y = src_y; - extents.source.width = width; - extents.source.height = height; - - extents.mask.x = dst_x; - extents.mask.y = dst_y; - extents.mask.width = width; - extents.mask.height = height; - - extents.bounded.x = dst_x; - extents.bounded.y = dst_y; - extents.bounded.width = width; - extents.bounded.height = height; - - extents.unbounded.x = 0; - extents.unbounded.y = 0; - extents.unbounded.width = dst->width; - extents.unbounded.height = dst->height; - - if (clip_region != NULL) { - cairo_rectangle_int_t rect; - - cairo_region_get_extents (clip_region, &rect); - if (! _cairo_rectangle_intersect (&extents.unbounded, &rect)) - return CAIRO_STATUS_SUCCESS; - } - - extents.is_bounded = _cairo_operator_bounded_by_either (op); - - if (clip_region != NULL) { - status = _cairo_image_surface_set_clip_region (dst, clip_region); - if (unlikely (status)) - return status; - } - - _cairo_pattern_init_static_copy (&source_pattern.base, pattern); - cairo_matrix_translate (&source_pattern.base.matrix, - src_x - extents.bounded.x, - src_y - extents.bounded.y); - - info.traps = traps; - info.num_traps = num_traps; - info.antialias = antialias; - status = _composite_traps (&info, - dst->pixman_image, - dst->pixman_format, - op, - &source_pattern.base, - 0, 0, - &dst->base.device_transform, - &extents); - - if (status == CAIRO_STATUS_SUCCESS && ! extents.is_bounded) - status = _cairo_image_surface_fixup_unbounded (dst, &extents, NULL); - - if (clip_region != NULL) - _cairo_image_surface_unset_clip_region (dst); - - return status; -} - -typedef struct _legacy_image_surface_span_renderer { - cairo_span_renderer_t base; - - cairo_operator_t op; - const cairo_pattern_t *pattern; - cairo_antialias_t antialias; - cairo_region_t *clip_region; - - pixman_image_t *mask; - uint8_t *mask_data; - uint32_t mask_stride; - - cairo_image_surface_t *dst; - cairo_composite_rectangles_t composite_rectangles; -} legacy_image_surface_span_renderer_t; - -void -_cairo_image_surface_span_render_row ( - int y, - const cairo_half_open_span_t *spans, - unsigned num_spans, - uint8_t *data, - uint32_t stride) -{ - uint8_t *row; - unsigned i; - - if (num_spans == 0) - return; - - row = data + y * stride; - for (i = 0; i < num_spans - 1; i++) { - if (! spans[i].coverage) - continue; - - /* We implement setting the most common single pixel wide - * span case to avoid the overhead of a memset call. - * Open coding setting longer spans didn't show a - * noticeable improvement over memset. - */ - if (spans[i+1].x == spans[i].x + 1) { - row[spans[i].x] = spans[i].coverage; - } else { - memset (row + spans[i].x, - spans[i].coverage, - spans[i+1].x - spans[i].x); - } - } -} - -static cairo_status_t -_cairo_image_surface_span_renderer_render_rows ( - void *abstract_renderer, - int y, - int height, - const cairo_half_open_span_t *spans, - unsigned num_spans) -{ - legacy_image_surface_span_renderer_t *renderer = abstract_renderer; - while (height--) - _cairo_image_surface_span_render_row (y++, spans, num_spans, renderer->mask_data, renderer->mask_stride); - return CAIRO_STATUS_SUCCESS; -} - -static void -_cairo_image_surface_span_renderer_destroy (void *abstract_renderer) -{ - legacy_image_surface_span_renderer_t *renderer = abstract_renderer; - if (renderer == NULL) - return; - - pixman_image_unref (renderer->mask); - - free (renderer); -} - -static cairo_status_t -_cairo_image_surface_span_renderer_finish (void *abstract_renderer) -{ - legacy_image_surface_span_renderer_t *renderer = abstract_renderer; - cairo_composite_rectangles_t *rects = &renderer->composite_rectangles; - cairo_image_surface_t *dst = renderer->dst; - pixman_image_t *src; - int src_x, src_y; - cairo_status_t status; - - if (renderer->clip_region != NULL) { - status = _cairo_image_surface_set_clip_region (dst, renderer->clip_region); - if (unlikely (status)) - return status; - } - - src = _pixman_image_for_pattern (renderer->pattern, FALSE, &rects->bounded, - &renderer->dst->base.device_transform, - &src_x, &src_y); - if (src == NULL) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - status = CAIRO_STATUS_SUCCESS; - pixman_image_composite32 (_pixman_operator (renderer->op), - src, - renderer->mask, - dst->pixman_image, - rects->bounded.x + src_x, - rects->bounded.y + src_y, - 0, 0, - rects->bounded.x, rects->bounded.y, - rects->bounded.width, rects->bounded.height); - - if (! rects->is_bounded) - status = _cairo_image_surface_fixup_unbounded (dst, rects, NULL); - - if (renderer->clip_region != NULL) - _cairo_image_surface_unset_clip_region (dst); - - return status; -} - -static cairo_bool_t -_cairo_image_surface_check_span_renderer (cairo_operator_t op, - const cairo_pattern_t *pattern, - void *abstract_dst, - cairo_antialias_t antialias) -{ - return TRUE; - (void) op; - (void) pattern; - (void) abstract_dst; - (void) antialias; -} - -static cairo_span_renderer_t * -_cairo_image_surface_create_span_renderer (cairo_operator_t op, - const cairo_pattern_t *pattern, - void *abstract_dst, - cairo_antialias_t antialias, - const cairo_composite_rectangles_t *rects, - cairo_region_t *clip_region) -{ - cairo_image_surface_t *dst = abstract_dst; - legacy_image_surface_span_renderer_t *renderer; - - renderer = calloc(1, sizeof(*renderer)); - if (unlikely (renderer == NULL)) - return _cairo_span_renderer_create_in_error (CAIRO_STATUS_NO_MEMORY); - - renderer->base.destroy = _cairo_image_surface_span_renderer_destroy; - renderer->base.finish = _cairo_image_surface_span_renderer_finish; - renderer->base.render_rows = _cairo_image_surface_span_renderer_render_rows; - renderer->op = op; - renderer->pattern = pattern; - renderer->antialias = antialias; - renderer->dst = dst; - renderer->clip_region = clip_region; - - renderer->composite_rectangles = *rects; - - /* TODO: support rendering to A1 surfaces (or: go add span - * compositing to pixman.) */ - renderer->mask = pixman_image_create_bits (PIXMAN_a8, - rects->bounded.width, - rects->bounded.height, - NULL, 0); - if (renderer->mask == NULL) { - free (renderer); - return _cairo_span_renderer_create_in_error (CAIRO_STATUS_NO_MEMORY); - } - - renderer->mask_stride = pixman_image_get_stride (renderer->mask); - renderer->mask_data = (uint8_t *) pixman_image_get_data (renderer->mask) - rects->bounded.x - rects->bounded.y * renderer->mask_stride; - - return &renderer->base; -} - -/** - * _cairo_surface_is_image: - * @surface: a #cairo_surface_t - * - * Checks if a surface is an #cairo_image_surface_t - * - * Return value: %TRUE if the surface is an image surface - **/ -cairo_bool_t -_cairo_surface_is_image (const cairo_surface_t *surface) -{ - return surface->backend == &_cairo_image_surface_backend; -} - const cairo_surface_backend_t _cairo_image_surface_backend = { CAIRO_SURFACE_TYPE_IMAGE, _cairo_image_surface_finish, @@ -4833,32 +950,23 @@ const cairo_surface_backend_t _cairo_image_surface_backend = { _cairo_image_surface_acquire_source_image, _cairo_image_surface_release_source_image, - _cairo_image_surface_acquire_dest_image, - _cairo_image_surface_release_dest_image, - _cairo_image_surface_clone_similar, - _cairo_image_surface_composite, - _cairo_image_surface_fill_rectangles, - _cairo_image_surface_composite_trapezoids, - _cairo_image_surface_create_span_renderer, - _cairo_image_surface_check_span_renderer, + _cairo_image_surface_snapshot, NULL, /* copy_page */ NULL, /* show_page */ + _cairo_image_surface_get_extents, - NULL, /* old_show_glyphs */ _cairo_image_surface_get_font_options, + NULL, /* flush */ NULL, /* mark dirty */ - NULL, /* font_fini */ - NULL, /* glyph_fini */ _cairo_image_surface_paint, _cairo_image_surface_mask, _cairo_image_surface_stroke, _cairo_image_surface_fill, + NULL, /* fill-stroke */ _cairo_image_surface_glyphs, - _cairo_image_surface_snapshot, - NULL, /* is_similar */ }; /* A convenience function for when one needs to coerce an image @@ -4908,7 +1016,7 @@ _cairo_image_surface_coerce_to_format (cairo_image_surface_t *surface, } cairo_image_transparency_t -_cairo_image_analyze_transparency (cairo_image_surface_t *image) +_cairo_image_analyze_transparency (cairo_image_surface_t *image) { int x, y; @@ -4918,6 +1026,9 @@ _cairo_image_analyze_transparency (cairo_image_surface_t *image) if ((image->base.content & CAIRO_CONTENT_ALPHA) == 0) return image->transparency = CAIRO_IMAGE_IS_OPAQUE; + if (image->base.is_clear) + return image->transparency = CAIRO_IMAGE_HAS_BILEVEL_ALPHA; + if ((image->base.content & CAIRO_CONTENT_COLOR) == 0) { if (image->format == CAIRO_FORMAT_A1) { return image->transparency = CAIRO_IMAGE_HAS_BILEVEL_ALPHA; diff --git a/src/cairo-mask-compositor.c b/src/cairo-mask-compositor.c new file mode 100644 index 00000000..b34ffa25 --- /dev/null +++ b/src/cairo-mask-compositor.c @@ -0,0 +1,1412 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Joonas Pihlaja <jpihlaja@cc.helsinki.fi> + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +/* This compositor renders the shape to a mask using an image surface + * then calls composite. + */ + +#include "cairoint.h" + +#include "cairo-compositor-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-pattern-private.h" +#include "cairo-region-private.h" +#include "cairo-surface-observer-private.h" +#include "cairo-surface-offset-private.h" +#include "cairo-surface-snapshot-private.h" +#include "cairo-surface-subsurface-private.h" + +typedef cairo_int_status_t +(*draw_func_t) (const cairo_mask_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + const cairo_pattern_t *src, + const cairo_rectangle_int_t *src_sample, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip); + +static void do_unaligned_row(void (*blt)(void *closure, + int16_t x, int16_t y, + int16_t w, int16_t h, + uint16_t coverage), + void *closure, + const cairo_box_t *b, + int tx, int y, int h, + uint16_t coverage) +{ + int x1 = _cairo_fixed_integer_part (b->p1.x) - tx; + int x2 = _cairo_fixed_integer_part (b->p2.x) - tx; + if (x2 > x1) { + if (! _cairo_fixed_is_integer (b->p1.x)) { + blt(closure, x1, y, 1, h, + coverage * (256 - _cairo_fixed_fractional_part (b->p1.x))); + x1++; + } + + if (x2 > x1) + blt(closure, x1, y, x2-x1, h, (coverage << 8) - (coverage >> 8)); + + if (! _cairo_fixed_is_integer (b->p2.x)) + blt(closure, x2, y, 1, h, + coverage * _cairo_fixed_fractional_part (b->p2.x)); + } else + blt(closure, x1, y, 1, h, + coverage * (b->p2.x - b->p1.x)); +} + +static void do_unaligned_box(void (*blt)(void *closure, + int16_t x, int16_t y, + int16_t w, int16_t h, + uint16_t coverage), + void *closure, + const cairo_box_t *b, int tx, int ty) +{ + int y1 = _cairo_fixed_integer_part (b->p1.y) - ty; + int y2 = _cairo_fixed_integer_part (b->p2.y) - ty; + if (y2 > y1) { + if (! _cairo_fixed_is_integer (b->p1.y)) { + do_unaligned_row(blt, closure, b, tx, y1, 1, + 256 - _cairo_fixed_fractional_part (b->p1.y)); + y1++; + } + + if (y2 > y1) + do_unaligned_row(blt, closure, b, tx, y1, y2-y1, 256); + + if (! _cairo_fixed_is_integer (b->p2.y)) + do_unaligned_row(blt, closure, b, tx, y2, 1, + _cairo_fixed_fractional_part (b->p2.y)); + } else + do_unaligned_row(blt, closure, b, tx, y1, 1, + b->p2.y - b->p1.y); +} + +struct blt_in { + const cairo_mask_compositor_t *compositor; + cairo_surface_t *dst; +}; + +static void blt_in(void *closure, + int16_t x, int16_t y, + int16_t w, int16_t h, + uint16_t coverage) +{ + struct blt_in *info = closure; + cairo_color_t color; + cairo_rectangle_int_t rect; + + if (coverage == 0xffff) + return; + + rect.x = x; + rect.y = y; + rect.width = w; + rect.height = h; + + _cairo_color_init_rgba (&color, 0, 0, 0, coverage / (double) 0xffff); + info->compositor->fill_rectangles (info->dst, CAIRO_OPERATOR_IN, + &color, &rect, 1); +} + +static cairo_surface_t * +create_composite_mask (const cairo_mask_compositor_t *compositor, + cairo_surface_t *dst, + void *draw_closure, + draw_func_t draw_func, + draw_func_t mask_func, + const cairo_composite_rectangles_t *extents) +{ + cairo_surface_t *surface; + cairo_int_status_t status; + struct blt_in info; + int i; + + surface = _cairo_surface_create_similar_solid (dst, + CAIRO_CONTENT_ALPHA, + extents->bounded.width, + extents->bounded.height, + CAIRO_COLOR_TRANSPARENT); + if (unlikely (surface->status)) + return surface; + + if (mask_func) { + status = mask_func (compositor, surface, draw_closure, + CAIRO_OPERATOR_SOURCE, NULL, NULL, + extents->bounded.x, extents->bounded.y, + &extents->bounded, extents->clip); + if (likely (status != CAIRO_INT_STATUS_UNSUPPORTED)) + return surface; + } + + /* Is it worth setting the clip region here? */ + status = draw_func (compositor, surface, draw_closure, + CAIRO_OPERATOR_ADD, NULL, NULL, + extents->bounded.x, extents->bounded.y, + &extents->bounded, NULL); + if (unlikely (status)) { + cairo_surface_destroy (surface); + return _cairo_surface_create_in_error (status); + } + + info.compositor = compositor; + info.dst = surface; + for (i = 0; i < extents->clip->num_boxes; i++) { + cairo_box_t *b = &extents->clip->boxes[i]; + + if (! _cairo_fixed_is_integer (b->p1.x) || + ! _cairo_fixed_is_integer (b->p1.y) || + ! _cairo_fixed_is_integer (b->p2.x) || + ! _cairo_fixed_is_integer (b->p2.y)) + { + do_unaligned_box(blt_in, &info, b, + extents->bounded.x, + extents->bounded.y); + } + } + + if (extents->clip->path != NULL) { + status = _cairo_clip_combine_with_surface (extents->clip, surface, + extents->bounded.x, + extents->bounded.y); + if (unlikely (status)) { + cairo_surface_destroy (surface); + return _cairo_surface_create_in_error (status); + } + } + + return surface; +} + +/* Handles compositing with a clip surface when the operator allows + * us to combine the clip with the mask + */ +static cairo_status_t +clip_and_composite_with_mask (const cairo_mask_compositor_t *compositor, + void *draw_closure, + draw_func_t draw_func, + draw_func_t mask_func, + cairo_operator_t op, + cairo_pattern_t *pattern, + const cairo_composite_rectangles_t*extents) +{ + cairo_surface_t *dst = extents->surface; + cairo_surface_t *mask, *src; + int src_x, src_y; + + mask = create_composite_mask (compositor, dst, draw_closure, + draw_func, mask_func, + extents); + if (unlikely (mask->status)) + return mask->status; + + if (pattern != NULL || dst->content != CAIRO_CONTENT_ALPHA) { + src = compositor->pattern_to_surface (dst, + &extents->source_pattern.base, + FALSE, + &extents->bounded, + &extents->source_sample_area, + &src_x, &src_y); + if (unlikely (src->status)) { + cairo_surface_destroy (mask); + return src->status; + } + + compositor->composite (dst, op, src, mask, + extents->bounded.x + src_x, + extents->bounded.y + src_y, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + + cairo_surface_destroy (src); + } else { + compositor->composite (dst, op, mask, NULL, + 0, 0, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + } + cairo_surface_destroy (mask); + + return CAIRO_STATUS_SUCCESS; +} + +/* Handles compositing with a clip surface when we have to do the operation + * in two pieces and combine them together. + */ +static cairo_status_t +clip_and_composite_combine (const cairo_mask_compositor_t *compositor, + void *draw_closure, + draw_func_t draw_func, + cairo_operator_t op, + const cairo_pattern_t *pattern, + const cairo_composite_rectangles_t*extents) +{ + cairo_surface_t *dst = extents->surface; + cairo_surface_t *tmp, *clip; + cairo_status_t status; + + tmp = _cairo_surface_create_similar_scratch (dst, dst->content, + extents->bounded.width, + extents->bounded.height); + if (unlikely (tmp->status)) + return tmp->status; + + compositor->composite (tmp, CAIRO_OPERATOR_SOURCE, dst, NULL, + extents->bounded.x, extents->bounded.y, + 0, 0, + 0, 0, + extents->bounded.width, extents->bounded.height); + + status = draw_func (compositor, tmp, draw_closure, op, + pattern, &extents->source_sample_area, + extents->bounded.x, extents->bounded.y, + &extents->bounded, NULL); + if (unlikely (status)) + goto cleanup; + + clip = _cairo_clip_get_image (extents->clip, dst, &extents->bounded); + if (unlikely ((status = clip->status))) + goto cleanup; + + if (dst->is_clear) { + compositor->composite (dst, CAIRO_OPERATOR_SOURCE, tmp, clip, + 0, 0, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + } else { + /* Punch the clip out of the destination */ + compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, clip, NULL, + 0, 0, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + + /* Now add the two results together */ + compositor->composite (dst, CAIRO_OPERATOR_ADD, tmp, clip, + 0, 0, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + } + cairo_surface_destroy (clip); + +cleanup: + cairo_surface_destroy (tmp); + return status; +} + +/* Handles compositing for %CAIRO_OPERATOR_SOURCE, which is special; it's + * defined as (src IN mask IN clip) ADD (dst OUT (mask IN clip)) + */ +static cairo_status_t +clip_and_composite_source (const cairo_mask_compositor_t *compositor, + void *draw_closure, + draw_func_t draw_func, + draw_func_t mask_func, + cairo_pattern_t *pattern, + const cairo_composite_rectangles_t *extents) +{ + cairo_surface_t *dst = extents->surface; + cairo_surface_t *mask, *src; + int src_x, src_y; + + /* Create a surface that is mask IN clip */ + mask = create_composite_mask (compositor, dst, draw_closure, + draw_func, mask_func, + extents); + if (unlikely (mask->status)) + return mask->status; + + src = compositor->pattern_to_surface (dst, + pattern, + FALSE, + &extents->bounded, + &extents->source_sample_area, + &src_x, &src_y); + if (unlikely (src->status)) { + cairo_surface_destroy (mask); + return src->status; + } + + if (dst->is_clear) { + compositor->composite (dst, CAIRO_OPERATOR_SOURCE, src, mask, + extents->bounded.x + src_x, extents->bounded.y + src_y, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + } else { + /* Compute dest' = dest OUT (mask IN clip) */ + compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL, + 0, 0, 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + + /* Now compute (src IN (mask IN clip)) ADD dest' */ + compositor->composite (dst, CAIRO_OPERATOR_ADD, src, mask, + extents->bounded.x + src_x, extents->bounded.y + src_y, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + } + + cairo_surface_destroy (src); + cairo_surface_destroy (mask); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_bool_t +can_reduce_alpha_op (cairo_operator_t op) +{ + int iop = op; + switch (iop) { + case CAIRO_OPERATOR_OVER: + case CAIRO_OPERATOR_SOURCE: + case CAIRO_OPERATOR_ADD: + return TRUE; + default: + return FALSE; + } +} + +static cairo_bool_t +reduce_alpha_op (cairo_surface_t *dst, + cairo_operator_t op, + const cairo_pattern_t *pattern) +{ + return dst->is_clear && + dst->content == CAIRO_CONTENT_ALPHA && + _cairo_pattern_is_opaque_solid (pattern) && + can_reduce_alpha_op (op); +} + +static cairo_status_t +fixup_unbounded (const cairo_mask_compositor_t *compositor, + cairo_surface_t *dst, + const cairo_composite_rectangles_t *extents) +{ + cairo_rectangle_int_t rects[4]; + int n; + + if (extents->bounded.width == extents->unbounded.width && + extents->bounded.height == extents->unbounded.height) + { + return CAIRO_STATUS_SUCCESS; + } + + n = 0; + if (extents->bounded.width == 0 || extents->bounded.height == 0) { + rects[n].x = extents->unbounded.x; + rects[n].width = extents->unbounded.width; + rects[n].y = extents->unbounded.y; + rects[n].height = extents->unbounded.height; + n++; + } else { + /* top */ + if (extents->bounded.y != extents->unbounded.y) { + rects[n].x = extents->unbounded.x; + rects[n].width = extents->unbounded.width; + rects[n].y = extents->unbounded.y; + rects[n].height = extents->bounded.y - extents->unbounded.y; + n++; + } + /* left */ + if (extents->bounded.x != extents->unbounded.x) { + rects[n].x = extents->unbounded.x; + rects[n].width = extents->bounded.x - extents->unbounded.x; + rects[n].y = extents->bounded.y; + rects[n].height = extents->bounded.height; + n++; + } + /* right */ + if (extents->bounded.x + extents->bounded.width != extents->unbounded.x + extents->unbounded.width) { + rects[n].x = extents->bounded.x + extents->bounded.width; + rects[n].width = extents->unbounded.x + extents->unbounded.width - rects[n].x; + rects[n].y = extents->bounded.y; + rects[n].height = extents->bounded.height; + n++; + } + /* bottom */ + if (extents->bounded.y + extents->bounded.height != extents->unbounded.y + extents->unbounded.height) { + rects[n].x = extents->unbounded.x; + rects[n].width = extents->unbounded.width; + rects[n].y = extents->bounded.y + extents->bounded.height; + rects[n].height = extents->unbounded.y + extents->unbounded.height - rects[n].y; + n++; + } + } + + return compositor->fill_rectangles (dst, CAIRO_OPERATOR_CLEAR, + CAIRO_COLOR_TRANSPARENT, + rects, n); +} + +static cairo_status_t +fixup_unbounded_with_mask (const cairo_mask_compositor_t *compositor, + cairo_surface_t *dst, + const cairo_composite_rectangles_t *extents) +{ + cairo_clip_t *clip = extents->clip; + cairo_surface_t *mask; + int mask_x, mask_y; + + mask = _cairo_clip_get_image (clip, dst, &extents->unbounded); + if (unlikely (mask->status)) + return mask->status; + + mask_x = -extents->unbounded.x; + mask_y = -extents->unbounded.y; + + /* top */ + if (extents->bounded.y != extents->unbounded.y) { + int x = extents->unbounded.x; + int y = extents->unbounded.y; + int width = extents->unbounded.width; + int height = extents->bounded.y - y; + + compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL, + x + mask_x, y + mask_y, + 0, 0, + x, y, + width, height); + } + + /* left */ + if (extents->bounded.x != extents->unbounded.x) { + int x = extents->unbounded.x; + int y = extents->bounded.y; + int width = extents->bounded.x - x; + int height = extents->bounded.height; + + compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL, + x + mask_x, y + mask_y, + 0, 0, + x, y, + width, height); + } + + /* right */ + if (extents->bounded.x + extents->bounded.width != extents->unbounded.x + extents->unbounded.width) { + int x = extents->bounded.x + extents->bounded.width; + int y = extents->bounded.y; + int width = extents->unbounded.x + extents->unbounded.width - x; + int height = extents->bounded.height; + + compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL, + x + mask_x, y + mask_y, + 0, 0, + x, y, + width, height); + } + + /* bottom */ + if (extents->bounded.y + extents->bounded.height != extents->unbounded.y + extents->unbounded.height) { + int x = extents->unbounded.x; + int y = extents->bounded.y + extents->bounded.height; + int width = extents->unbounded.width; + int height = extents->unbounded.y + extents->unbounded.height - y; + + compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL, + x + mask_x, y + mask_y, + 0, 0, + x, y, + width, height); + } + + cairo_surface_destroy (mask); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +fixup_unbounded_boxes (const cairo_mask_compositor_t *compositor, + const cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_surface_t *dst = extents->surface; + cairo_boxes_t clear; + cairo_region_t *clip_region; + cairo_box_t box; + cairo_status_t status; + struct _cairo_boxes_chunk *chunk; + int i; + + assert (boxes->is_pixel_aligned); + + clip_region = NULL; + if (_cairo_clip_is_region (extents->clip) && + (clip_region = _cairo_clip_get_region (extents->clip)) && + cairo_region_contains_rectangle (clip_region, + &extents->bounded) == CAIRO_REGION_OVERLAP_IN) + clip_region = NULL; + + + if (boxes->num_boxes <= 1 && clip_region == NULL) + return fixup_unbounded (compositor, dst, extents); + + _cairo_boxes_init (&clear); + + box.p1.x = _cairo_fixed_from_int (extents->unbounded.x + extents->unbounded.width); + box.p1.y = _cairo_fixed_from_int (extents->unbounded.y); + box.p2.x = _cairo_fixed_from_int (extents->unbounded.x); + box.p2.y = _cairo_fixed_from_int (extents->unbounded.y + extents->unbounded.height); + + if (clip_region == NULL) { + cairo_boxes_t tmp; + + _cairo_boxes_init (&tmp); + + status = _cairo_boxes_add (&tmp, CAIRO_ANTIALIAS_DEFAULT, &box); + assert (status == CAIRO_STATUS_SUCCESS); + + tmp.chunks.next = &boxes->chunks; + tmp.num_boxes += boxes->num_boxes; + + status = _cairo_bentley_ottmann_tessellate_boxes (&tmp, + CAIRO_FILL_RULE_WINDING, + &clear); + + tmp.chunks.next = NULL; + } else { + pixman_box32_t *pbox; + + pbox = pixman_region32_rectangles (&clip_region->rgn, &i); + _cairo_boxes_limit (&clear, (cairo_box_t *) pbox, i); + + status = _cairo_boxes_add (&clear, CAIRO_ANTIALIAS_DEFAULT, &box); + assert (status == CAIRO_STATUS_SUCCESS); + + for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + status = _cairo_boxes_add (&clear, + CAIRO_ANTIALIAS_DEFAULT, + &chunk->base[i]); + if (unlikely (status)) { + _cairo_boxes_fini (&clear); + return status; + } + } + } + + status = _cairo_bentley_ottmann_tessellate_boxes (&clear, + CAIRO_FILL_RULE_WINDING, + &clear); + } + + if (likely (status == CAIRO_STATUS_SUCCESS)) { + status = compositor->fill_boxes (dst, + CAIRO_OPERATOR_CLEAR, + CAIRO_COLOR_TRANSPARENT, + &clear); + } + + _cairo_boxes_fini (&clear); + + return status; +} + +enum { + NEED_CLIP_REGION = 0x1, + NEED_CLIP_SURFACE = 0x2, + FORCE_CLIP_REGION = 0x4, +}; + +static cairo_bool_t +need_bounded_clip (cairo_composite_rectangles_t *extents) +{ + unsigned int flags = NEED_CLIP_REGION; + if (! _cairo_clip_is_region (extents->clip)) + flags |= NEED_CLIP_SURFACE; + return flags; +} + +static cairo_bool_t +need_unbounded_clip (cairo_composite_rectangles_t *extents) +{ + unsigned int flags = 0; + if (! extents->is_bounded) { + flags |= NEED_CLIP_REGION; + if (! _cairo_clip_is_region (extents->clip)) + flags |= NEED_CLIP_SURFACE; + } + if (extents->clip->path != NULL) + flags |= NEED_CLIP_SURFACE; + return flags; +} + +static cairo_status_t +clip_and_composite (const cairo_mask_compositor_t *compositor, + draw_func_t draw_func, + draw_func_t mask_func, + void *draw_closure, + cairo_composite_rectangles_t*extents, + unsigned int need_clip) +{ + cairo_surface_t *dst = extents->surface; + cairo_operator_t op = extents->op; + cairo_pattern_t *src = &extents->source_pattern.base; + cairo_region_t *clip_region = NULL; + cairo_status_t status; + + compositor->acquire (dst); + + if (need_clip & NEED_CLIP_REGION) { + clip_region = _cairo_clip_get_region (extents->clip); + if ((need_clip & FORCE_CLIP_REGION) == 0 && + _cairo_composite_rectangles_can_reduce_clip (extents, + extents->clip)) + clip_region = NULL; + if (clip_region != NULL) { + status = compositor->set_clip_region (dst, clip_region); + if (unlikely (status)) { + compositor->release (dst); + return status; + } + } + } + + if (reduce_alpha_op (dst, op, &extents->source_pattern.base)) { + op = CAIRO_OPERATOR_ADD; + src = NULL; + } + + if (op == CAIRO_OPERATOR_SOURCE) { + status = clip_and_composite_source (compositor, + draw_closure, draw_func, mask_func, + src, extents); + } else { + if (op == CAIRO_OPERATOR_CLEAR) { + op = CAIRO_OPERATOR_DEST_OUT; + src = NULL; + } + + if (need_clip & NEED_CLIP_SURFACE) { + if (extents->is_bounded) { + status = clip_and_composite_with_mask (compositor, + draw_closure, + draw_func, + mask_func, + op, src, extents); + } else { + status = clip_and_composite_combine (compositor, + draw_closure, + draw_func, + op, src, extents); + } + } else { + status = draw_func (compositor, + dst, draw_closure, + op, src, &extents->source_sample_area, + 0, 0, + &extents->bounded, + extents->clip); + } + } + + if (status == CAIRO_STATUS_SUCCESS && ! extents->is_bounded) { + if (need_clip & NEED_CLIP_SURFACE) + status = fixup_unbounded_with_mask (compositor, dst, extents); + else + status = fixup_unbounded (compositor, dst, extents); + } + + if (clip_region) + compositor->set_clip_region (dst, NULL); + + compositor->release (dst); + + return status; +} + +static cairo_int_status_t +trim_extents_to_boxes (cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_box_t box; + + _cairo_boxes_extents (boxes, &box); + return _cairo_composite_rectangles_intersect_mask_extents (extents, &box); +} + +static cairo_status_t +upload_boxes (const cairo_mask_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_surface_t *dst = extents->surface; + const cairo_pattern_t *source = &extents->source_pattern.base; + const cairo_surface_pattern_t *pattern; + cairo_surface_t *src; + cairo_rectangle_int_t limit; + cairo_int_status_t status; + int tx, ty; + + pattern = (const cairo_surface_pattern_t *) source; + src = pattern->surface; + if (!(src->type == CAIRO_SURFACE_TYPE_IMAGE || src->type == dst->type)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + if (! _cairo_matrix_is_integer_translation (&source->matrix, &tx, &ty)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + if (_cairo_surface_is_snapshot (src)) + src = _cairo_surface_snapshot_get_target (src); + if (_cairo_surface_is_observer (src)) + src = _cairo_surface_observer_get_target (src); + if (_cairo_surface_is_subsurface (src)) { + _cairo_surface_subsurface_offset (src, &tx, &ty); + src = _cairo_surface_subsurface_get_target (src); + } + + /* Check that the data is entirely within the image */ + if (extents->bounded.x + tx < 0 || extents->bounded.y + ty < 0) + return CAIRO_INT_STATUS_UNSUPPORTED; + + _cairo_surface_get_extents (pattern->surface, &limit); + if (extents->bounded.x + extents->bounded.width + tx > limit.width || + extents->bounded.y + extents->bounded.height + ty > limit.height) + return CAIRO_INT_STATUS_UNSUPPORTED; + + if (pattern->surface->type == CAIRO_SURFACE_TYPE_IMAGE) + status = compositor->draw_image_boxes (dst, + (cairo_image_surface_t *)src, + boxes, tx, ty); + else + status = compositor->copy_boxes (dst, src, boxes, &extents->bounded, + tx, ty); + + return status; +} + +static cairo_status_t +composite_boxes (const cairo_mask_compositor_t *compositor, + const cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_surface_t *dst = extents->surface; + cairo_operator_t op = extents->op; + const cairo_pattern_t *source = &extents->source_pattern.base; + cairo_bool_t need_clip_mask = extents->clip->path != NULL; + cairo_status_t status; + + if (need_clip_mask && + (! extents->is_bounded || op == CAIRO_OPERATOR_SOURCE)) + { + return CAIRO_INT_STATUS_UNSUPPORTED; + } + + status = compositor->acquire (dst); + if (unlikely (status)) + return status; + + if (! need_clip_mask && source->type == CAIRO_PATTERN_TYPE_SOLID) { + const cairo_color_t *color; + + color = &((cairo_solid_pattern_t *) source)->color; + status = compositor->fill_boxes (dst, op, color, boxes); + } else { + cairo_surface_t *src, *mask = NULL; + int src_x, src_y; + int mask_x = 0, mask_y = 0; + + if (need_clip_mask) { + mask = _cairo_clip_get_image (extents->clip, dst, + &extents->bounded); + if (unlikely (mask->status)) + return mask->status; + + if (op == CAIRO_OPERATOR_CLEAR) { + source = NULL; + op = CAIRO_OPERATOR_DEST_OUT; + } + + mask_x = -extents->bounded.x; + mask_y = -extents->bounded.y; + } + + if (source || mask == NULL) { + src = compositor->pattern_to_surface (dst, source, FALSE, + &extents->bounded, + &extents->source_sample_area, + &src_x, &src_y); + } else { + src = mask; + src_x = mask_x; + src_y = mask_y; + mask = NULL; + } + + status = compositor->composite_boxes (dst, op, src, mask, + src_x, src_y, + mask_x, mask_y, + 0, 0, + boxes, &extents->bounded); + + cairo_surface_destroy (src); + cairo_surface_destroy (mask); + } + + if (status == CAIRO_STATUS_SUCCESS && ! extents->is_bounded) + status = fixup_unbounded_boxes (compositor, extents, boxes); + + compositor->release (dst); + + return status; +} + +static cairo_status_t +clip_and_composite_boxes (const cairo_mask_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_surface_t *dst = extents->surface; + cairo_int_status_t status; + + if (boxes->num_boxes == 0) { + if (extents->is_bounded) + return CAIRO_STATUS_SUCCESS; + + return fixup_unbounded_boxes (compositor, extents, boxes); + } + + if (! boxes->is_pixel_aligned) + return CAIRO_INT_STATUS_UNSUPPORTED; + + status = trim_extents_to_boxes (extents, boxes); + if (unlikely (status)) + return status; + + if (extents->source_pattern.base.type == CAIRO_PATTERN_TYPE_SURFACE && + extents->clip->path == NULL && + (extents->op == CAIRO_OPERATOR_SOURCE || + (dst->is_clear && (extents->op == CAIRO_OPERATOR_OVER || + extents->op == CAIRO_OPERATOR_ADD)))) + { + status = upload_boxes (compositor, extents, boxes); + if (status != CAIRO_INT_STATUS_UNSUPPORTED) + return status; + } + + return composite_boxes (compositor, extents, boxes); +} + +/* high-level compositor interface */ + +static cairo_int_status_t +_cairo_mask_compositor_paint (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents) +{ + cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor; + cairo_boxes_t boxes; + cairo_int_status_t status; + + _cairo_clip_steal_boxes (extents->clip, &boxes); + status = clip_and_composite_boxes (compositor, extents, &boxes); + _cairo_clip_unsteal_boxes (extents->clip, &boxes); + + return status; +} + +struct composite_opacity_info { + const cairo_mask_compositor_t *compositor; + uint8_t op; + cairo_surface_t *dst; + cairo_surface_t *src; + int src_x, src_y; + double opacity; +}; + +static void composite_opacity(void *closure, + int16_t x, int16_t y, + int16_t w, int16_t h, + uint16_t coverage) +{ + struct composite_opacity_info *info = closure; + const cairo_mask_compositor_t *compositor = info->compositor; + cairo_surface_t *mask; + int mask_x, mask_y; + cairo_color_t color; + cairo_solid_pattern_t solid; + + _cairo_color_init_rgba (&color, 0, 0, 0, info->opacity * coverage); + _cairo_pattern_init_solid (&solid, &color); + mask = compositor->pattern_to_surface (info->dst, &solid.base, TRUE, + &_cairo_unbounded_rectangle, + &_cairo_unbounded_rectangle, + &mask_x, &mask_y); + if (likely (mask->status == CAIRO_STATUS_SUCCESS)) { + if (info->src) { + compositor->composite (info->dst, info->op, info->src, mask, + x + info->src_x, y + info->src_y, + mask_x, mask_y, + x, y, + w, h); + } else { + compositor->composite (info->dst, info->op, mask, NULL, + mask_x, mask_y, + 0, 0, + x, y, + w, h); + } + } + + cairo_surface_destroy (mask); +} + +static cairo_int_status_t +composite_opacity_boxes (const cairo_mask_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + const cairo_pattern_t *src_pattern, + const cairo_rectangle_int_t *src_sample, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip) +{ + const cairo_solid_pattern_t *mask_pattern = closure; + struct composite_opacity_info info; + int i; + + assert (clip); + + info.compositor = compositor; + info.op = op; + info.dst = dst; + + if (src_pattern != NULL) { + info.src = compositor->pattern_to_surface (dst, src_pattern, FALSE, + extents, src_sample, + &info.src_x, &info.src_y); + if (unlikely (info.src->status)) + return info.src->status; + } else + info.src = NULL; + + info.opacity = mask_pattern->color.alpha / (double) 0xffff; + + /* XXX for lots of boxes create a clip region for the fully opaque areas */ + for (i = 0; i < clip->num_boxes; i++) + do_unaligned_box(composite_opacity, &info, + &clip->boxes[i], dst_x, dst_y); + cairo_surface_destroy (info.src); + + return CAIRO_STATUS_SUCCESS; +} + +struct composite_box_info { + const cairo_mask_compositor_t *compositor; + cairo_surface_t *dst; + cairo_surface_t *src; + int src_x, src_y; + uint8_t op; +}; + +static void composite_box(void *closure, + int16_t x, int16_t y, + int16_t w, int16_t h, + uint16_t coverage) +{ + struct composite_box_info *info = closure; + const cairo_mask_compositor_t *compositor = info->compositor; + + if (! CAIRO_ALPHA_SHORT_IS_OPAQUE (coverage)) { + cairo_surface_t *mask; + cairo_color_t color; + cairo_solid_pattern_t solid; + int mask_x, mask_y; + + _cairo_color_init_rgba (&color, 0, 0, 0, coverage / (double)0xffff); + _cairo_pattern_init_solid (&solid, &color); + + mask = compositor->pattern_to_surface (info->dst, &solid.base, FALSE, + &_cairo_unbounded_rectangle, + &_cairo_unbounded_rectangle, + &mask_x, &mask_y); + + if (likely (mask->status == CAIRO_STATUS_SUCCESS)) { + compositor->composite (info->dst, info->op, info->src, mask, + x + info->src_x, y + info->src_y, + mask_x, mask_y, + x, y, + w, h); + } + + cairo_surface_destroy (mask); + } else { + compositor->composite (info->dst, info->op, info->src, NULL, + x + info->src_x, y + info->src_y, + 0, 0, + x, y, + w, h); + } +} + +static cairo_int_status_t +composite_mask_clip_boxes (const cairo_mask_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + const cairo_pattern_t *src_pattern, + const cairo_rectangle_int_t *src_sample, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip) +{ + cairo_composite_rectangles_t *composite = closure; + struct composite_box_info info; + int i; + + assert (src_pattern == NULL); + assert (op == CAIRO_OPERATOR_SOURCE); + + info.compositor = compositor; + info.op = CAIRO_OPERATOR_SOURCE; + info.dst = dst; + info.src = compositor->pattern_to_surface (dst, + &composite->mask_pattern.base, + FALSE, extents, + &composite->mask_sample_area, + &info.src_x, &info.src_y); + if (unlikely (info.src->status)) + return info.src->status; + + info.src_x += dst_x; + info.src_y += dst_y; + + for (i = 0; i < clip->num_boxes; i++) + do_unaligned_box(composite_box, &info, &clip->boxes[i], dst_x, dst_y); + + cairo_surface_destroy (info.src); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_mask (const cairo_mask_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + const cairo_pattern_t *src_pattern, + const cairo_rectangle_int_t *src_sample, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip) +{ + cairo_composite_rectangles_t *composite = closure; + cairo_surface_t *src, *mask; + int src_x, src_y; + int mask_x, mask_y; + + if (src_pattern != NULL) { + src = compositor->pattern_to_surface (dst, src_pattern, FALSE, + extents, src_sample, + &src_x, &src_y); + if (unlikely (src->status)) + return src->status; + + mask = compositor->pattern_to_surface (dst, &composite->mask_pattern.base, TRUE, + extents, &composite->mask_sample_area, + &mask_x, &mask_y); + if (unlikely (mask->status)) { + cairo_surface_destroy (src); + return mask->status; + } + + compositor->composite (dst, op, src, mask, + extents->x + src_x, extents->y + src_y, + extents->x + mask_x, extents->y + mask_y, + extents->x - dst_x, extents->y - dst_y, + extents->width, extents->height); + + cairo_surface_destroy (mask); + cairo_surface_destroy (src); + } else { + src = compositor->pattern_to_surface (dst, &composite->mask_pattern.base, FALSE, + extents, &composite->mask_sample_area, + &src_x, &src_y); + if (unlikely (src->status)) + return src->status; + + compositor->composite (dst, op, src, NULL, + extents->x + src_x, extents->y + src_y, + 0, 0, + extents->x - dst_x, extents->y - dst_y, + extents->width, extents->height); + + cairo_surface_destroy (src); + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +_cairo_mask_compositor_mask (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents) +{ + const cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor; + cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED; + + if (extents->mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID && + extents->clip->path == NULL && + ! _cairo_clip_is_region (extents->clip)) { + status = clip_and_composite (compositor, + composite_opacity_boxes, + composite_opacity_boxes, + &extents->mask_pattern.solid, + extents, need_unbounded_clip (extents)); + } else { + status = clip_and_composite (compositor, + composite_mask, + extents->clip->path == NULL ? composite_mask_clip_boxes : NULL, + extents, + extents, need_bounded_clip (extents)); + } + + return status; +} + +static cairo_int_status_t +_cairo_mask_compositor_stroke (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + 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_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor; + cairo_surface_t *mask; + cairo_surface_pattern_t pattern; + cairo_int_status_t status; + + status = CAIRO_INT_STATUS_UNSUPPORTED; + if (_cairo_path_fixed_stroke_is_rectilinear (path)) { + cairo_boxes_t boxes; + + _cairo_boxes_init_with_clip (&boxes, extents->clip); + status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path, + style, + ctm, + antialias, + &boxes); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = clip_and_composite_boxes (compositor, extents, &boxes); + _cairo_boxes_fini (&boxes); + } + + + if (status == CAIRO_INT_STATUS_UNSUPPORTED) { + mask = cairo_surface_create_similar_image (extents->surface, + CAIRO_FORMAT_A8, + extents->bounded.width, + extents->bounded.height); + if (unlikely (mask->status)) + return mask->status; + + status = _cairo_surface_offset_stroke (mask, + extents->bounded.x, + extents->bounded.y, + CAIRO_OPERATOR_ADD, + &_cairo_pattern_white.base, + path, style, ctm, ctm_inverse, + tolerance, antialias, + extents->clip); + if (unlikely (status)) { + cairo_surface_destroy (mask); + return status; + } + + _cairo_pattern_init_for_surface (&pattern, mask); + cairo_surface_destroy (mask); + + cairo_matrix_init_translate (&pattern.base.matrix, + -extents->bounded.x, + -extents->bounded.y); + pattern.base.filter = CAIRO_FILTER_NEAREST; + pattern.base.extend = CAIRO_EXTEND_NONE; + status = _cairo_surface_mask (extents->surface, + extents->op, + &extents->source_pattern.base, + &pattern.base, + extents->clip); + _cairo_pattern_fini (&pattern.base); + } + + return status; +} + +static cairo_int_status_t +_cairo_mask_compositor_fill (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + cairo_antialias_t antialias) +{ + const cairo_mask_compositor_t *compositor = (cairo_mask_compositor_t*)_compositor; + cairo_surface_t *mask; + cairo_surface_pattern_t pattern; + cairo_int_status_t status; + + status = CAIRO_INT_STATUS_UNSUPPORTED; + if (_cairo_path_fixed_fill_is_rectilinear (path)) { + cairo_boxes_t boxes; + + _cairo_boxes_init_with_clip (&boxes, extents->clip); + status = _cairo_path_fixed_fill_rectilinear_to_boxes (path, + fill_rule, + antialias, + &boxes); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = clip_and_composite_boxes (compositor, extents, &boxes); + _cairo_boxes_fini (&boxes); + } + + if (status == CAIRO_INT_STATUS_UNSUPPORTED) { + mask = cairo_surface_create_similar_image (extents->surface, + CAIRO_FORMAT_A8, + extents->bounded.width, + extents->bounded.height); + if (unlikely (mask->status)) + return mask->status; + + status = _cairo_surface_offset_fill (mask, + extents->bounded.x, + extents->bounded.y, + CAIRO_OPERATOR_ADD, + &_cairo_pattern_white.base, + path, fill_rule, tolerance, antialias, + extents->clip); + if (unlikely (status)) { + cairo_surface_destroy (mask); + return status; + } + + _cairo_pattern_init_for_surface (&pattern, mask); + cairo_surface_destroy (mask); + + cairo_matrix_init_translate (&pattern.base.matrix, + -extents->bounded.x, + -extents->bounded.y); + pattern.base.filter = CAIRO_FILTER_NEAREST; + pattern.base.extend = CAIRO_EXTEND_NONE; + status = _cairo_surface_mask (extents->surface, + extents->op, + &extents->source_pattern.base, + &pattern.base, + extents->clip); + _cairo_pattern_fini (&pattern.base); + } + + return status; +} + +static cairo_int_status_t +_cairo_mask_compositor_glyphs (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *scaled_font, + cairo_glyph_t *glyphs, + int num_glyphs, + cairo_bool_t overlap) +{ + cairo_surface_t *mask; + cairo_surface_pattern_t pattern; + cairo_int_status_t status; + + mask = cairo_surface_create_similar_image (extents->surface, + CAIRO_FORMAT_A8, + extents->bounded.width, + extents->bounded.height); + if (unlikely (mask->status)) + return mask->status; + + status = _cairo_surface_offset_glyphs (mask, + extents->bounded.x, + extents->bounded.y, + CAIRO_OPERATOR_ADD, + &_cairo_pattern_white.base, + scaled_font, glyphs, num_glyphs, + extents->clip); + if (unlikely (status)) { + cairo_surface_destroy (mask); + return status; + } + + _cairo_pattern_init_for_surface (&pattern, mask); + cairo_surface_destroy (mask); + + cairo_matrix_init_translate (&pattern.base.matrix, + -extents->bounded.x, + -extents->bounded.y); + pattern.base.filter = CAIRO_FILTER_NEAREST; + pattern.base.extend = CAIRO_EXTEND_NONE; + status = _cairo_surface_mask (extents->surface, + extents->op, + &extents->source_pattern.base, + &pattern.base, + extents->clip); + _cairo_pattern_fini (&pattern.base); + + return status; +} + +void +_cairo_mask_compositor_init (cairo_mask_compositor_t *compositor, + const cairo_compositor_t *delegate) +{ + compositor->base.delegate = delegate; + + compositor->base.paint = _cairo_mask_compositor_paint; + compositor->base.mask = _cairo_mask_compositor_mask; + compositor->base.fill = _cairo_mask_compositor_fill; + compositor->base.stroke = _cairo_mask_compositor_stroke; + compositor->base.glyphs = _cairo_mask_compositor_glyphs; +} diff --git a/src/cairo-matrix.c b/src/cairo-matrix.c index 195438c8..25211357 100644 --- a/src/cairo-matrix.c +++ b/src/cairo-matrix.c @@ -889,6 +889,9 @@ _cairo_matrix_transformed_circle_major_axis (const cairo_matrix_t *matrix, { double a, b, c, d, f, g, h, i, j; + if (_cairo_matrix_has_unity_scale (matrix)) + return radius; + _cairo_matrix_get_affine (matrix, &a, &b, &c, &d, @@ -1043,6 +1046,9 @@ _cairo_matrix_is_pixman_translation (const cairo_matrix_t *matrix, if (!_cairo_matrix_is_translation (matrix)) return FALSE; + if (matrix->x0 == 0. && matrix->y0 == 0.) + return TRUE; + tx = matrix->x0 + *x_offset; ty = matrix->y0 + *y_offset; diff --git a/src/cairo-mesh-pattern-rasterizer.c b/src/cairo-mesh-pattern-rasterizer.c index 9c9d0ece..82b16e73 100644 --- a/src/cairo-mesh-pattern-rasterizer.c +++ b/src/cairo-mesh-pattern-rasterizer.c @@ -36,6 +36,7 @@ #include "cairoint.h" +#include "cairo-array-private.h" #include "cairo-pattern-private.h" /* diff --git a/src/cairo-mime-surface.c b/src/cairo-mime-surface.c index f23c451a..e19852f7 100644 --- a/src/cairo-mime-surface.c +++ b/src/cairo-mime-surface.c @@ -97,6 +97,7 @@ #include "cairoint.h" #include "cairo-error-private.h" #include "cairo-image-surface-private.h" +#include "cairo-surface-backend-private.h" typedef struct _cairo_mime_surface { cairo_surface_t base; @@ -221,32 +222,25 @@ static const cairo_surface_backend_t cairo_mime_surface_backend = { _cairo_mime_surface_acquire_source_image, _cairo_mime_surface_release_source_image, - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + _cairo_mime_surface_snapshot, + NULL, /* copy_page */ NULL, /* show_page */ + _cairo_mime_surface_get_extents, - NULL, /* old_show_glyphs */ NULL, /* get_font_options */ + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ + NULL, /* scaled_font_fini */ NULL, /* scaled_glyph_fini */ - NULL, /* paint */ NULL, /* mask */ NULL, /* stroke */ NULL, /* fill */ NULL, /* glyphs */ - - _cairo_mime_surface_snapshot, }; cairo_surface_t * diff --git a/src/cairo-mono-scan-converter.c b/src/cairo-mono-scan-converter.c new file mode 100644 index 00000000..98b7631f --- /dev/null +++ b/src/cairo-mono-scan-converter.c @@ -0,0 +1,607 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* + * Copyright (c) 2011 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + */ +#include "cairoint.h" +#include "cairo-spans-private.h" +#include "cairo-error-private.h" + +#include <stdlib.h> +#include <string.h> +#include <limits.h> + +struct quorem { + int32_t quo; + int32_t rem; +}; + +struct edge { + struct edge *next, *prev; + + int32_t height_left; + int32_t dir; + int32_t vertical; + + int32_t dy; + struct quorem x; + struct quorem dxdy; +}; + +/* A collection of sorted and vertically clipped edges of the polygon. + * Edges are moved from the polygon to an active list while scan + * converting. */ +struct polygon { + /* The vertical clip extents. */ + int32_t ymin, ymax; + + int num_edges; + struct edge *edges; + + /* Array of edges all starting in the same bucket. An edge is put + * into bucket EDGE_BUCKET_INDEX(edge->ytop, polygon->ymin) when + * it is added to the polygon. */ + struct edge **y_buckets; + + struct edge *y_buckets_embedded[64]; + struct edge edges_embedded[32]; +}; + +struct mono_scan_converter { + struct polygon polygon[1]; + + /* Leftmost edge on the current scan line. */ + struct edge head, tail; + int is_vertical; + + cairo_half_open_span_t *spans; + cairo_half_open_span_t spans_embedded[64]; + int num_spans; + + /* Clip box. */ + int32_t xmin, xmax; + int32_t ymin, ymax; +}; + +#define I(x) _cairo_fixed_integer_round_down(x) + +/* Compute the floored division a/b. Assumes / and % perform symmetric + * division. */ +inline static struct quorem +floored_divrem(int a, int b) +{ + struct quorem qr; + qr.quo = a/b; + qr.rem = a%b; + if ((a^b)<0 && qr.rem) { + qr.quo -= 1; + qr.rem += b; + } + return qr; +} + +/* Compute the floored division (x*a)/b. Assumes / and % perform symmetric + * division. */ +static struct quorem +floored_muldivrem(int x, int a, int b) +{ + struct quorem qr; + long long xa = (long long)x*a; + qr.quo = xa/b; + qr.rem = xa%b; + if ((xa>=0) != (b>=0) && qr.rem) { + qr.quo -= 1; + qr.rem += b; + } + return qr; +} + +static cairo_status_t +polygon_init (struct polygon *polygon, int ymin, int ymax) +{ + unsigned h = ymax - ymin; + + polygon->y_buckets = polygon->y_buckets_embedded; + if (h > ARRAY_LENGTH (polygon->y_buckets_embedded)) { + polygon->y_buckets = _cairo_malloc_ab (h, sizeof (struct edge *)); + if (unlikely (NULL == polygon->y_buckets)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + memset (polygon->y_buckets, 0, h * sizeof (struct edge *)); + + polygon->ymin = ymin; + polygon->ymax = ymax; + return CAIRO_STATUS_SUCCESS; +} + +static void +polygon_fini (struct polygon *polygon) +{ + if (polygon->y_buckets != polygon->y_buckets_embedded) + free (polygon->y_buckets); + + if (polygon->edges != polygon->edges_embedded) + free (polygon->edges); +} + +static void +_polygon_insert_edge_into_its_y_bucket(struct polygon *polygon, + struct edge *e, + int y) +{ + struct edge **ptail = &polygon->y_buckets[y - polygon->ymin]; + if (*ptail) + (*ptail)->prev = e; + e->next = *ptail; + e->prev = NULL; + *ptail = e; +} + +inline static void +polygon_add_edge (struct polygon *polygon, + const cairo_edge_t *edge) +{ + struct edge *e; + cairo_fixed_t dx; + cairo_fixed_t dy; + int y, ytop, ybot; + int ymin = polygon->ymin; + int ymax = polygon->ymax; + + y = I(edge->top); + ytop = MAX(y, ymin); + + y = I(edge->bottom); + ybot = MIN(y, ymax); + + if (ybot <= ytop) + return; + + e = polygon->edges + polygon->num_edges++; + e->height_left = ybot - ytop; + e->dir = edge->dir; + + dx = edge->line.p2.x - edge->line.p1.x; + dy = edge->line.p2.y - edge->line.p1.y; + + if (dx == 0) { + e->vertical = TRUE; + e->x.quo = edge->line.p1.x; + e->x.rem = 0; + e->dxdy.quo = 0; + e->dxdy.rem = 0; + e->dy = 0; + } else { + e->vertical = FALSE; + e->dxdy = floored_muldivrem (dx, CAIRO_FIXED_ONE, dy); + e->dy = dy; + + e->x = floored_muldivrem (ytop * CAIRO_FIXED_ONE + CAIRO_FIXED_FRAC_MASK/2 - edge->line.p1.y, + dx, dy); + e->x.quo += edge->line.p1.x; + e->x.rem -= dy; + } + + _polygon_insert_edge_into_its_y_bucket (polygon, e, ytop); +} + +static struct edge * +merge_sorted_edges (struct edge *head_a, struct edge *head_b) +{ + struct edge *head, **next, *prev; + int32_t x; + + prev = head_a->prev; + next = &head; + if (head_a->x.quo <= head_b->x.quo) { + head = head_a; + } else { + head = head_b; + head_b->prev = prev; + goto start_with_b; + } + + do { + x = head_b->x.quo; + while (head_a != NULL && head_a->x.quo <= x) { + prev = head_a; + next = &head_a->next; + head_a = head_a->next; + } + + head_b->prev = prev; + *next = head_b; + if (head_a == NULL) + return head; + +start_with_b: + x = head_a->x.quo; + while (head_b != NULL && head_b->x.quo <= x) { + prev = head_b; + next = &head_b->next; + head_b = head_b->next; + } + + head_a->prev = prev; + *next = head_a; + if (head_b == NULL) + return head; + } while (1); +} + +static struct edge * +sort_edges (struct edge *list, + unsigned int level, + struct edge **head_out) +{ + struct edge *head_other, *remaining; + unsigned int i; + + head_other = list->next; + + if (head_other == NULL) { + *head_out = list; + return NULL; + } + + remaining = head_other->next; + if (list->x.quo <= head_other->x.quo) { + *head_out = list; + head_other->next = NULL; + } else { + *head_out = head_other; + head_other->prev = list->prev; + head_other->next = list; + list->prev = head_other; + list->next = NULL; + } + + for (i = 0; i < level && remaining; i++) { + remaining = sort_edges (remaining, i, &head_other); + *head_out = merge_sorted_edges (*head_out, head_other); + } + + return remaining; +} + +static struct edge * +merge_unsorted_edges (struct edge *head, struct edge *unsorted) +{ + sort_edges (unsorted, UINT_MAX, &unsorted); + return merge_sorted_edges (head, unsorted); +} + +inline static void +active_list_merge_edges (struct mono_scan_converter *c, struct edge *edges) +{ + struct edge *e; + + for (e = edges; c->is_vertical && e; e = e->next) + c->is_vertical = e->vertical; + + c->head.next = merge_unsorted_edges (c->head.next, edges); +} + +inline static void +add_span (struct mono_scan_converter *c, int x1, int x2) +{ + int n; + + if (x1 < c->xmin) + x1 = c->xmin; + if (x2 > c->xmax) + x2 = c->xmax; + if (x2 <= x1) + return; + + n = c->num_spans++; + c->spans[n].x = x1; + c->spans[n].coverage = 255; + + n = c->num_spans++; + c->spans[n].x = x2; + c->spans[n].coverage = 0; +} + +inline static void +row (struct mono_scan_converter *c, unsigned int mask) +{ + struct edge *edge = c->head.next; + int xstart = INT_MIN, prev_x = INT_MIN; + int winding = 0; + + c->num_spans = 0; + while (&c->tail != edge) { + struct edge *next = edge->next; + int xend = I(edge->x.quo); + + if (--edge->height_left) { + edge->x.quo += edge->dxdy.quo; + edge->x.rem += edge->dxdy.rem; + if (edge->x.rem >= 0) { + ++edge->x.quo; + edge->x.rem -= edge->dy; + } + + if (edge->x.quo < prev_x) { + struct edge *pos = edge->prev; + pos->next = next; + next->prev = pos; + do { + pos = pos->prev; + } while (edge->x.quo < pos->x.quo); + pos->next->prev = edge; + edge->next = pos->next; + edge->prev = pos; + pos->next = edge; + } else + prev_x = edge->x.quo; + } else { + edge->prev->next = next; + next->prev = edge->prev; + } + + winding += edge->dir; + if ((winding & mask) == 0) { + if (I(next->x.quo) != xend) { + add_span (c, xstart, xend); + xstart = INT_MIN; + } + } else if (xstart == INT_MIN) + xstart = xend; + + edge = next; + } +} + +inline static void dec (struct edge *e, int h) +{ + e->height_left -= h; + if (e->height_left == 0) { + e->prev->next = e->next; + e->next->prev = e->prev; + } +} + +static cairo_status_t +_mono_scan_converter_init(struct mono_scan_converter *c, + int xmin, int ymin, + int xmax, int ymax) +{ + cairo_status_t status; + + status = polygon_init (c->polygon, ymin, ymax); + if (unlikely (status)) + return status; + + if (xmax - xmin > ARRAY_LENGTH(c->spans_embedded)) { + c->spans = _cairo_malloc_ab (xmax - xmin, + sizeof (cairo_half_open_span_t)); + if (unlikely (c->spans == NULL)) { + polygon_fini (c->polygon); + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + } else + c->spans = c->spans_embedded; + + c->xmin = xmin; + c->xmax = xmax; + c->ymin = ymin; + c->ymax = ymax; + + c->head.vertical = 1; + c->head.height_left = INT_MAX; + c->head.x.quo = INT_MIN; + c->head.prev = NULL; + c->head.next = &c->tail; + c->tail.prev = &c->head; + c->tail.next = NULL; + c->tail.x.quo = INT_MAX; + c->tail.height_left = INT_MAX; + c->tail.vertical = 1; + + c->is_vertical = 1; + return CAIRO_STATUS_SUCCESS; +} + +static void +_mono_scan_converter_fini(struct mono_scan_converter *self) +{ + if (self->spans != self->spans_embedded) + free (self->spans); + + polygon_fini(self->polygon); +} + +static cairo_status_t +mono_scan_converter_allocate_edges(struct mono_scan_converter *c, + int num_edges) + +{ + c->polygon->num_edges = 0; + c->polygon->edges = c->polygon->edges_embedded; + if (num_edges > ARRAY_LENGTH (c->polygon->edges_embedded)) { + c->polygon->edges = _cairo_malloc_ab (num_edges, sizeof (struct edge)); + if (unlikely (c->polygon->edges == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + return CAIRO_STATUS_SUCCESS; +} + +static void +mono_scan_converter_add_edge (struct mono_scan_converter *c, + const cairo_edge_t *edge) +{ + polygon_add_edge (c->polygon, edge); +} + +static void +step_edges (struct mono_scan_converter *c, int count) +{ + struct edge *edge; + + for (edge = c->head.next; edge != &c->tail; edge = edge->next) { + edge->height_left -= count; + if (! edge->height_left) { + edge->prev->next = edge->next; + edge->next->prev = edge->prev; + } + } +} + +static cairo_status_t +mono_scan_converter_render(struct mono_scan_converter *c, + unsigned int winding_mask, + cairo_span_renderer_t *renderer) +{ + struct polygon *polygon = c->polygon; + int i, j, h = c->ymax - c->ymin; + cairo_status_t status; + + for (i = 0; i < h; i = j) { + j = i + 1; + + if (polygon->y_buckets[i]) + active_list_merge_edges (c, polygon->y_buckets[i]); + + if (c->is_vertical) { + int min_height; + struct edge *e; + + e = c->head.next; + min_height = e->height_left; + while (e != &c->tail) { + if (e->height_left < min_height) + min_height = e->height_left; + e = e->next; + } + + while (min_height >= 2 && polygon->y_buckets[j] == NULL) + j++; + if (j != i + 1) + step_edges (c, j - (i + 1)); + } + + row (c, winding_mask); + if (c->num_spans) { + status = renderer->render_rows (renderer, c->ymin+i, j-i, + c->spans, c->num_spans); + if (unlikely (status)) + return status; + } + + /* XXX recompute after dropping edges? */ + if (c->head.next == &c->tail) + c->is_vertical = 1; + } + + return CAIRO_STATUS_SUCCESS; +} + +struct _cairo_mono_scan_converter { + cairo_scan_converter_t base; + + struct mono_scan_converter converter[1]; + cairo_fill_rule_t fill_rule; +}; + +typedef struct _cairo_mono_scan_converter cairo_mono_scan_converter_t; + +static void +_cairo_mono_scan_converter_destroy (void *converter) +{ + cairo_mono_scan_converter_t *self = converter; + _mono_scan_converter_fini (self->converter); + free(self); +} + +cairo_status_t +_cairo_mono_scan_converter_add_polygon (void *converter, + const cairo_polygon_t *polygon) +{ + cairo_mono_scan_converter_t *self = converter; + cairo_status_t status; + int i; + +#if 0 + FILE *file = fopen ("polygon.txt", "w"); + _cairo_debug_print_polygon (file, polygon); + fclose (file); +#endif + + status = mono_scan_converter_allocate_edges (self->converter, + polygon->num_edges); + if (unlikely (status)) + return status; + + for (i = 0; i < polygon->num_edges; i++) + mono_scan_converter_add_edge (self->converter, &polygon->edges[i]); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_mono_scan_converter_generate (void *converter, + cairo_span_renderer_t *renderer) +{ + cairo_mono_scan_converter_t *self = converter; + + return mono_scan_converter_render (self->converter, + self->fill_rule == CAIRO_FILL_RULE_WINDING ? ~0 : 1, + renderer); +} + +cairo_scan_converter_t * +_cairo_mono_scan_converter_create (int xmin, + int ymin, + int xmax, + int ymax, + cairo_fill_rule_t fill_rule) +{ + cairo_mono_scan_converter_t *self; + cairo_status_t status; + + self = malloc (sizeof(struct _cairo_mono_scan_converter)); + if (unlikely (self == NULL)) { + status = _cairo_error (CAIRO_STATUS_NO_MEMORY); + goto bail_nomem; + } + + self->base.destroy = _cairo_mono_scan_converter_destroy; + self->base.generate = _cairo_mono_scan_converter_generate; + + status = _mono_scan_converter_init (self->converter, + xmin, ymin, xmax, ymax); + if (unlikely (status)) + goto bail; + + self->fill_rule = fill_rule; + + return &self->base; + + bail: + self->base.destroy(&self->base); + bail_nomem: + return _cairo_scan_converter_create_in_error (status); +} diff --git a/src/cairo-no-compositor.c b/src/cairo-no-compositor.c new file mode 100644 index 00000000..1602a12f --- /dev/null +++ b/src/cairo-no-compositor.c @@ -0,0 +1,107 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Joonas Pihlaja <jpihlaja@cc.helsinki.fi> + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#include "cairoint.h" + +#include "cairo-compositor-private.h" + +static cairo_int_status_t +_cairo_no_compositor_paint (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents) +{ + ASSERT_NOT_REACHED; + return CAIRO_INT_STATUS_NOTHING_TO_DO; +} + +static cairo_int_status_t +_cairo_no_compositor_mask (const cairo_compositor_t *compositor, + cairo_composite_rectangles_t *extents) +{ + ASSERT_NOT_REACHED; + return CAIRO_INT_STATUS_NOTHING_TO_DO; +} + +static cairo_int_status_t +_cairo_no_compositor_stroke (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + 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) +{ + ASSERT_NOT_REACHED; + return CAIRO_INT_STATUS_NOTHING_TO_DO; +} + +static cairo_int_status_t +_cairo_no_compositor_fill (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + cairo_antialias_t antialias) +{ + ASSERT_NOT_REACHED; + return CAIRO_INT_STATUS_NOTHING_TO_DO; +} + +static cairo_int_status_t +_cairo_no_compositor_glyphs (const cairo_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *scaled_font, + cairo_glyph_t *glyphs, + int num_glyphs, + cairo_bool_t overlap) +{ + ASSERT_NOT_REACHED; + return CAIRO_INT_STATUS_NOTHING_TO_DO; +} + +const cairo_compositor_t __cairo_no_compositor = { + NULL, + _cairo_no_compositor_paint, + _cairo_no_compositor_mask, + _cairo_no_compositor_stroke, + _cairo_no_compositor_fill, + _cairo_no_compositor_glyphs, +}; diff --git a/src/cairo-output-stream.c b/src/cairo-output-stream.c index 0adda365..cc7e300c 100644 --- a/src/cairo-output-stream.c +++ b/src/cairo-output-stream.c @@ -37,6 +37,8 @@ #include "cairoint.h" #include "cairo-output-stream-private.h" + +#include "cairo-array-private.h" #include "cairo-error-private.h" #include "cairo-compiler-private.h" diff --git a/src/cairo-paginated-surface.c b/src/cairo-paginated-surface.c index d9c6c2f9..0418e67b 100644 --- a/src/cairo-paginated-surface.c +++ b/src/cairo-paginated-surface.c @@ -347,11 +347,10 @@ _paint_page (cairo_paginated_surface_t *surface) CAIRO_PAGINATED_MODE_ANALYZE); status = _cairo_recording_surface_replay_and_create_regions (surface->recording_surface, analysis); - if (status || analysis->status) { - if (status == CAIRO_INT_STATUS_SUCCESS) - status = analysis->status; + if (status) goto FAIL; - } + + assert (analysis->status == CAIRO_STATUS_SUCCESS); if (surface->backend->set_bounding_box) { cairo_box_t bbox; @@ -674,33 +673,23 @@ static const cairo_surface_backend_t cairo_paginated_surface_backend = { _cairo_paginated_surface_acquire_source_image, _cairo_paginated_surface_release_source_image, - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + _cairo_paginated_surface_snapshot, + _cairo_paginated_surface_copy_page, _cairo_paginated_surface_show_page, + _cairo_paginated_surface_get_extents, - NULL, /* old_show_glyphs */ _cairo_paginated_surface_get_font_options, + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ + _cairo_paginated_surface_paint, _cairo_paginated_surface_mask, _cairo_paginated_surface_stroke, _cairo_paginated_surface_fill, - NULL, /* show_glyphs */ - _cairo_paginated_surface_snapshot, - NULL, /* is_similar */ NULL, /* fill_stroke */ - NULL, /* create_solid_pattern_surface */ - NULL, /* can_repaint_solid_pattern_surface */ + NULL, /* show_glyphs */ _cairo_paginated_surface_has_show_text_glyphs, _cairo_paginated_surface_show_text_glyphs }; diff --git a/src/cairo-path-bounds.c b/src/cairo-path-bounds.c index 1fc9a06a..087a7d0e 100644 --- a/src/cairo-path-bounds.c +++ b/src/cairo-path-bounds.c @@ -40,7 +40,6 @@ #include "cairo-error-private.h" #include "cairo-path-fixed-private.h" - typedef struct _cairo_path_bounder { cairo_point_t current_point; cairo_bool_t has_extents; @@ -161,8 +160,9 @@ _cairo_path_fixed_approximate_stroke_extents (const cairo_path_fixed_t *path, cairo_box_t box_extents; double dx, dy; + _cairo_stroke_style_max_distance_from_path (style, path, ctm, &dx, &dy); + box_extents = path->extents; - _cairo_stroke_style_max_distance_from_path (style, ctm, &dx, &dy); box_extents.p1.x -= _cairo_fixed_from_double (dx); box_extents.p1.y -= _cairo_fixed_from_double (dy); box_extents.p2.x += _cairo_fixed_from_double (dx); @@ -183,23 +183,17 @@ _cairo_path_fixed_stroke_extents (const cairo_path_fixed_t *path, double tolerance, cairo_rectangle_int_t *extents) { - cairo_traps_t traps; - cairo_box_t bbox; + cairo_polygon_t polygon; cairo_status_t status; - _cairo_traps_init (&traps); - - status = _cairo_path_fixed_stroke_to_traps (path, - stroke_style, - ctm, - ctm_inverse, - tolerance, - &traps); - - _cairo_traps_extents (&traps, &bbox); - _cairo_traps_fini (&traps); - - _cairo_box_round_to_rectangle (&bbox, extents); + _cairo_polygon_init (&polygon, NULL, 0); + status = _cairo_path_fixed_stroke_to_polygon (path, + stroke_style, + ctm, ctm_inverse, + tolerance, + &polygon); + _cairo_box_round_to_rectangle (&polygon.extents, extents); + _cairo_polygon_fini (&polygon); return status; } diff --git a/src/cairo-path-fill.c b/src/cairo-path-fill.c index ce4c86a4..83393070 100644 --- a/src/cairo-path-fill.c +++ b/src/cairo-path-fill.c @@ -40,9 +40,14 @@ #include "cairo-error-private.h" #include "cairo-path-fixed-private.h" #include "cairo-region-private.h" +#include "cairo-traps-private.h" typedef struct cairo_filler { cairo_polygon_t *polygon; + double tolerance; + + cairo_box_t limit; + cairo_bool_t has_limits; cairo_point_t current_point; cairo_point_t last_move_to; @@ -86,13 +91,38 @@ _cairo_filler_move_to (void *closure, if (unlikely (status)) return status; - /* make sure that the closure represents a degenerate path */ + /* make sure that the closure represents a degenerate path */ filler->current_point = *point; filler->last_move_to = *point; return CAIRO_STATUS_SUCCESS; } +static cairo_status_t +_cairo_filler_curve_to (void *closure, + const cairo_point_t *p1, + const cairo_point_t *p2, + const cairo_point_t *p3) +{ + cairo_filler_t *filler = closure; + cairo_spline_t spline; + + if (filler->has_limits) { + if (! _cairo_spline_intersects (&filler->current_point, p1, p2, p3, + &filler->limit)) + return _cairo_filler_line_to (filler, p3); + } + + if (! _cairo_spline_init (&spline, + (cairo_spline_add_point_func_t)_cairo_filler_line_to, filler, + &filler->current_point, p1, p2, p3)) + { + return _cairo_filler_line_to (closure, p3); + } + + return _cairo_spline_decompose (&spline, filler->tolerance); +} + cairo_status_t _cairo_path_fixed_fill_to_polygon (const cairo_path_fixed_t *path, double tolerance, @@ -102,18 +132,25 @@ _cairo_path_fixed_fill_to_polygon (const cairo_path_fixed_t *path, cairo_status_t status; filler.polygon = polygon; + filler.tolerance = tolerance; + + filler.has_limits = FALSE; + if (polygon->num_limits) { + filler.has_limits = TRUE; + filler.limit = polygon->limit; + } /* make sure that the closure represents a degenerate path */ filler.current_point.x = 0; filler.current_point.y = 0; filler.last_move_to = filler.current_point; - status = _cairo_path_fixed_interpret_flat (path, - _cairo_filler_move_to, - _cairo_filler_line_to, - _cairo_filler_close, - &filler, - tolerance); + status = _cairo_path_fixed_interpret (path, + _cairo_filler_move_to, + _cairo_filler_line_to, + _cairo_filler_curve_to, + _cairo_filler_close, + &filler); if (unlikely (status)) return status; @@ -179,7 +216,7 @@ _cairo_path_fixed_fill_rectilinear_to_polygon (const cairo_path_fixed_t *path, cairo_status_t status; if (antialias != CAIRO_ANTIALIAS_NONE) - return _cairo_path_fixed_fill_to_polygon (path, 0., polygon); + return _cairo_path_fixed_fill_to_polygon (path, 0., polygon); filler.polygon = polygon; @@ -213,22 +250,12 @@ _cairo_path_fixed_fill_to_traps (const cairo_path_fixed_t *path, return CAIRO_STATUS_SUCCESS; _cairo_polygon_init (&polygon, traps->limits, traps->num_limits); - - status = _cairo_path_fixed_fill_to_polygon (path, - tolerance, - &polygon); + status = _cairo_path_fixed_fill_to_polygon (path, tolerance, &polygon); if (unlikely (status || polygon.num_edges == 0)) goto CLEANUP; - if (_cairo_path_fixed_fill_is_rectilinear (path)) { - status = _cairo_bentley_ottmann_tessellate_rectilinear_polygon (traps, - &polygon, - fill_rule); - } else { - status = _cairo_bentley_ottmann_tessellate_polygon (traps, - &polygon, - fill_rule); - } + status = _cairo_bentley_ottmann_tessellate_polygon (traps, + &polygon, fill_rule); CLEANUP: _cairo_polygon_fini (&polygon); diff --git a/src/cairo-path-fixed-private.h b/src/cairo-path-fixed-private.h index e24b1c79..9b7b4037 100644 --- a/src/cairo-path-fixed-private.h +++ b/src/cairo-path-fixed-private.h @@ -182,4 +182,8 @@ _cairo_path_fixed_fill_maybe_region (const cairo_path_fixed_t *path) path->current_point.y == path->last_move_point.y; } +cairo_private cairo_bool_t +_cairo_path_fixed_is_stroke_box (const cairo_path_fixed_t *path, + cairo_box_t *box); + #endif /* CAIRO_PATH_FIXED_PRIVATE_H */ diff --git a/src/cairo-path-fixed.c b/src/cairo-path-fixed.c index d67954f8..c257d73b 100644 --- a/src/cairo-path-fixed.c +++ b/src/cairo-path-fixed.c @@ -584,6 +584,18 @@ _cairo_path_fixed_curve_to (cairo_path_fixed_t *path, cairo_status_t status; cairo_point_t point[3]; + /* If this curves does not move, replace it with a line-to. + * This frequently happens with rounded-rectangles and r==0. + */ + if (path->current_point.x == x2 && path->current_point.y == y2) { + if (x1 == x2 && x0 == x2 && y1 == y2 && y0 == y2) + return _cairo_path_fixed_line_to (path, x2, y2); + + /* We may want to check for the absence of a cusp, in which case + * we can also replace the curve-to with a line-to. + */ + } + /* make sure subpaths are started properly */ if (! path->has_current_point) { status = _cairo_path_fixed_move_to (path, x0, y0); @@ -1270,6 +1282,51 @@ _cairo_path_fixed_is_box (const cairo_path_fixed_t *path, return FALSE; } +cairo_bool_t +_cairo_path_fixed_is_stroke_box (const cairo_path_fixed_t *path, + cairo_box_t *box) +{ + const cairo_path_buf_t *buf = cairo_path_head (path); + + if (! path->fill_is_rectilinear) + return FALSE; + + /* Do we have the right number of ops? */ + if (buf->num_ops != 5) + return FALSE; + + /* Check whether the ops are those that would be used for a rectangle */ + if (buf->op[0] != CAIRO_PATH_OP_MOVE_TO || + buf->op[1] != CAIRO_PATH_OP_LINE_TO || + buf->op[2] != CAIRO_PATH_OP_LINE_TO || + buf->op[3] != CAIRO_PATH_OP_LINE_TO || + buf->op[4] != CAIRO_PATH_OP_CLOSE_PATH) + { + return FALSE; + } + + /* Ok, we may have a box, if the points line up */ + if (buf->points[0].y == buf->points[1].y && + buf->points[1].x == buf->points[2].x && + buf->points[2].y == buf->points[3].y && + buf->points[3].x == buf->points[0].x) + { + _canonical_box (box, &buf->points[0], &buf->points[2]); + return TRUE; + } + + if (buf->points[0].x == buf->points[1].x && + buf->points[1].y == buf->points[2].y && + buf->points[2].x == buf->points[3].x && + buf->points[3].y == buf->points[0].y) + { + _canonical_box (box, &buf->points[0], &buf->points[2]); + return TRUE; + } + + return FALSE; +} + /* * Check whether the given path contains a single rectangle * that is logically equivalent to: diff --git a/src/cairo-path-stroke-boxes.c b/src/cairo-path-stroke-boxes.c index de3a628a..794250b1 100644 --- a/src/cairo-path-stroke-boxes.c +++ b/src/cairo-path-stroke-boxes.c @@ -234,29 +234,31 @@ _cairo_rectilinear_stroker_emit_segments (cairo_rectilinear_stroker_t *stroker) } /* Perform the adjustments of the endpoints. */ - if (a->y == b->y) { - if (a->x < b->x) { - if (lengthen_initial) - a->x -= half_line_width; - if (lengthen_final) - b->x += half_line_width; - } else { - if (lengthen_initial) - a->x += half_line_width; - if (lengthen_final) - b->x -= half_line_width; - } - } else { - if (a->y < b->y) { - if (lengthen_initial) - a->y -= half_line_width; - if (lengthen_final) - b->y += half_line_width; + if (lengthen_initial | lengthen_final) { + if (a->y == b->y) { + if (a->x < b->x) { + if (lengthen_initial) + a->x -= half_line_width; + if (lengthen_final) + b->x += half_line_width; + } else { + if (lengthen_initial) + a->x += half_line_width; + if (lengthen_final) + b->x -= half_line_width; + } } else { - if (lengthen_initial) - a->y += half_line_width; - if (lengthen_final) - b->y -= half_line_width; + if (a->y < b->y) { + if (lengthen_initial) + a->y -= half_line_width; + if (lengthen_final) + b->y += half_line_width; + } else { + if (lengthen_initial) + a->y += half_line_width; + if (lengthen_final) + b->y -= half_line_width; + } } } @@ -291,7 +293,6 @@ _cairo_rectilinear_stroker_emit_segments (cairo_rectilinear_stroker_t *stroker) } stroker->num_segments = 0; - return CAIRO_STATUS_SUCCESS; } @@ -606,6 +607,7 @@ _cairo_path_fixed_stroke_rectilinear_to_boxes (const cairo_path_fixed_t *path, { cairo_rectilinear_stroker_t rectilinear_stroker; cairo_int_status_t status; + cairo_box_t box; assert (_cairo_path_fixed_stroke_is_rectilinear (path)); @@ -616,6 +618,46 @@ _cairo_path_fixed_stroke_rectilinear_to_boxes (const cairo_path_fixed_t *path, return CAIRO_INT_STATUS_UNSUPPORTED; } + if (! rectilinear_stroker.dash.dashed && + _cairo_path_fixed_is_stroke_box (path, &box)) + { + cairo_box_t b; + + /* top */ + b.p1.x = box.p1.x - rectilinear_stroker.half_line_width; + b.p2.x = box.p2.x + rectilinear_stroker.half_line_width; + b.p1.y = box.p1.y - rectilinear_stroker.half_line_width; + b.p2.y = box.p1.y + rectilinear_stroker.half_line_width; + status = _cairo_boxes_add (boxes, antialias, &b); + assert (status == CAIRO_INT_STATUS_SUCCESS); + + /* left (excluding top/bottom) */ + b.p1.x = box.p1.x - rectilinear_stroker.half_line_width; + b.p2.x = box.p1.x + rectilinear_stroker.half_line_width; + b.p1.y = box.p1.y + rectilinear_stroker.half_line_width; + b.p2.y = box.p2.y - rectilinear_stroker.half_line_width; + status = _cairo_boxes_add (boxes, antialias, &b); + assert (status == CAIRO_INT_STATUS_SUCCESS); + + /* right (excluding top/bottom) */ + b.p1.x = box.p2.x - rectilinear_stroker.half_line_width; + b.p2.x = box.p2.x + rectilinear_stroker.half_line_width; + b.p1.y = box.p1.y + rectilinear_stroker.half_line_width; + b.p2.y = box.p2.y - rectilinear_stroker.half_line_width; + status = _cairo_boxes_add (boxes, antialias, &b); + assert (status == CAIRO_INT_STATUS_SUCCESS); + + /* bottom */ + b.p1.x = box.p1.x - rectilinear_stroker.half_line_width; + b.p2.x = box.p2.x + rectilinear_stroker.half_line_width; + b.p1.y = box.p2.y - rectilinear_stroker.half_line_width; + b.p2.y = box.p2.y + rectilinear_stroker.half_line_width; + status = _cairo_boxes_add (boxes, antialias, &b); + assert (status == CAIRO_INT_STATUS_SUCCESS); + + goto done; + } + if (boxes->num_limits) { _cairo_rectilinear_stroker_limit (&rectilinear_stroker, boxes->limits, @@ -647,8 +689,8 @@ _cairo_path_fixed_stroke_rectilinear_to_boxes (const cairo_path_fixed_t *path, if (unlikely (status)) goto BAIL; +done: _cairo_rectilinear_stroker_fini (&rectilinear_stroker); - return CAIRO_STATUS_SUCCESS; BAIL: diff --git a/src/cairo-path-stroke-polygon.c b/src/cairo-path-stroke-polygon.c index 3b8a67da..9128a003 100644 --- a/src/cairo-path-stroke-polygon.c +++ b/src/cairo-path-stroke-polygon.c @@ -104,6 +104,7 @@ within_tolerance (const cairo_point_t *p1, const cairo_point_t *p2, cairo_uint64_t tolerance) { + return FALSE; return _cairo_int64_lt (point_distance_sq (p1, p2), tolerance); } @@ -115,6 +116,7 @@ contour_add_point (struct stroker *stroker, if (! within_tolerance (point, _cairo_contour_last_point (&c->contour), stroker->contour_tolerance)) _cairo_contour_add_point (&c->contour, point); + //*_cairo_contour_last_point (&c->contour) = *point; } static void @@ -789,7 +791,7 @@ outer_join (struct stroker *stroker, * Make sure the miter point line lies between the two * faces by comparing the slopes */ - if (1 || slope_compare_sgn (fdx1, fdy1, mdx, mdy) != + if (slope_compare_sgn (fdx1, fdy1, mdx, mdy) != slope_compare_sgn (fdx2, fdy2, mdx, mdy)) { cairo_point_t p; @@ -1091,6 +1093,7 @@ line_to (void *closure, cairo_stroke_face_t start; cairo_point_t *p1 = &stroker->current_face.point; cairo_slope_t dev_slope; + int move_last = 0; stroker->has_initial_sub_path = TRUE; @@ -1105,15 +1108,21 @@ line_to (void *closure, compute_face (p1, &dev_slope, stroker, &start); if (stroker->has_current_face) { - int clockwise = join_is_clockwise (&stroker->current_face, &start); - /* Join with final face from previous segment */ - if (! within_tolerance (&stroker->current_face.ccw, &start.ccw, - stroker->contour_tolerance) || - ! within_tolerance (&stroker->current_face.cw, &start.cw, - stroker->contour_tolerance)) - { - outer_join (stroker, &stroker->current_face, &start, clockwise); - inner_join (stroker, &stroker->current_face, &start, clockwise); + int clockwise = _cairo_slope_compare (&stroker->current_face.dev_vector, + &start.dev_vector); + if (clockwise == 0) { + move_last = 1; + } else { + clockwise = clockwise < 0; + /* Join with final face from previous segment */ + if (! within_tolerance (&stroker->current_face.ccw, &start.ccw, + stroker->contour_tolerance) || + ! within_tolerance (&stroker->current_face.cw, &start.cw, + stroker->contour_tolerance)) + { + outer_join (stroker, &stroker->current_face, &start, clockwise); + inner_join (stroker, &stroker->current_face, &start, clockwise); + } } } else { if (! stroker->has_first_face) { @@ -1134,8 +1143,13 @@ line_to (void *closure, stroker->current_face.cw.x += dev_slope.dx; stroker->current_face.cw.y += dev_slope.dy; - contour_add_point (stroker, &stroker->cw, &stroker->current_face.cw); - contour_add_point (stroker, &stroker->ccw, &stroker->current_face.ccw); + if (move_last) { + *_cairo_contour_last_point (&stroker->cw.contour) = stroker->current_face.cw; + *_cairo_contour_last_point (&stroker->ccw.contour) = stroker->current_face.ccw; + } else { + contour_add_point (stroker, &stroker->cw, &stroker->current_face.cw); + contour_add_point (stroker, &stroker->ccw, &stroker->current_face.ccw); + } return CAIRO_STATUS_SUCCESS; } @@ -1187,6 +1201,37 @@ spline_to (void *closure, } else { compute_face (point, tangent, stroker, &face); + if (face.dev_slope.x * stroker->current_face.dev_slope.x + + face.dev_slope.y * stroker->current_face.dev_slope.y < 0) + { + const cairo_point_t *inpt, *outpt; + struct stroke_contour *outer; + int clockwise = join_is_clockwise (&stroker->current_face, &face); + + stroker->current_face.cw.x += face.point.x - stroker->current_face.point.x; + stroker->current_face.cw.y += face.point.y - stroker->current_face.point.y; + contour_add_point (stroker, &stroker->cw, &stroker->current_face.cw); + + stroker->current_face.ccw.x += face.point.x - stroker->current_face.point.x; + stroker->current_face.ccw.y += face.point.y - stroker->current_face.point.y; + contour_add_point (stroker, &stroker->ccw, &stroker->current_face.ccw); + + if (clockwise) { + inpt = &stroker->current_face.cw; + outpt = &face.cw; + outer = &stroker->cw; + } else { + inpt = &stroker->current_face.ccw; + outpt = &face.ccw; + outer = &stroker->ccw; + } + add_fan (stroker, + &stroker->current_face.dev_vector, + &face.dev_vector, + &stroker->current_face.point, inpt, outpt, + clockwise, outer); + } + contour_add_point (stroker, &stroker->cw, &face.cw); contour_add_point (stroker, &stroker->ccw, &face.ccw); } @@ -1328,6 +1373,8 @@ _cairo_path_fixed_stroke_to_polygon (const cairo_path_fixed_t *path, stroker.has_initial_sub_path = FALSE; #if DEBUG + remove ("contours.txt"); + remove ("polygons.txt"); _cairo_contour_init (&stroker.path, 0); #endif _cairo_contour_init (&stroker.cw.contour, 1); diff --git a/src/cairo-path-stroke-tristrip.c b/src/cairo-path-stroke-tristrip.c new file mode 100644 index 00000000..337d814b --- /dev/null +++ b/src/cairo-path-stroke-tristrip.c @@ -0,0 +1,1088 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#define _BSD_SOURCE /* for hypot() */ +#include "cairoint.h" + +#include "cairo-box-private.h" +#include "cairo-boxes-private.h" +#include "cairo-error-private.h" +#include "cairo-path-fixed-private.h" +#include "cairo-slope-private.h" +#include "cairo-tristrip-private.h" + +struct stroker { + cairo_stroke_style_t style; + + cairo_tristrip_t *strip; + + const cairo_matrix_t *ctm; + const cairo_matrix_t *ctm_inverse; + double tolerance; + cairo_bool_t ctm_det_positive; + + cairo_pen_t pen; + + cairo_bool_t has_sub_path; + + cairo_point_t first_point; + + cairo_bool_t has_current_face; + cairo_stroke_face_t current_face; + + cairo_bool_t has_first_face; + cairo_stroke_face_t first_face; + + cairo_box_t limit; + cairo_bool_t has_limits; +}; + +static inline double +normalize_slope (double *dx, double *dy); + +static void +compute_face (const cairo_point_t *point, + const cairo_slope_t *dev_slope, + struct stroker *stroker, + cairo_stroke_face_t *face); + +static void +translate_point (cairo_point_t *point, const cairo_point_t *offset) +{ + point->x += offset->x; + point->y += offset->y; +} + +static int +slope_compare_sgn (double dx1, double dy1, double dx2, double dy2) +{ + double c = (dx1 * dy2 - dx2 * dy1); + + if (c > 0) return 1; + if (c < 0) return -1; + return 0; +} + +static inline int +range_step (int i, int step, int max) +{ + i += step; + if (i < 0) + i = max - 1; + if (i >= max) + i = 0; + return i; +} + +/* + * Construct a fan around the midpoint using the vertices from pen between + * inpt and outpt. + */ +static void +add_fan (struct stroker *stroker, + const cairo_slope_t *in_vector, + const cairo_slope_t *out_vector, + const cairo_point_t *midpt, + const cairo_point_t *inpt, + const cairo_point_t *outpt, + cairo_bool_t clockwise) +{ + int start, stop, step, i, npoints; + + if (clockwise) { + step = 1; + + start = _cairo_pen_find_active_cw_vertex_index (&stroker->pen, + in_vector); + if (_cairo_slope_compare (&stroker->pen.vertices[start].slope_cw, + in_vector) < 0) + start = range_step (start, 1, stroker->pen.num_vertices); + + stop = _cairo_pen_find_active_cw_vertex_index (&stroker->pen, + out_vector); + if (_cairo_slope_compare (&stroker->pen.vertices[stop].slope_ccw, + out_vector) > 0) + { + stop = range_step (stop, -1, stroker->pen.num_vertices); + if (_cairo_slope_compare (&stroker->pen.vertices[stop].slope_cw, + in_vector) < 0) + return; + } + + npoints = stop - start; + } else { + step = -1; + + start = _cairo_pen_find_active_ccw_vertex_index (&stroker->pen, + in_vector); + if (_cairo_slope_compare (&stroker->pen.vertices[start].slope_ccw, + in_vector) < 0) + start = range_step (start, -1, stroker->pen.num_vertices); + + stop = _cairo_pen_find_active_ccw_vertex_index (&stroker->pen, + out_vector); + if (_cairo_slope_compare (&stroker->pen.vertices[stop].slope_cw, + out_vector) > 0) + { + stop = range_step (stop, 1, stroker->pen.num_vertices); + if (_cairo_slope_compare (&stroker->pen.vertices[stop].slope_ccw, + in_vector) < 0) + return; + } + + npoints = start - stop; + } + stop = range_step (stop, step, stroker->pen.num_vertices); + if (npoints < 0) + npoints += stroker->pen.num_vertices; + if (npoints <= 1) + return; + + for (i = start; + i != stop; + i = range_step (i, step, stroker->pen.num_vertices)) + { + cairo_point_t p = *midpt; + translate_point (&p, &stroker->pen.vertices[i].point); + //contour_add_point (stroker, c, &p); + } +} + +static int +join_is_clockwise (const cairo_stroke_face_t *in, + const cairo_stroke_face_t *out) +{ + return _cairo_slope_compare (&in->dev_vector, &out->dev_vector) < 0; +} + +static void +inner_join (struct stroker *stroker, + const cairo_stroke_face_t *in, + const cairo_stroke_face_t *out, + int clockwise) +{ + const cairo_point_t *outpt; + + if (clockwise) { + outpt = &out->ccw; + } else { + outpt = &out->cw; + } + //contour_add_point (stroker, inner, &in->point); + //contour_add_point (stroker, inner, outpt); +} + +static void +inner_close (struct stroker *stroker, + const cairo_stroke_face_t *in, + cairo_stroke_face_t *out) +{ + const cairo_point_t *inpt; + + if (join_is_clockwise (in, out)) { + inpt = &out->ccw; + } else { + inpt = &out->cw; + } + + //contour_add_point (stroker, inner, &in->point); + //contour_add_point (stroker, inner, inpt); + //*_cairo_contour_first_point (&inner->contour) = + //*_cairo_contour_last_point (&inner->contour); +} + +static void +outer_close (struct stroker *stroker, + const cairo_stroke_face_t *in, + const cairo_stroke_face_t *out) +{ + const cairo_point_t *inpt, *outpt; + int clockwise; + + if (in->cw.x == out->cw.x && in->cw.y == out->cw.y && + in->ccw.x == out->ccw.x && out->ccw.y == out->ccw.y) + { + return; + } + clockwise = join_is_clockwise (in, out); + if (clockwise) { + inpt = &in->cw; + outpt = &out->cw; + } else { + inpt = &in->ccw; + outpt = &out->ccw; + } + + switch (stroker->style.line_join) { + case CAIRO_LINE_JOIN_ROUND: + /* construct a fan around the common midpoint */ + add_fan (stroker, + &in->dev_vector, + &out->dev_vector, + &in->point, inpt, outpt, + clockwise); + break; + + case CAIRO_LINE_JOIN_MITER: + default: { + /* dot product of incoming slope vector with outgoing slope vector */ + double in_dot_out = -in->usr_vector.x * out->usr_vector.x + + -in->usr_vector.y * out->usr_vector.y; + double ml = stroker->style.miter_limit; + + /* Check the miter limit -- lines meeting at an acute angle + * can generate long miters, the limit converts them to bevel + * + * Consider the miter join formed when two line segments + * meet at an angle psi: + * + * /.\ + * /. .\ + * /./ \.\ + * /./psi\.\ + * + * We can zoom in on the right half of that to see: + * + * |\ + * | \ psi/2 + * | \ + * | \ + * | \ + * | \ + * miter \ + * length \ + * | \ + * | .\ + * | . \ + * |. line \ + * \ width \ + * \ \ + * + * + * The right triangle in that figure, (the line-width side is + * shown faintly with three '.' characters), gives us the + * following expression relating miter length, angle and line + * width: + * + * 1 /sin (psi/2) = miter_length / line_width + * + * The right-hand side of this relationship is the same ratio + * in which the miter limit (ml) is expressed. We want to know + * when the miter length is within the miter limit. That is + * when the following condition holds: + * + * 1/sin(psi/2) <= ml + * 1 <= ml sin(psi/2) + * 1 <= ml² sin²(psi/2) + * 2 <= ml² 2 sin²(psi/2) + * 2·sin²(psi/2) = 1-cos(psi) + * 2 <= ml² (1-cos(psi)) + * + * in · out = |in| |out| cos (psi) + * + * in and out are both unit vectors, so: + * + * in · out = cos (psi) + * + * 2 <= ml² (1 - in · out) + * + */ + if (2 <= ml * ml * (1 - in_dot_out)) { + double x1, y1, x2, y2; + double mx, my; + double dx1, dx2, dy1, dy2; + double ix, iy; + double fdx1, fdy1, fdx2, fdy2; + double mdx, mdy; + + /* + * we've got the points already transformed to device + * space, but need to do some computation with them and + * also need to transform the slope from user space to + * device space + */ + /* outer point of incoming line face */ + x1 = _cairo_fixed_to_double (inpt->x); + y1 = _cairo_fixed_to_double (inpt->y); + dx1 = in->usr_vector.x; + dy1 = in->usr_vector.y; + cairo_matrix_transform_distance (stroker->ctm, &dx1, &dy1); + + /* outer point of outgoing line face */ + x2 = _cairo_fixed_to_double (outpt->x); + y2 = _cairo_fixed_to_double (outpt->y); + dx2 = out->usr_vector.x; + dy2 = out->usr_vector.y; + cairo_matrix_transform_distance (stroker->ctm, &dx2, &dy2); + + /* + * Compute the location of the outer corner of the miter. + * That's pretty easy -- just the intersection of the two + * outer edges. We've got slopes and points on each + * of those edges. Compute my directly, then compute + * mx by using the edge with the larger dy; that avoids + * dividing by values close to zero. + */ + my = (((x2 - x1) * dy1 * dy2 - y2 * dx2 * dy1 + y1 * dx1 * dy2) / + (dx1 * dy2 - dx2 * dy1)); + if (fabs (dy1) >= fabs (dy2)) + mx = (my - y1) * dx1 / dy1 + x1; + else + mx = (my - y2) * dx2 / dy2 + x2; + + /* + * When the two outer edges are nearly parallel, slight + * perturbations in the position of the outer points of the lines + * caused by representing them in fixed point form can cause the + * intersection point of the miter to move a large amount. If + * that moves the miter intersection from between the two faces, + * then draw a bevel instead. + */ + + ix = _cairo_fixed_to_double (in->point.x); + iy = _cairo_fixed_to_double (in->point.y); + + /* slope of one face */ + fdx1 = x1 - ix; fdy1 = y1 - iy; + + /* slope of the other face */ + fdx2 = x2 - ix; fdy2 = y2 - iy; + + /* slope from the intersection to the miter point */ + mdx = mx - ix; mdy = my - iy; + + /* + * Make sure the miter point line lies between the two + * faces by comparing the slopes + */ + if (slope_compare_sgn (fdx1, fdy1, mdx, mdy) != + slope_compare_sgn (fdx2, fdy2, mdx, mdy)) + { + cairo_point_t p; + + p.x = _cairo_fixed_from_double (mx); + p.y = _cairo_fixed_from_double (my); + + //*_cairo_contour_last_point (&outer->contour) = p; + //*_cairo_contour_first_point (&outer->contour) = p; + return; + } + } + break; + } + + case CAIRO_LINE_JOIN_BEVEL: + break; + } + //contour_add_point (stroker, outer, outpt); +} + +static void +outer_join (struct stroker *stroker, + const cairo_stroke_face_t *in, + const cairo_stroke_face_t *out, + int clockwise) +{ + const cairo_point_t *inpt, *outpt; + + if (in->cw.x == out->cw.x && in->cw.y == out->cw.y && + in->ccw.x == out->ccw.x && out->ccw.y == out->ccw.y) + { + return; + } + if (clockwise) { + inpt = &in->cw; + outpt = &out->cw; + } else { + inpt = &in->ccw; + outpt = &out->ccw; + } + + switch (stroker->style.line_join) { + case CAIRO_LINE_JOIN_ROUND: + /* construct a fan around the common midpoint */ + add_fan (stroker, + &in->dev_vector, + &out->dev_vector, + &in->point, inpt, outpt, + clockwise); + break; + + case CAIRO_LINE_JOIN_MITER: + default: { + /* dot product of incoming slope vector with outgoing slope vector */ + double in_dot_out = -in->usr_vector.x * out->usr_vector.x + + -in->usr_vector.y * out->usr_vector.y; + double ml = stroker->style.miter_limit; + + /* Check the miter limit -- lines meeting at an acute angle + * can generate long miters, the limit converts them to bevel + * + * Consider the miter join formed when two line segments + * meet at an angle psi: + * + * /.\ + * /. .\ + * /./ \.\ + * /./psi\.\ + * + * We can zoom in on the right half of that to see: + * + * |\ + * | \ psi/2 + * | \ + * | \ + * | \ + * | \ + * miter \ + * length \ + * | \ + * | .\ + * | . \ + * |. line \ + * \ width \ + * \ \ + * + * + * The right triangle in that figure, (the line-width side is + * shown faintly with three '.' characters), gives us the + * following expression relating miter length, angle and line + * width: + * + * 1 /sin (psi/2) = miter_length / line_width + * + * The right-hand side of this relationship is the same ratio + * in which the miter limit (ml) is expressed. We want to know + * when the miter length is within the miter limit. That is + * when the following condition holds: + * + * 1/sin(psi/2) <= ml + * 1 <= ml sin(psi/2) + * 1 <= ml² sin²(psi/2) + * 2 <= ml² 2 sin²(psi/2) + * 2·sin²(psi/2) = 1-cos(psi) + * 2 <= ml² (1-cos(psi)) + * + * in · out = |in| |out| cos (psi) + * + * in and out are both unit vectors, so: + * + * in · out = cos (psi) + * + * 2 <= ml² (1 - in · out) + * + */ + if (2 <= ml * ml * (1 - in_dot_out)) { + double x1, y1, x2, y2; + double mx, my; + double dx1, dx2, dy1, dy2; + double ix, iy; + double fdx1, fdy1, fdx2, fdy2; + double mdx, mdy; + + /* + * we've got the points already transformed to device + * space, but need to do some computation with them and + * also need to transform the slope from user space to + * device space + */ + /* outer point of incoming line face */ + x1 = _cairo_fixed_to_double (inpt->x); + y1 = _cairo_fixed_to_double (inpt->y); + dx1 = in->usr_vector.x; + dy1 = in->usr_vector.y; + cairo_matrix_transform_distance (stroker->ctm, &dx1, &dy1); + + /* outer point of outgoing line face */ + x2 = _cairo_fixed_to_double (outpt->x); + y2 = _cairo_fixed_to_double (outpt->y); + dx2 = out->usr_vector.x; + dy2 = out->usr_vector.y; + cairo_matrix_transform_distance (stroker->ctm, &dx2, &dy2); + + /* + * Compute the location of the outer corner of the miter. + * That's pretty easy -- just the intersection of the two + * outer edges. We've got slopes and points on each + * of those edges. Compute my directly, then compute + * mx by using the edge with the larger dy; that avoids + * dividing by values close to zero. + */ + my = (((x2 - x1) * dy1 * dy2 - y2 * dx2 * dy1 + y1 * dx1 * dy2) / + (dx1 * dy2 - dx2 * dy1)); + if (fabs (dy1) >= fabs (dy2)) + mx = (my - y1) * dx1 / dy1 + x1; + else + mx = (my - y2) * dx2 / dy2 + x2; + + /* + * When the two outer edges are nearly parallel, slight + * perturbations in the position of the outer points of the lines + * caused by representing them in fixed point form can cause the + * intersection point of the miter to move a large amount. If + * that moves the miter intersection from between the two faces, + * then draw a bevel instead. + */ + + ix = _cairo_fixed_to_double (in->point.x); + iy = _cairo_fixed_to_double (in->point.y); + + /* slope of one face */ + fdx1 = x1 - ix; fdy1 = y1 - iy; + + /* slope of the other face */ + fdx2 = x2 - ix; fdy2 = y2 - iy; + + /* slope from the intersection to the miter point */ + mdx = mx - ix; mdy = my - iy; + + /* + * Make sure the miter point line lies between the two + * faces by comparing the slopes + */ + if (slope_compare_sgn (fdx1, fdy1, mdx, mdy) != + slope_compare_sgn (fdx2, fdy2, mdx, mdy)) + { + cairo_point_t p; + + p.x = _cairo_fixed_from_double (mx); + p.y = _cairo_fixed_from_double (my); + + //*_cairo_contour_last_point (&outer->contour) = p; + return; + } + } + break; + } + + case CAIRO_LINE_JOIN_BEVEL: + break; + } + //contour_add_point (stroker,outer, outpt); +} + +static void +add_cap (struct stroker *stroker, + const cairo_stroke_face_t *f) +{ + switch (stroker->style.line_cap) { + case CAIRO_LINE_CAP_ROUND: { + cairo_slope_t slope; + + slope.dx = -f->dev_vector.dx; + slope.dy = -f->dev_vector.dy; + + add_fan (stroker, &f->dev_vector, &slope, + &f->point, &f->ccw, &f->cw, + FALSE); + break; + } + + case CAIRO_LINE_CAP_SQUARE: { + double dx, dy; + cairo_slope_t fvector; + cairo_point_t quad[4]; + + dx = f->usr_vector.x; + dy = f->usr_vector.y; + dx *= stroker->style.line_width / 2.0; + dy *= stroker->style.line_width / 2.0; + cairo_matrix_transform_distance (stroker->ctm, &dx, &dy); + fvector.dx = _cairo_fixed_from_double (dx); + fvector.dy = _cairo_fixed_from_double (dy); + + quad[0] = f->ccw; + quad[1].x = f->ccw.x + fvector.dx; + quad[1].y = f->ccw.y + fvector.dy; + quad[2].x = f->cw.x + fvector.dx; + quad[2].y = f->cw.y + fvector.dy; + quad[3] = f->cw; + + //contour_add_point (stroker, c, &quad[1]); + //contour_add_point (stroker, c, &quad[2]); + } + + case CAIRO_LINE_CAP_BUTT: + default: + break; + } + //contour_add_point (stroker, c, &f->cw); +} + +static void +add_leading_cap (struct stroker *stroker, + const cairo_stroke_face_t *face) +{ + cairo_stroke_face_t reversed; + cairo_point_t t; + + reversed = *face; + + /* The initial cap needs an outward facing vector. Reverse everything */ + reversed.usr_vector.x = -reversed.usr_vector.x; + reversed.usr_vector.y = -reversed.usr_vector.y; + reversed.dev_vector.dx = -reversed.dev_vector.dx; + reversed.dev_vector.dy = -reversed.dev_vector.dy; + + t = reversed.cw; + reversed.cw = reversed.ccw; + reversed.ccw = t; + + add_cap (stroker, &reversed); +} + +static void +add_trailing_cap (struct stroker *stroker, + const cairo_stroke_face_t *face) +{ + add_cap (stroker, face); +} + +static inline double +normalize_slope (double *dx, double *dy) +{ + double dx0 = *dx, dy0 = *dy; + double mag; + + assert (dx0 != 0.0 || dy0 != 0.0); + + if (dx0 == 0.0) { + *dx = 0.0; + if (dy0 > 0.0) { + mag = dy0; + *dy = 1.0; + } else { + mag = -dy0; + *dy = -1.0; + } + } else if (dy0 == 0.0) { + *dy = 0.0; + if (dx0 > 0.0) { + mag = dx0; + *dx = 1.0; + } else { + mag = -dx0; + *dx = -1.0; + } + } else { + mag = hypot (dx0, dy0); + *dx = dx0 / mag; + *dy = dy0 / mag; + } + + return mag; +} + +static void +compute_face (const cairo_point_t *point, + const cairo_slope_t *dev_slope, + struct stroker *stroker, + cairo_stroke_face_t *face) +{ + double face_dx, face_dy; + cairo_point_t offset_ccw, offset_cw; + double slope_dx, slope_dy; + + slope_dx = _cairo_fixed_to_double (dev_slope->dx); + slope_dy = _cairo_fixed_to_double (dev_slope->dy); + face->length = normalize_slope (&slope_dx, &slope_dy); + face->dev_slope.x = slope_dx; + face->dev_slope.y = slope_dy; + + /* + * rotate to get a line_width/2 vector along the face, note that + * the vector must be rotated the right direction in device space, + * but by 90° in user space. So, the rotation depends on + * whether the ctm reflects or not, and that can be determined + * by looking at the determinant of the matrix. + */ + if (! _cairo_matrix_is_identity (stroker->ctm_inverse)) { + /* Normalize the matrix! */ + cairo_matrix_transform_distance (stroker->ctm_inverse, + &slope_dx, &slope_dy); + normalize_slope (&slope_dx, &slope_dy); + + if (stroker->ctm_det_positive) { + face_dx = - slope_dy * (stroker->style.line_width / 2.0); + face_dy = slope_dx * (stroker->style.line_width / 2.0); + } else { + face_dx = slope_dy * (stroker->style.line_width / 2.0); + face_dy = - slope_dx * (stroker->style.line_width / 2.0); + } + + /* back to device space */ + cairo_matrix_transform_distance (stroker->ctm, &face_dx, &face_dy); + } else { + face_dx = - slope_dy * (stroker->style.line_width / 2.0); + face_dy = slope_dx * (stroker->style.line_width / 2.0); + } + + offset_ccw.x = _cairo_fixed_from_double (face_dx); + offset_ccw.y = _cairo_fixed_from_double (face_dy); + offset_cw.x = -offset_ccw.x; + offset_cw.y = -offset_ccw.y; + + face->ccw = *point; + translate_point (&face->ccw, &offset_ccw); + + face->point = *point; + + face->cw = *point; + translate_point (&face->cw, &offset_cw); + + face->usr_vector.x = slope_dx; + face->usr_vector.y = slope_dy; + + face->dev_vector = *dev_slope; +} + +static void +add_caps (struct stroker *stroker) +{ + /* check for a degenerative sub_path */ + if (stroker->has_sub_path && + ! stroker->has_first_face && + ! stroker->has_current_face && + stroker->style.line_cap == CAIRO_LINE_CAP_ROUND) + { + /* pick an arbitrary slope to use */ + cairo_slope_t slope = { CAIRO_FIXED_ONE, 0 }; + cairo_stroke_face_t face; + + /* arbitrarily choose first_point */ + compute_face (&stroker->first_point, &slope, stroker, &face); + + add_leading_cap (stroker, &face); + add_trailing_cap (stroker, &face); + + /* ensure the circle is complete */ + //_cairo_contour_add_point (&stroker->ccw.contour, + //_cairo_contour_first_point (&stroker->ccw.contour)); + } else { + if (stroker->has_current_face) + add_trailing_cap (stroker, &stroker->current_face); + + //_cairo_polygon_add_contour (stroker->polygon, &stroker->ccw.contour); + //_cairo_contour_reset (&stroker->ccw.contour); + + if (stroker->has_first_face) { + //_cairo_contour_add_point (&stroker->ccw.contour, + //&stroker->first_face.cw); + add_leading_cap (stroker, &stroker->first_face); + //_cairo_polygon_add_contour (stroker->polygon, + //&stroker->ccw.contour); + //_cairo_contour_reset (&stroker->ccw.contour); + } + } +} + +static cairo_status_t +move_to (void *closure, + const cairo_point_t *point) +{ + struct stroker *stroker = closure; + + /* Cap the start and end of the previous sub path as needed */ + add_caps (stroker); + + stroker->has_first_face = FALSE; + stroker->has_current_face = FALSE; + stroker->has_sub_path = FALSE; + + stroker->first_point = *point; + + stroker->current_face.point = *point; + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +line_to (void *closure, + const cairo_point_t *point) +{ + struct stroker *stroker = closure; + cairo_stroke_face_t start; + cairo_point_t *p1 = &stroker->current_face.point; + cairo_slope_t dev_slope; + + stroker->has_sub_path = TRUE; + + if (p1->x == point->x && p1->y == point->y) + return CAIRO_STATUS_SUCCESS; + + _cairo_slope_init (&dev_slope, p1, point); + compute_face (p1, &dev_slope, stroker, &start); + + if (stroker->has_current_face) { + int clockwise = join_is_clockwise (&stroker->current_face, &start); + /* Join with final face from previous segment */ + outer_join (stroker, &stroker->current_face, &start, clockwise); + inner_join (stroker, &stroker->current_face, &start, clockwise); + } else { + if (! stroker->has_first_face) { + /* Save sub path's first face in case needed for closing join */ + stroker->first_face = start; + _cairo_tristrip_move_to (stroker->strip, &start.cw); + stroker->has_first_face = TRUE; + } + stroker->has_current_face = TRUE; + + _cairo_tristrip_add_point (stroker->strip, &start.cw); + _cairo_tristrip_add_point (stroker->strip, &start.ccw); + } + + stroker->current_face = start; + stroker->current_face.point = *point; + stroker->current_face.ccw.x += dev_slope.dx; + stroker->current_face.ccw.y += dev_slope.dy; + stroker->current_face.cw.x += dev_slope.dx; + stroker->current_face.cw.y += dev_slope.dy; + + _cairo_tristrip_add_point (stroker->strip, &stroker->current_face.cw); + _cairo_tristrip_add_point (stroker->strip, &stroker->current_face.ccw); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +spline_to (void *closure, + const cairo_point_t *point, + const cairo_slope_t *tangent) +{ + struct stroker *stroker = closure; + cairo_stroke_face_t face; + + if (tangent->dx == 0 && tangent->dy == 0) { + const cairo_point_t *inpt, *outpt; + cairo_point_t t; + int clockwise; + + face = stroker->current_face; + + face.usr_vector.x = -face.usr_vector.x; + face.usr_vector.y = -face.usr_vector.y; + face.dev_vector.dx = -face.dev_vector.dx; + face.dev_vector.dy = -face.dev_vector.dy; + + t = face.cw; + face.cw = face.ccw; + face.ccw = t; + + clockwise = join_is_clockwise (&stroker->current_face, &face); + if (clockwise) { + inpt = &stroker->current_face.cw; + outpt = &face.cw; + } else { + inpt = &stroker->current_face.ccw; + outpt = &face.ccw; + } + + add_fan (stroker, + &stroker->current_face.dev_vector, + &face.dev_vector, + &stroker->current_face.point, inpt, outpt, + clockwise); + } else { + compute_face (point, tangent, stroker, &face); + + if (face.dev_slope.x * stroker->current_face.dev_slope.x + + face.dev_slope.y * stroker->current_face.dev_slope.y < 0) + { + const cairo_point_t *inpt, *outpt; + int clockwise = join_is_clockwise (&stroker->current_face, &face); + + stroker->current_face.cw.x += face.point.x - stroker->current_face.point.x; + stroker->current_face.cw.y += face.point.y - stroker->current_face.point.y; + //contour_add_point (stroker, &stroker->cw, &stroker->current_face.cw); + + stroker->current_face.ccw.x += face.point.x - stroker->current_face.point.x; + stroker->current_face.ccw.y += face.point.y - stroker->current_face.point.y; + //contour_add_point (stroker, &stroker->ccw, &stroker->current_face.ccw); + + if (clockwise) { + inpt = &stroker->current_face.cw; + outpt = &face.cw; + } else { + inpt = &stroker->current_face.ccw; + outpt = &face.ccw; + } + add_fan (stroker, + &stroker->current_face.dev_vector, + &face.dev_vector, + &stroker->current_face.point, inpt, outpt, + clockwise); + } + + _cairo_tristrip_add_point (stroker->strip, &face.cw); + _cairo_tristrip_add_point (stroker->strip, &face.ccw); + } + + stroker->current_face = face; + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +curve_to (void *closure, + const cairo_point_t *b, + const cairo_point_t *c, + const cairo_point_t *d) +{ + struct stroker *stroker = closure; + cairo_spline_t spline; + cairo_stroke_face_t face; + + if (stroker->has_limits) { + if (! _cairo_spline_intersects (&stroker->current_face.point, b, c, d, + &stroker->limit)) + return line_to (closure, d); + } + + if (! _cairo_spline_init (&spline, spline_to, stroker, + &stroker->current_face.point, b, c, d)) + return line_to (closure, d); + + compute_face (&stroker->current_face.point, &spline.initial_slope, + stroker, &face); + + if (stroker->has_current_face) { + int clockwise = join_is_clockwise (&stroker->current_face, &face); + /* Join with final face from previous segment */ + outer_join (stroker, &stroker->current_face, &face, clockwise); + inner_join (stroker, &stroker->current_face, &face, clockwise); + } else { + if (! stroker->has_first_face) { + /* Save sub path's first face in case needed for closing join */ + stroker->first_face = face; + _cairo_tristrip_move_to (stroker->strip, &face.cw); + stroker->has_first_face = TRUE; + } + stroker->has_current_face = TRUE; + + _cairo_tristrip_add_point (stroker->strip, &face.cw); + _cairo_tristrip_add_point (stroker->strip, &face.ccw); + } + stroker->current_face = face; + + return _cairo_spline_decompose (&spline, stroker->tolerance); +} + +static cairo_status_t +close_path (void *closure) +{ + struct stroker *stroker = closure; + cairo_status_t status; + + status = line_to (stroker, &stroker->first_point); + if (unlikely (status)) + return status; + + if (stroker->has_first_face && stroker->has_current_face) { + /* Join first and final faces of sub path */ + outer_close (stroker, &stroker->current_face, &stroker->first_face); + inner_close (stroker, &stroker->current_face, &stroker->first_face); + } else { + /* Cap the start and end of the sub path as needed */ + add_caps (stroker); + } + + stroker->has_sub_path = FALSE; + stroker->has_first_face = FALSE; + stroker->has_current_face = FALSE; + + return CAIRO_STATUS_SUCCESS; +} + +cairo_int_status_t +_cairo_path_fixed_stroke_to_tristrip (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_tristrip_t *strip) +{ + struct stroker stroker; + cairo_int_status_t status; + int i; + + if (style->num_dashes) + return CAIRO_INT_STATUS_UNSUPPORTED; + + stroker.style = *style; + stroker.ctm = ctm; + stroker.ctm_inverse = ctm_inverse; + stroker.tolerance = tolerance; + + stroker.ctm_det_positive = + _cairo_matrix_compute_determinant (ctm) >= 0.0; + + status = _cairo_pen_init (&stroker.pen, + style->line_width / 2.0, + tolerance, ctm); + if (unlikely (status)) + return status; + + if (stroker.pen.num_vertices <= 1) + return CAIRO_INT_STATUS_NOTHING_TO_DO; + + stroker.has_current_face = FALSE; + stroker.has_first_face = FALSE; + stroker.has_sub_path = FALSE; + + stroker.has_limits = strip->num_limits > 0; + stroker.limit = strip->limits[0]; + for (i = 1; i < strip->num_limits; i++) + _cairo_box_add_box (&stroker.limit, &strip->limits[i]); + + stroker.strip = strip; + + status = _cairo_path_fixed_interpret (path, + move_to, + line_to, + curve_to, + close_path, + &stroker); + /* Cap the start and end of the final sub path as needed */ + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + add_caps (&stroker); + + _cairo_pen_fini (&stroker.pen); + + return status; +} diff --git a/src/cairo-path-stroke.c b/src/cairo-path-stroke.c index c4382912..f25cfe4f 100644 --- a/src/cairo-path-stroke.c +++ b/src/cairo-path-stroke.c @@ -45,6 +45,7 @@ #include "cairo-path-fixed-private.h" #include "cairo-slope-private.h" #include "cairo-stroke-dash-private.h" +#include "cairo-traps-private.h" typedef struct cairo_stroker { cairo_stroke_style_t style; @@ -125,6 +126,7 @@ _cairo_stroker_init (cairo_stroker_t *stroker, static void _cairo_stroker_limit (cairo_stroker_t *stroker, + const cairo_path_fixed_t *path, const cairo_box_t *boxes, int num_boxes) { @@ -139,8 +141,8 @@ _cairo_stroker_limit (cairo_stroker_t *stroker, * of the bounds but which might generate rendering that's within bounds. */ - _cairo_stroke_style_max_distance_from_path (&stroker->style, stroker->ctm, - &dx, &dy); + _cairo_stroke_style_max_distance_from_path (&stroker->style, path, + stroker->ctm, &dx, &dy); fdx = _cairo_fixed_from_double (dx); fdy = _cairo_fixed_from_double (dy); @@ -1293,7 +1295,8 @@ _cairo_path_fixed_stroke_dashed_to_polygon (const cairo_path_fixed_t *path, stroker.closure = polygon; if (polygon->num_limits) - _cairo_stroker_limit (&stroker, polygon->limits, polygon->num_limits); + _cairo_stroker_limit (&stroker, path, + polygon->limits, polygon->num_limits); status = _cairo_path_fixed_interpret (path, _cairo_stroker_move_to, @@ -1328,7 +1331,6 @@ _cairo_path_fixed_stroke_to_traps (const cairo_path_fixed_t *path, cairo_polygon_t polygon; _cairo_polygon_init (&polygon, traps->limits, traps->num_limits); - status = _cairo_path_fixed_stroke_to_polygon (path, stroke_style, ctm, diff --git a/src/cairo-pattern-private.h b/src/cairo-pattern-private.h index 46a8ad6e..8be319e1 100644 --- a/src/cairo-pattern-private.h +++ b/src/cairo-pattern-private.h @@ -40,6 +40,8 @@ #include "cairo-types-private.h" #include "cairo-list-private.h" +#include <stdio.h> /* FILE* */ + CAIRO_BEGIN_DECLS typedef struct _cairo_pattern_observer cairo_pattern_observer_t; @@ -59,19 +61,19 @@ struct _cairo_pattern_observer { }; struct _cairo_pattern { - cairo_pattern_type_t type; cairo_reference_count_t ref_count; cairo_status_t status; cairo_user_data_array_t user_data; + cairo_list_t observers; + + cairo_pattern_type_t type; - cairo_matrix_t matrix; cairo_filter_t filter; cairo_extend_t extend; - double opacity; - cairo_bool_t has_component_alpha; - cairo_list_t observers; + cairo_matrix_t matrix; + double opacity; }; struct _cairo_solid_pattern { @@ -265,46 +267,19 @@ _cairo_mesh_pattern_coord_box (const cairo_mesh_pattern_t *mesh, double *out_xmax, double *out_ymax); -enum { - CAIRO_PATTERN_ACQUIRE_NONE = 0x0, - CAIRO_PATTERN_ACQUIRE_NO_REFLECT = 0x1, -}; -cairo_private cairo_int_status_t -_cairo_pattern_acquire_surface (const cairo_pattern_t *pattern, - cairo_surface_t *dst, - int x, - int y, - unsigned int width, - unsigned int height, - unsigned int flags, - cairo_surface_t **surface_out, - cairo_surface_attributes_t *attributes); - -cairo_private void -_cairo_pattern_release_surface (const cairo_pattern_t *pattern, - cairo_surface_t *surface, - cairo_surface_attributes_t *attributes); - -cairo_private cairo_int_status_t -_cairo_pattern_acquire_surfaces (const cairo_pattern_t *src, - const cairo_pattern_t *mask, - cairo_surface_t *dst, - int src_x, - int src_y, - int mask_x, - int mask_y, - unsigned int width, - unsigned int height, - unsigned int flags, - cairo_surface_t **src_out, - cairo_surface_t **mask_out, - cairo_surface_attributes_t *src_attributes, - cairo_surface_attributes_t *mask_attributes); +cairo_private_no_warn cairo_filter_t +_cairo_pattern_sampled_area (const cairo_pattern_t *pattern, + const cairo_rectangle_int_t *extents, + cairo_rectangle_int_t *sample); cairo_private void _cairo_pattern_get_extents (const cairo_pattern_t *pattern, cairo_rectangle_int_t *extents); +cairo_private cairo_int_status_t +_cairo_pattern_get_ink_extents (const cairo_pattern_t *pattern, + cairo_rectangle_int_t *extents); + cairo_private unsigned long _cairo_pattern_hash (const cairo_pattern_t *pattern); @@ -353,7 +328,8 @@ _cairo_mesh_pattern_rasterize (const cairo_mesh_pattern_t *mesh, double x_offset, double y_offset); - +cairo_private void +_cairo_debug_print_pattern (FILE *file, const cairo_pattern_t *pattern); CAIRO_END_DECLS diff --git a/src/cairo-pattern.c b/src/cairo-pattern.c index 19aa9783..f91de265 100644 --- a/src/cairo-pattern.c +++ b/src/cairo-pattern.c @@ -29,11 +29,14 @@ */ #include "cairoint.h" + +#include "cairo-array-private.h" #include "cairo-error-private.h" #include "cairo-freed-pool-private.h" +#include "cairo-image-surface-private.h" #include "cairo-path-private.h" #include "cairo-pattern-private.h" -#include "cairo-image-surface-private.h" +#include "cairo-recording-surface-private.h" #include <float.h> @@ -61,55 +64,85 @@ static freed_pool_t freed_pattern_pool[5]; static const cairo_solid_pattern_t _cairo_pattern_nil = { - { CAIRO_PATTERN_TYPE_SOLID, /* type */ + { CAIRO_REFERENCE_COUNT_INVALID, /* ref_count */ CAIRO_STATUS_NO_MEMORY, /* status */ { 0, 0, 0, NULL }, /* user_data */ - { 1., 0., 0., 1., 0., 0., }, /* matrix */ + { NULL, NULL }, /* observers */ + + CAIRO_PATTERN_TYPE_SOLID, /* type */ CAIRO_FILTER_DEFAULT, /* filter */ - CAIRO_EXTEND_GRADIENT_DEFAULT }, /* extend */ + CAIRO_EXTEND_GRADIENT_DEFAULT, /* extend */ + FALSE, /* has component alpha */ + { 1., 0., 0., 1., 0., 0., }, /* matrix */ + 1.0 /* opacity */ + } }; static const cairo_solid_pattern_t _cairo_pattern_nil_null_pointer = { - { CAIRO_PATTERN_TYPE_SOLID, /* type */ + { CAIRO_REFERENCE_COUNT_INVALID, /* ref_count */ CAIRO_STATUS_NULL_POINTER, /* status */ { 0, 0, 0, NULL }, /* user_data */ - { 1., 0., 0., 1., 0., 0., }, /* matrix */ + { NULL, NULL }, /* observers */ + + CAIRO_PATTERN_TYPE_SOLID, /* type */ CAIRO_FILTER_DEFAULT, /* filter */ - CAIRO_EXTEND_GRADIENT_DEFAULT }, /* extend */ + CAIRO_EXTEND_GRADIENT_DEFAULT, /* extend */ + FALSE, /* has component alpha */ + { 1., 0., 0., 1., 0., 0., }, /* matrix */ + 1.0 /* opacity */ + } }; const cairo_solid_pattern_t _cairo_pattern_black = { - { CAIRO_PATTERN_TYPE_SOLID, /* type */ + { CAIRO_REFERENCE_COUNT_INVALID, /* ref_count */ CAIRO_STATUS_SUCCESS, /* status */ { 0, 0, 0, NULL }, /* user_data */ + { NULL, NULL }, /* observers */ + + CAIRO_PATTERN_TYPE_SOLID, /* type */ + CAIRO_FILTER_NEAREST, /* filter */ + CAIRO_EXTEND_REPEAT, /* extend */ + FALSE, /* has component alpha */ { 1., 0., 0., 1., 0., 0., }, /* matrix */ - CAIRO_FILTER_DEFAULT, /* filter */ - CAIRO_EXTEND_GRADIENT_DEFAULT}, /* extend */ + 1.0 /* opacity */ + }, { 0., 0., 0., 1., 0, 0, 0, 0xffff },/* color (double rgba, short rgba) */ }; const cairo_solid_pattern_t _cairo_pattern_clear = { - { CAIRO_PATTERN_TYPE_SOLID, /* type */ + { CAIRO_REFERENCE_COUNT_INVALID, /* ref_count */ CAIRO_STATUS_SUCCESS, /* status */ { 0, 0, 0, NULL }, /* user_data */ + { NULL, NULL }, /* observers */ + + CAIRO_PATTERN_TYPE_SOLID, /* type */ + CAIRO_FILTER_NEAREST, /* filter */ + CAIRO_EXTEND_REPEAT, /* extend */ + FALSE, /* has component alpha */ { 1., 0., 0., 1., 0., 0., }, /* matrix */ - CAIRO_FILTER_DEFAULT, /* filter */ - CAIRO_EXTEND_GRADIENT_DEFAULT}, /* extend */ + 1.0 /* opacity */ + }, { 0., 0., 0., 0., 0, 0, 0, 0 },/* color (double rgba, short rgba) */ }; const cairo_solid_pattern_t _cairo_pattern_white = { - { CAIRO_PATTERN_TYPE_SOLID, /* type */ + { CAIRO_REFERENCE_COUNT_INVALID, /* ref_count */ CAIRO_STATUS_SUCCESS, /* status */ { 0, 0, 0, NULL }, /* user_data */ + { NULL, NULL }, /* observers */ + + CAIRO_PATTERN_TYPE_SOLID, /* type */ + CAIRO_FILTER_NEAREST, /* filter */ + CAIRO_EXTEND_REPEAT, /* extend */ + FALSE, /* has component alpha */ { 1., 0., 0., 1., 0., 0., }, /* matrix */ - CAIRO_FILTER_DEFAULT, /* filter */ - CAIRO_EXTEND_GRADIENT_DEFAULT}, /* extend */ + 1.0 /* opacity */ + }, { 1., 1., 1., 1., 0xffff, 0xffff, 0xffff, 0xffff },/* color (double rgba, short rgba) */ }; @@ -249,7 +282,6 @@ _cairo_mesh_pattern_init_copy (cairo_mesh_pattern_t *pattern, *pattern = *other; _cairo_array_init (&pattern->patches, sizeof (cairo_mesh_patch_t)); - return _cairo_array_append_multiple (&pattern->patches, _cairo_array_index_const (&other->patches, 0), _cairo_array_num_elements (&other->patches)); @@ -477,7 +509,6 @@ _cairo_pattern_create_copy (cairo_pattern_t **pattern_out, return CAIRO_STATUS_SUCCESS; } - void _cairo_pattern_init_solid (cairo_solid_pattern_t *pattern, const cairo_color_t *color) @@ -2049,477 +2080,6 @@ _cairo_pattern_transform (cairo_pattern_t *pattern, cairo_matrix_multiply (&pattern->matrix, ctm_inverse, &pattern->matrix); } -static void -_cairo_linear_pattern_classify (cairo_linear_pattern_t *pattern, - double offset_x, - double offset_y, - int width, - int height, - cairo_bool_t *is_horizontal, - cairo_bool_t *is_vertical) -{ - cairo_point_double_t point0, point1; - double a, b, c, d, tx, ty; - double scale, start, dx, dy; - cairo_fixed_t factors[3]; - int i; - - /* To classify a pattern as horizontal or vertical, we first - * compute the (fixed point) factors at the corners of the - * pattern. We actually only need 3/4 corners, so we skip the - * fourth. - */ - point0 = pattern->pd1; - point1 = pattern->pd2; - - _cairo_matrix_get_affine (&pattern->base.base.matrix, - &a, &b, &c, &d, &tx, &ty); - - dx = point1.x - point0.x; - dy = point1.y - point0.y; - scale = dx * dx + dy * dy; - scale = (scale) ? 1.0 / scale : 1.0; - - start = dx * point0.x + dy * point0.y; - - for (i = 0; i < 3; i++) { - double qx_device = (i % 2) * (width - 1) + offset_x; - double qy_device = (i / 2) * (height - 1) + offset_y; - - /* transform fragment into pattern space */ - double qx = a * qx_device + c * qy_device + tx; - double qy = b * qx_device + d * qy_device + ty; - - factors[i] = _cairo_fixed_from_double (((dx * qx + dy * qy) - start) * scale); - } - - /* We consider a pattern to be vertical if the fixed point factor - * at the two upper corners is the same. We could accept a small - * change, but determining what change is acceptable would require - * sorting the stops in the pattern and looking at the differences. - * - * Horizontal works the same way with the two left corners. - */ - - *is_vertical = factors[1] == factors[0]; - *is_horizontal = factors[2] == factors[0]; -} - -static cairo_int_status_t -_cairo_pattern_acquire_surface_for_gradient (const cairo_gradient_pattern_t *pattern, - cairo_surface_t *dst, - int x, - int y, - unsigned int width, - unsigned int height, - cairo_surface_t **out, - cairo_surface_attributes_t *attr) -{ - cairo_image_surface_t *image; - pixman_image_t *pixman_image; - pixman_transform_t pixman_transform; - cairo_circle_double_t extremes[2]; - pixman_point_fixed_t p1, p2; - cairo_int_status_t status; - cairo_bool_t repeat = FALSE; - int ix, iy; - pixman_gradient_stop_t pixman_stops_static[2]; - pixman_gradient_stop_t *pixman_stops = pixman_stops_static; - unsigned int i; - int clone_offset_x, clone_offset_y; - cairo_matrix_t matrix = pattern->base.matrix; - - if (CAIRO_INJECT_FAULT ()) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - if (pattern->n_stops > ARRAY_LENGTH(pixman_stops_static)) { - pixman_stops = _cairo_malloc_ab (pattern->n_stops, - sizeof(pixman_gradient_stop_t)); - if (unlikely (pixman_stops == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - for (i = 0; i < pattern->n_stops; i++) { - pixman_stops[i].x = _cairo_fixed_16_16_from_double (pattern->stops[i].offset); - pixman_stops[i].color.red = pattern->stops[i].color.red_short; - pixman_stops[i].color.green = pattern->stops[i].color.green_short; - pixman_stops[i].color.blue = pattern->stops[i].color.blue_short; - pixman_stops[i].color.alpha = pattern->stops[i].color.alpha_short; - } - - _cairo_gradient_pattern_fit_to_range (pattern, PIXMAN_MAX_INT >> 1, &matrix, extremes); - - p1.x = _cairo_fixed_16_16_from_double (extremes[0].center.x); - p1.y = _cairo_fixed_16_16_from_double (extremes[0].center.y); - p2.x = _cairo_fixed_16_16_from_double (extremes[1].center.x); - p2.y = _cairo_fixed_16_16_from_double (extremes[1].center.y); - - if (pattern->base.type == CAIRO_PATTERN_TYPE_LINEAR) { - pixman_image = pixman_image_create_linear_gradient (&p1, &p2, - pixman_stops, - pattern->n_stops); - } else { - pixman_fixed_t r1, r2; - - r1 = _cairo_fixed_16_16_from_double (extremes[0].radius); - r2 = _cairo_fixed_16_16_from_double (extremes[1].radius); - - pixman_image = pixman_image_create_radial_gradient (&p1, &p2, r1, r2, - pixman_stops, - pattern->n_stops); - } - - if (pixman_stops != pixman_stops_static) - free (pixman_stops); - - if (unlikely (pixman_image == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - if (_cairo_surface_is_image (dst)) - { - image = (cairo_image_surface_t *) - _cairo_image_surface_create_for_pixman_image (pixman_image, - PIXMAN_a8r8g8b8); - if (image->base.status) - { - pixman_image_unref (pixman_image); - return image->base.status; - } - - attr->x_offset = attr->y_offset = 0; - attr->matrix = matrix; - attr->extend = pattern->base.extend; - attr->filter = CAIRO_FILTER_NEAREST; - attr->has_component_alpha = pattern->base.has_component_alpha; - - *out = &image->base; - - return CAIRO_STATUS_SUCCESS; - } - - if (pattern->base.type == CAIRO_PATTERN_TYPE_LINEAR) { - cairo_bool_t is_horizontal; - cairo_bool_t is_vertical; - - _cairo_linear_pattern_classify ((cairo_linear_pattern_t *)pattern, - x, y, width, height, - &is_horizontal, &is_vertical); - if (is_horizontal) { - height = 1; - repeat = TRUE; - } - /* width-1 repeating patterns are quite slow with scan-line based - * compositing code, so we use a wider strip and spend some extra - * expense in computing the gradient. It's possible that for narrow - * gradients we'd be better off using a 2 or 4 pixel strip; the - * wider the gradient, the more it's worth spending extra time - * computing a sample. - */ - if (is_vertical && width > 8) { - width = 8; - repeat = TRUE; - } - } - - if (! pixman_image_set_filter (pixman_image, PIXMAN_FILTER_BILINEAR, - NULL, 0)) - { - pixman_image_unref (pixman_image); - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - image = (cairo_image_surface_t *) - cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height); - if (image->base.status) { - pixman_image_unref (pixman_image); - return image->base.status; - } - - ix = x; - iy = y; - status = _cairo_matrix_to_pixman_matrix_offset (&matrix, - pattern->base.filter, - width/2., height/2., - &pixman_transform, - &ix, &iy); - if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) { - if (unlikely (status != CAIRO_INT_STATUS_SUCCESS) || - ! pixman_image_set_transform (pixman_image, &pixman_transform)) - { - cairo_surface_destroy (&image->base); - pixman_image_unref (pixman_image); - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - } - - switch (pattern->base.extend) { - case CAIRO_EXTEND_NONE: - pixman_image_set_repeat (pixman_image, PIXMAN_REPEAT_NONE); - break; - case CAIRO_EXTEND_REPEAT: - pixman_image_set_repeat (pixman_image, PIXMAN_REPEAT_NORMAL); - break; - case CAIRO_EXTEND_REFLECT: - pixman_image_set_repeat (pixman_image, PIXMAN_REPEAT_REFLECT); - break; - case CAIRO_EXTEND_PAD: - pixman_image_set_repeat (pixman_image, PIXMAN_REPEAT_PAD); - break; - } - - pixman_image_composite32 (PIXMAN_OP_SRC, - pixman_image, - NULL, - image->pixman_image, - ix, iy, - 0, 0, - 0, 0, - width, height); - - pixman_image_unref (pixman_image); - - _cairo_debug_check_image_surface_is_defined (&image->base); - - status = _cairo_surface_clone_similar (dst, &image->base, - 0, 0, width, height, - &clone_offset_x, - &clone_offset_y, - out); - - cairo_surface_destroy (&image->base); - - attr->x_offset = -x; - attr->y_offset = -y; - cairo_matrix_init_identity (&attr->matrix); - attr->extend = repeat ? CAIRO_EXTEND_REPEAT : CAIRO_EXTEND_NONE; - attr->filter = CAIRO_FILTER_NEAREST; - attr->has_component_alpha = pattern->base.has_component_alpha; - - return status; -} - -static cairo_int_status_t -_cairo_pattern_acquire_surface_for_mesh (const cairo_mesh_pattern_t *pattern, - cairo_surface_t *dst, - int x, - int y, - unsigned int width, - unsigned int height, - cairo_surface_t **out, - cairo_surface_attributes_t *attr) -{ - cairo_surface_t *image; - void *data; - cairo_status_t status; - int clone_offset_x, clone_offset_y; - int stride; - - image = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height); - if (unlikely (image->status)) - return image->status; - - stride = cairo_image_surface_get_stride (image); - data = cairo_image_surface_get_data (image); - - _cairo_mesh_pattern_rasterize (pattern, data, width, height, stride, -x, -y); - - attr->x_offset = -x; - attr->y_offset = -y; - attr->filter = CAIRO_FILTER_NEAREST; - attr->extend = pattern->base.extend; - cairo_matrix_init_identity (&attr->matrix); - attr->has_component_alpha = pattern->base.has_component_alpha; - - if (_cairo_surface_is_image (dst)) { - *out = image; - - return CAIRO_STATUS_SUCCESS; - } - - status = _cairo_surface_clone_similar (dst, image, - 0, 0, width, height, - &clone_offset_x, - &clone_offset_y, out); - - cairo_surface_destroy (image); - - return status; -} - -/* We maintain a small cache here, because we don't want to constantly - * recreate surfaces for simple solid colors. */ -#define MAX_SURFACE_CACHE_SIZE 16 -static struct { - struct _cairo_pattern_solid_surface_cache{ - cairo_color_t color; - cairo_surface_t *surface; - } cache[MAX_SURFACE_CACHE_SIZE]; - int size; -} solid_surface_cache; - -static cairo_bool_t -_cairo_pattern_solid_surface_matches ( - const struct _cairo_pattern_solid_surface_cache *cache, - const cairo_solid_pattern_t *pattern, - cairo_surface_t *dst) -{ - if (cairo_surface_get_content (cache->surface) != _cairo_color_get_content (&pattern->color)) - return FALSE; - - if (CAIRO_REFERENCE_COUNT_GET_VALUE (&cache->surface->ref_count) != 1) - return FALSE; - - if (! _cairo_surface_is_similar (cache->surface, dst)) - return FALSE; - - return TRUE; -} - -static cairo_bool_t -_cairo_pattern_solid_surface_matches_color ( - const struct _cairo_pattern_solid_surface_cache *cache, - const cairo_solid_pattern_t *pattern, - cairo_surface_t *dst) -{ - if (! _cairo_color_equal (&cache->color, &pattern->color)) - return FALSE; - - return _cairo_pattern_solid_surface_matches (cache, pattern, dst); -} - -static cairo_int_status_t -_cairo_pattern_acquire_surface_for_solid (const cairo_solid_pattern_t *pattern, - cairo_surface_t *dst, - int x, - int y, - unsigned int width, - unsigned int height, - cairo_surface_t **out, - cairo_surface_attributes_t *attribs) -{ - static int i; - - cairo_surface_t *surface, *to_destroy = NULL; - cairo_status_t status; - - CAIRO_MUTEX_LOCK (_cairo_pattern_solid_surface_cache_lock); - - /* Check cache first */ - if (i < solid_surface_cache.size && - _cairo_pattern_solid_surface_matches_color (&solid_surface_cache.cache[i], - pattern, - dst)) - { - goto DONE; - } - - for (i = 0 ; i < solid_surface_cache.size; i++) { - if (_cairo_pattern_solid_surface_matches_color (&solid_surface_cache.cache[i], - pattern, - dst)) - { - goto DONE; - } - } - - /* Choose a surface to repaint/evict */ - surface = NULL; - if (solid_surface_cache.size == MAX_SURFACE_CACHE_SIZE) { - i = rand () % MAX_SURFACE_CACHE_SIZE; - surface = solid_surface_cache.cache[i].surface; - - if (_cairo_pattern_solid_surface_matches (&solid_surface_cache.cache[i], - pattern, - dst)) - { - /* Reuse the surface instead of evicting */ - status = _cairo_surface_repaint_solid_pattern_surface (dst, surface, pattern); - if (unlikely (status)) - goto EVICT; - - cairo_surface_reference (surface); - } - else - { - EVICT: - surface = NULL; - } - } - - if (surface == NULL) { - /* Not cached, need to create new */ - surface = _cairo_surface_create_solid_pattern_surface (dst, pattern); - if (surface == NULL) { - status = CAIRO_INT_STATUS_UNSUPPORTED; - goto UNLOCK; - } - if (unlikely (surface->status)) { - status = surface->status; - goto UNLOCK; - } - - if (unlikely (! _cairo_surface_is_similar (surface, dst))) - { - /* In the rare event of a substitute surface being returned, - * don't cache the fallback. - */ - *out = surface; - goto NOCACHE; - } - } - - if (i == solid_surface_cache.size) - solid_surface_cache.size++; - - to_destroy = solid_surface_cache.cache[i].surface; - solid_surface_cache.cache[i].surface = surface; - solid_surface_cache.cache[i].color = pattern->color; - -DONE: - *out = cairo_surface_reference (solid_surface_cache.cache[i].surface); - -NOCACHE: - attribs->x_offset = attribs->y_offset = 0; - cairo_matrix_init_identity (&attribs->matrix); - attribs->extend = CAIRO_EXTEND_REPEAT; - attribs->filter = CAIRO_FILTER_NEAREST; - attribs->has_component_alpha = pattern->base.has_component_alpha; - - status = CAIRO_STATUS_SUCCESS; - -UNLOCK: - CAIRO_MUTEX_UNLOCK (_cairo_pattern_solid_surface_cache_lock); - - if (to_destroy) - cairo_surface_destroy (to_destroy); - - return status; -} - -static void -_cairo_pattern_reset_solid_surface_cache (void) -{ - CAIRO_MUTEX_LOCK (_cairo_pattern_solid_surface_cache_lock); - - /* remove surfaces starting from the end so that solid_surface_cache.cache - * is always in a consistent state when we release the mutex. */ - while (solid_surface_cache.size) { - cairo_surface_t *surface; - - solid_surface_cache.size--; - surface = solid_surface_cache.cache[solid_surface_cache.size].surface; - solid_surface_cache.cache[solid_surface_cache.size].surface = NULL; - - /* release the lock to avoid the possibility of a recursive - * deadlock when the surface destroy closure gets called */ - CAIRO_MUTEX_UNLOCK (_cairo_pattern_solid_surface_cache_lock); - cairo_surface_destroy (surface); - CAIRO_MUTEX_LOCK (_cairo_pattern_solid_surface_cache_lock); - } - - CAIRO_MUTEX_UNLOCK (_cairo_pattern_solid_surface_cache_lock); -} - static cairo_bool_t _linear_pattern_is_degenerate (const cairo_linear_pattern_t *linear) { @@ -3546,7 +3106,7 @@ _cairo_pattern_is_opaque_solid (const cairo_pattern_t *pattern) static cairo_bool_t _surface_is_opaque (const cairo_surface_pattern_t *pattern, - const cairo_rectangle_int_t *r) + const cairo_rectangle_int_t *sample) { if (pattern->surface->content & CAIRO_CONTENT_ALPHA) return FALSE; @@ -3554,16 +3114,16 @@ _surface_is_opaque (const cairo_surface_pattern_t *pattern, if (pattern->base.extend != CAIRO_EXTEND_NONE) return TRUE; - if (r != NULL) { + if (sample != NULL) { cairo_rectangle_int_t extents; if (! _cairo_surface_get_extents (pattern->surface, &extents)) return TRUE; - if (r->x >= extents.x && - r->y >= extents.y && - r->x + r->width <= extents.x + extents.width && - r->y + r->height <= extents.y + extents.height) + if (sample->x >= extents.x && + sample->y >= extents.y && + sample->x + sample->width <= extents.x + extents.width && + sample->y + sample->height <= extents.y + extents.height) { return TRUE; } @@ -3587,7 +3147,7 @@ _surface_is_clear (const cairo_surface_pattern_t *pattern) static cairo_bool_t _gradient_is_opaque (const cairo_gradient_pattern_t *gradient, - const cairo_rectangle_int_t *extents) + const cairo_rectangle_int_t *sample) { unsigned int i; @@ -3608,14 +3168,14 @@ _gradient_is_opaque (const cairo_gradient_pattern_t *gradient, if (_linear_pattern_is_degenerate (linear)) return FALSE; - if (extents == NULL) + if (sample == NULL) return FALSE; _cairo_linear_pattern_box_to_parameter (linear, - extents->x, - extents->y, - extents->x + extents->width, - extents->y + extents->height, + sample->x, + sample->y, + sample->x + sample->width, + sample->y + sample->height, t); if (t[0] < 0.0 || t[1] > 1.0) @@ -3642,7 +3202,7 @@ _gradient_is_opaque (const cairo_gradient_pattern_t *gradient, **/ cairo_bool_t _cairo_pattern_is_opaque (const cairo_pattern_t *abstract_pattern, - const cairo_rectangle_int_t *extents) + const cairo_rectangle_int_t *sample) { const cairo_pattern_union_t *pattern; @@ -3654,10 +3214,10 @@ _cairo_pattern_is_opaque (const cairo_pattern_t *abstract_pattern, case CAIRO_PATTERN_TYPE_SOLID: return _cairo_pattern_is_opaque_solid (abstract_pattern); case CAIRO_PATTERN_TYPE_SURFACE: - return _surface_is_opaque (&pattern->surface, extents); + return _surface_is_opaque (&pattern->surface, sample); case CAIRO_PATTERN_TYPE_LINEAR: case CAIRO_PATTERN_TYPE_RADIAL: - return _gradient_is_opaque (&pattern->gradient.base, extents); + return _gradient_is_opaque (&pattern->gradient.base, sample); case CAIRO_PATTERN_TYPE_MESH: return FALSE; } @@ -3749,437 +3309,53 @@ _cairo_pattern_analyze_filter (const cairo_pattern_t *pattern, return optimized_filter; } - -static double -_pixman_nearest_sample (double d) -{ - return ceil (d - .5); -} - -static cairo_int_status_t -_cairo_pattern_acquire_surface_for_surface (const cairo_surface_pattern_t *pattern, - cairo_surface_t *dst, - int x, - int y, - unsigned int width, - unsigned int height, - unsigned int flags, - cairo_surface_t **out, - cairo_surface_attributes_t *attr) +cairo_filter_t +_cairo_pattern_sampled_area (const cairo_pattern_t *pattern, + const cairo_rectangle_int_t *extents, + cairo_rectangle_int_t *sample) { - cairo_surface_t *surface; - cairo_rectangle_int_t extents; - cairo_rectangle_int_t sampled_area; - double x1, y1, x2, y2; - int tx, ty; + cairo_filter_t filter; + double x1, x2, y1, y2; double pad; - cairo_bool_t is_identity; - cairo_bool_t is_bounded; - cairo_int_status_t status; - - surface = cairo_surface_reference (pattern->surface); - - is_identity = FALSE; - attr->matrix = pattern->base.matrix; - attr->extend = pattern->base.extend; - attr->filter = _cairo_pattern_analyze_filter (&pattern->base, &pad); - attr->has_component_alpha = pattern->base.has_component_alpha; - - attr->x_offset = attr->y_offset = tx = ty = 0; - if (_cairo_matrix_is_integer_translation (&attr->matrix, &tx, &ty)) { - cairo_matrix_init_identity (&attr->matrix); - attr->x_offset = tx; - attr->y_offset = ty; - is_identity = TRUE; - } else if (attr->filter == CAIRO_FILTER_NEAREST) { - /* - * For NEAREST, we can remove the fractional translation component - * from the transformation - this ensures that the pattern will always - * hit fast-paths in the backends for simple transformations that - * become (almost) identity, without loss of quality. - */ - attr->matrix.x0 = 0; - attr->matrix.y0 = 0; - if (_cairo_matrix_is_pixel_exact (&attr->matrix)) { - /* The rounding here is rather peculiar as it needs to match the - * rounding performed on the sample coordinate used by pixman. - */ - attr->matrix.x0 = _pixman_nearest_sample (pattern->base.matrix.x0); - attr->matrix.y0 = _pixman_nearest_sample (pattern->base.matrix.y0); - } else { - attr->matrix.x0 = pattern->base.matrix.x0; - attr->matrix.y0 = pattern->base.matrix.y0; - } - if (_cairo_matrix_is_integer_translation (&attr->matrix, &tx, &ty)) { - cairo_matrix_init_identity (&attr->matrix); - attr->x_offset = tx; - attr->y_offset = ty; - is_identity = TRUE; - } + filter = _cairo_pattern_analyze_filter (pattern, &pad); + if (pad == 0.0 && _cairo_matrix_is_identity (&pattern->matrix)) { + *sample = *extents; + return filter; } - /* XXX: Hack: - * - * The way we currently support CAIRO_EXTEND_REFLECT is to create - * an image twice bigger on each side, and create a pattern of four - * images such that the new image, when repeated, has the same effect - * of reflecting the original pattern. - */ - if (flags & CAIRO_PATTERN_ACQUIRE_NO_REFLECT && - attr->extend == CAIRO_EXTEND_REFLECT) - { - cairo_t *cr; - cairo_surface_t *src; - int w, h; - - is_bounded = _cairo_surface_get_extents (surface, &extents); - assert (is_bounded); - - status = _cairo_surface_clone_similar (dst, surface, - extents.x, extents.y, - extents.width, extents.height, - &extents.x, &extents.y, &src); - if (unlikely (status)) - goto BAIL; - - w = 2 * extents.width; - h = 2 * extents.height; - - if (is_identity) { - attr->x_offset = -x; - x += tx; - while (x <= -w) - x += w; - while (x >= w) - x -= w; - extents.x += x; - tx = x = 0; - - attr->y_offset = -y; - y += ty; - while (y <= -h) - y += h; - while (y >= h) - y -= h; - extents.y += y; - ty = y = 0; - } - - cairo_surface_destroy (surface); - surface = _cairo_surface_create_similar_solid (dst, - dst->content, w, h, - CAIRO_COLOR_TRANSPARENT, - FALSE); - if (surface == NULL) - return CAIRO_INT_STATUS_UNSUPPORTED; - if (unlikely (surface->status)) { - cairo_surface_destroy (src); - return surface->status; - } - - surface->device_transform = pattern->surface->device_transform; - surface->device_transform_inverse = pattern->surface->device_transform_inverse; - - cr = cairo_create (surface); - - cairo_set_source_surface (cr, src, -extents.x, -extents.y); - cairo_paint (cr); - - cairo_scale (cr, -1, +1); - cairo_set_source_surface (cr, src, extents.x-w, -extents.y); - cairo_paint (cr); - cairo_set_source_surface (cr, src, extents.x, -extents.y); - cairo_paint (cr); - - cairo_scale (cr, +1, -1); - cairo_set_source_surface (cr, src, extents.x-w, extents.y-h); - cairo_paint (cr); - cairo_set_source_surface (cr, src, extents.x, extents.y-h); - cairo_paint (cr); - cairo_set_source_surface (cr, src, extents.x-w, extents.y); - cairo_paint (cr); - cairo_set_source_surface (cr, src, extents.x, extents.y); - cairo_paint (cr); - - cairo_scale (cr, -1, +1); - cairo_set_source_surface (cr, src, -extents.x, extents.y-h); - cairo_paint (cr); - cairo_set_source_surface (cr, src, -extents.x, extents.y); - cairo_paint (cr); - - status = cairo_status (cr); - cairo_destroy (cr); - - cairo_surface_destroy (src); - - if (unlikely (status)) - goto BAIL; - - attr->extend = CAIRO_EXTEND_REPEAT; - } - - /* We first transform the rectangle to the coordinate space of the - * source surface so that we only need to clone that portion of the - * surface that will be read. - */ - x1 = x; - y1 = y; - x2 = x + (int) width; - y2 = y + (int) height; - if (! is_identity) { - _cairo_matrix_transform_bounding_box (&attr->matrix, - &x1, &y1, &x2, &y2, - NULL); - } - - sampled_area.x = floor (x1 - pad); - sampled_area.y = floor (y1 - pad); - sampled_area.width = ceil (x2 + pad) - sampled_area.x; - sampled_area.height = ceil (y2 + pad) - sampled_area.y; - - sampled_area.x += tx; - sampled_area.y += ty; - - if ( _cairo_surface_get_extents (surface, &extents)) { - if (attr->extend == CAIRO_EXTEND_NONE) { - /* Never acquire a larger area than the source itself */ - _cairo_rectangle_intersect (&extents, &sampled_area); - } else { - int trim = 0; - - if (sampled_area.x >= extents.x && - sampled_area.x + (int) sampled_area.width <= extents.x + (int) extents.width) - { - /* source is horizontally contained within extents, trim */ - extents.x = sampled_area.x; - extents.width = sampled_area.width; - trim |= 0x1; - } - - if (sampled_area.y >= extents.y && - sampled_area.y + (int) sampled_area.height <= extents.y + (int) extents.height) - { - /* source is vertically contained within extents, trim */ - extents.y = sampled_area.y; - extents.height = sampled_area.height; - trim |= 0x2; - } - - if (trim == 0x3) { - /* source is wholly contained within extents, drop the REPEAT */ - attr->extend = CAIRO_EXTEND_NONE; - } - } - } - - status = _cairo_surface_clone_similar (dst, surface, - extents.x, extents.y, - extents.width, extents.height, - &x, &y, out); - if (unlikely (status)) - goto BAIL; - - if (x != 0 || y != 0) { - if (is_identity) { - attr->x_offset -= x; - attr->y_offset -= y; - } else { - cairo_matrix_t m; - - x -= attr->x_offset; - y -= attr->y_offset; - attr->x_offset = 0; - attr->y_offset = 0; - - cairo_matrix_init_translate (&m, -x, -y); - cairo_matrix_multiply (&attr->matrix, &attr->matrix, &m); - } - } - - /* reduce likelihood of range overflow with large downscaling */ - if (! is_identity) { - cairo_matrix_t m; - cairo_status_t invert_status; - - m = attr->matrix; - invert_status = cairo_matrix_invert (&m); - assert (invert_status == CAIRO_STATUS_SUCCESS); - - if (m.x0 != 0. || m.y0 != 0.) { - /* pixman also limits the [xy]_offset to 16 bits so evenly - * spread the bits between the two. - */ - x = floor (m.x0 / 2); - y = floor (m.y0 / 2); - attr->x_offset -= x; - attr->y_offset -= y; - cairo_matrix_init_translate (&m, x, y); - cairo_matrix_multiply (&attr->matrix, &m, &attr->matrix); - } - } - - BAIL: - cairo_surface_destroy (surface); - return status; -} - -/** - * _cairo_pattern_acquire_surface: - * @pattern: a #cairo_pattern_t - * @dst: destination surface - * @x: X coordinate in source corresponding to left side of destination area - * @y: Y coordinate in source corresponding to top side of destination area - * @width: width of destination area - * @height: height of destination area - * @surface_out: location to store a pointer to a surface - * @attributes: surface attributes that destination backend should apply to - * the returned surface - * - * A convenience function to obtain a surface to use as the source for - * drawing on @dst. - * - * Note that this function is only suitable for use when the destination - * surface is pixel based and 1 device unit maps to one pixel. - * - * Return value: %CAIRO_STATUS_SUCCESS if a surface was stored in @surface_out. - **/ -cairo_int_status_t -_cairo_pattern_acquire_surface (const cairo_pattern_t *pattern, - cairo_surface_t *dst, - int x, - int y, - unsigned int width, - unsigned int height, - unsigned int flags, - cairo_surface_t **surface_out, - cairo_surface_attributes_t *attributes) -{ - if (unlikely (pattern->status)) { - *surface_out = NULL; - return pattern->status; - } + x1 = extents->x; + y1 = extents->y; + x2 = extents->x + (int) extents->width; + y2 = extents->y + (int) extents->height; - switch (pattern->type) { - case CAIRO_PATTERN_TYPE_SOLID: - return _cairo_pattern_acquire_surface_for_solid ((cairo_solid_pattern_t *) pattern, - dst, x, y, width, height, - surface_out, - attributes); - - case CAIRO_PATTERN_TYPE_LINEAR: - case CAIRO_PATTERN_TYPE_RADIAL: - return _cairo_pattern_acquire_surface_for_gradient ((cairo_gradient_pattern_t *) pattern, - dst, x, y, width, height, - surface_out, - attributes); - - case CAIRO_PATTERN_TYPE_SURFACE: - return _cairo_pattern_acquire_surface_for_surface ((cairo_surface_pattern_t *) pattern, - dst, x, y, width, height, - flags, - surface_out, - attributes); - - case CAIRO_PATTERN_TYPE_MESH: - return _cairo_pattern_acquire_surface_for_mesh ((cairo_mesh_pattern_t *) pattern, - dst, x, y, width, height, - surface_out, - attributes); - - default: - ASSERT_NOT_REACHED; - return _cairo_error (CAIRO_STATUS_PATTERN_TYPE_MISMATCH); - } -} - -/** - * _cairo_pattern_release_surface: - * @pattern: a #cairo_pattern_t - * @surface: a surface obtained by _cairo_pattern_acquire_surface - * @attributes: attributes obtained by _cairo_pattern_acquire_surface - * - * Releases resources obtained by _cairo_pattern_acquire_surface. - **/ -void -_cairo_pattern_release_surface (const cairo_pattern_t *pattern, - cairo_surface_t *surface, - cairo_surface_attributes_t *attributes) -{ - cairo_surface_destroy (surface); -} - -cairo_int_status_t -_cairo_pattern_acquire_surfaces (const cairo_pattern_t *src, - const cairo_pattern_t *mask, - cairo_surface_t *dst, - int src_x, - int src_y, - int mask_x, - int mask_y, - unsigned int width, - unsigned int height, - unsigned int flags, - cairo_surface_t **src_out, - cairo_surface_t **mask_out, - cairo_surface_attributes_t *src_attributes, - cairo_surface_attributes_t *mask_attributes) -{ - cairo_int_status_t status; - cairo_pattern_union_t src_tmp; - - if (unlikely (src->status)) - return src->status; - if (unlikely (mask != NULL && mask->status)) - return mask->status; - - /* If src and mask are both solid, then the mask alpha can be - * combined into src and mask can be ignored. */ - - if (src->type == CAIRO_PATTERN_TYPE_SOLID && - mask && - ! mask->has_component_alpha && - mask->type == CAIRO_PATTERN_TYPE_SOLID) - { - cairo_color_t combined; - cairo_solid_pattern_t *src_solid = (cairo_solid_pattern_t *) src; - cairo_solid_pattern_t *mask_solid = (cairo_solid_pattern_t *) mask; - - combined = src_solid->color; - _cairo_color_multiply_alpha (&combined, mask_solid->color.alpha); - - _cairo_pattern_init_solid (&src_tmp.solid, &combined); - - src = &src_tmp.base; - mask = NULL; - } + _cairo_matrix_transform_bounding_box (&pattern->matrix, + &x1, &y1, &x2, &y2, + NULL); + if (x1 > CAIRO_RECT_INT_MIN) + sample->x = floor (x1 - pad); + else + sample->x = CAIRO_RECT_INT_MIN; - status = _cairo_pattern_acquire_surface (src, dst, - src_x, src_y, - width, height, - flags, - src_out, src_attributes); - if (unlikely (status)) - goto BAIL; + if (y1 > CAIRO_RECT_INT_MIN) + sample->y = floor (y1 - pad); + else + sample->y = CAIRO_RECT_INT_MIN; - if (mask == NULL) { - *mask_out = NULL; - goto BAIL; - } + if (x2 < CAIRO_RECT_INT_MAX) + sample->width = ceil (x2 + pad); + else + sample->width = CAIRO_RECT_INT_MAX; - status = _cairo_pattern_acquire_surface (mask, dst, - mask_x, mask_y, - width, height, - flags, - mask_out, mask_attributes); - if (unlikely (status)) - _cairo_pattern_release_surface (src, *src_out, src_attributes); + if (y2 < CAIRO_RECT_INT_MAX) + sample->height = ceil (y2 + pad); + else + sample->height = CAIRO_RECT_INT_MAX; - BAIL: - if (src == &src_tmp.base) - _cairo_pattern_fini (&src_tmp.base); + sample->width -= sample->x; + sample->height -= sample->y; - return status; + return filter; } /** @@ -4381,7 +3557,7 @@ _cairo_pattern_get_extents (const cairo_pattern_t *pattern, * * Return the "target-space" inked extents of @pattern in @extents. **/ -void +cairo_int_status_t _cairo_pattern_get_ink_extents (const cairo_pattern_t *pattern, cairo_rectangle_int_t *extents) { @@ -4392,33 +3568,28 @@ _cairo_pattern_get_ink_extents (const cairo_pattern_t *pattern, (const cairo_surface_pattern_t *) pattern; cairo_surface_t *surface = surface_pattern->surface; - if (surface->type == CAIRO_SURFACE_TYPE_RECORDING) { + if (_cairo_surface_is_recording (surface)) { cairo_matrix_t imatrix; - double x1, y1, x2, y2, width, height; + cairo_box_t box; cairo_status_t status; - cairo_recording_surface_ink_extents (surface, &x1, &y1, &width, &height); imatrix = pattern->matrix; status = cairo_matrix_invert (&imatrix); /* cairo_pattern_set_matrix ensures the matrix is invertible */ assert (status == CAIRO_STATUS_SUCCESS); - x2 = x1 + width; - y2 = y1 + height; - _cairo_matrix_transform_bounding_box (&imatrix, - &x1, &y1, &x2, &y2, - NULL); - x1 = floor (x1); - y1 = floor (y1); - x2 = ceil (x2); - y2 = ceil (y2); - extents->x = x1; extents->width = x2 - x1; - extents->y = y1; extents->height = y2 - y1; - return; + status = _cairo_recording_surface_get_ink_bbox ((cairo_recording_surface_t *)surface, + &box, &imatrix); + if (unlikely (status)) + return status; + + _cairo_box_round_to_rectangle (&box, extents); + return CAIRO_STATUS_SUCCESS; } } - return _cairo_pattern_get_extents (pattern, extents); + _cairo_pattern_get_extents (pattern, extents); + return CAIRO_STATUS_SUCCESS; } static unsigned long @@ -5200,6 +4371,88 @@ _cairo_pattern_reset_static_data (void) for (i = 0; i < ARRAY_LENGTH (freed_pattern_pool); i++) _freed_pool_reset (&freed_pattern_pool[i]); +} + +static void +_cairo_debug_print_surface_pattern (FILE *file, + const cairo_surface_pattern_t *pattern) +{ + printf (" surface type: %d\n", pattern->surface->type); +} + +static void +_cairo_debug_print_linear_pattern (FILE *file, + const cairo_linear_pattern_t *pattern) +{ +} + +static void +_cairo_debug_print_radial_pattern (FILE *file, + const cairo_radial_pattern_t *pattern) +{ +} + +static void +_cairo_debug_print_mesh_pattern (FILE *file, + const cairo_mesh_pattern_t *pattern) +{ +} + +void +_cairo_debug_print_pattern (FILE *file, const cairo_pattern_t *pattern) +{ + const char *s; + switch (pattern->type) { + case CAIRO_PATTERN_TYPE_SOLID: s = "solid"; break; + case CAIRO_PATTERN_TYPE_SURFACE: s = "surface"; break; + case CAIRO_PATTERN_TYPE_LINEAR: s = "linear"; break; + case CAIRO_PATTERN_TYPE_RADIAL: s = "radial"; break; + case CAIRO_PATTERN_TYPE_MESH: s = "mesh"; break; + default: s = "invalid"; ASSERT_NOT_REACHED; break; + } - _cairo_pattern_reset_solid_surface_cache (); + fprintf (file, "pattern: %s\n", s); + if (pattern->type == CAIRO_PATTERN_TYPE_SOLID) + return; + + switch (pattern->extend) { + case CAIRO_EXTEND_NONE: s = "none"; break; + case CAIRO_EXTEND_REPEAT: s = "repeat"; break; + case CAIRO_EXTEND_REFLECT: s = "reflect"; break; + case CAIRO_EXTEND_PAD: s = "pad"; break; + default: s = "invalid"; ASSERT_NOT_REACHED; break; + } + fprintf (file, " extend: %s\n", s); + + switch (pattern->filter) { + case CAIRO_FILTER_FAST: s = "fast"; break; + case CAIRO_FILTER_GOOD: s = "good"; break; + case CAIRO_FILTER_BEST: s = "best"; break; + case CAIRO_FILTER_NEAREST: s = "nearest"; break; + case CAIRO_FILTER_BILINEAR: s = "bilinear"; break; + case CAIRO_FILTER_GAUSSIAN: s = "guassian"; break; + default: s = "invalid"; ASSERT_NOT_REACHED; break; + } + fprintf (file, " filter: %s\n", s); + fprintf (file, " matrix: [%g %g %g %g %g %g]\n", + pattern->matrix.xx, pattern->matrix.yx, + pattern->matrix.xy, pattern->matrix.yy, + pattern->matrix.x0, pattern->matrix.y0); + switch (pattern->type) { + default: + case CAIRO_PATTERN_TYPE_SOLID: + break; + case CAIRO_PATTERN_TYPE_SURFACE: + _cairo_debug_print_surface_pattern (file, (cairo_surface_pattern_t *)pattern); + break; + case CAIRO_PATTERN_TYPE_LINEAR: + _cairo_debug_print_linear_pattern (file, (cairo_linear_pattern_t *)pattern); + break; + case CAIRO_PATTERN_TYPE_RADIAL: + _cairo_debug_print_radial_pattern (file, (cairo_radial_pattern_t *)pattern); + break; + case CAIRO_PATTERN_TYPE_MESH: + _cairo_debug_print_mesh_pattern (file, (cairo_mesh_pattern_t *)pattern); + break; + } } diff --git a/src/cairo-pdf-operators.c b/src/cairo-pdf-operators.c index 58c64721..fceaf1cc 100644 --- a/src/cairo-pdf-operators.c +++ b/src/cairo-pdf-operators.c @@ -769,7 +769,7 @@ _cairo_pdf_operators_emit_stroke (cairo_pdf_operators_t *pdf_operators, const cairo_matrix_t *ctm_inverse, const char *pdf_operator) { - cairo_status_t status; + cairo_int_status_t status; cairo_matrix_t m, path_transform; cairo_bool_t has_ctm = TRUE; double scale = 1.0; diff --git a/src/cairo-pdf-shading.c b/src/cairo-pdf-shading.c index 6b7bcea1..646e2cd4 100644 --- a/src/cairo-pdf-shading.c +++ b/src/cairo-pdf-shading.c @@ -39,6 +39,8 @@ #if CAIRO_HAS_PDF_OPERATORS #include "cairo-pdf-shading-private.h" + +#include "cairo-array-private.h" #include "cairo-error-private.h" #include <float.h> diff --git a/src/cairo-pdf-surface.c b/src/cairo-pdf-surface.c index b115fd1e..3f2d0470 100644 --- a/src/cairo-pdf-surface.c +++ b/src/cairo-pdf-surface.c @@ -41,10 +41,13 @@ #define _BSD_SOURCE /* for snprintf() */ #include "cairoint.h" + #include "cairo-pdf.h" #include "cairo-pdf-surface-private.h" #include "cairo-pdf-operators-private.h" #include "cairo-pdf-shading-private.h" + +#include "cairo-array-private.h" #include "cairo-analysis-surface-private.h" #include "cairo-composite-rectangles-private.h" #include "cairo-default-context-private.h" @@ -1122,17 +1125,19 @@ _get_source_surface_size (cairo_surface_t *source, *height = extents->height; } else { cairo_rectangle_int_t surf_extents; - double x, y, w, h; + cairo_box_t box; cairo_bool_t bounded; if (_cairo_surface_is_snapshot (source)) source = _cairo_surface_snapshot_get_target (source); - cairo_recording_surface_ink_extents (source, &x, &y,&w, &h); - extents->x = floor (x); - extents->y = floor (y); - extents->width = ceil (x + w) - extents->x; - extents->height = ceil (y + h) - extents->y; + status = _cairo_recording_surface_get_ink_bbox ((cairo_recording_surface_t *)source, + &box, NULL); + if (unlikely (status)) + return status; + + _cairo_box_round_to_rectangle (&box, extents); + bounded = _cairo_surface_get_extents (source, &surf_extents); *width = surf_extents.width; *height = surf_extents.height; @@ -2358,16 +2363,9 @@ _cairo_pdf_surface_emit_padded_image_surface (cairo_pdf_surface_t *surface, _cairo_pattern_init_for_surface (&pad_pattern, &image->base); cairo_matrix_init_translate (&pad_pattern.base.matrix, -x, -y); pad_pattern.base.extend = CAIRO_EXTEND_PAD; - status = _cairo_surface_composite (CAIRO_OPERATOR_SOURCE, - &pad_pattern.base, - NULL, - pad_image, - 0, 0, - 0, 0, - 0, 0, - rect.width, - rect.height, - NULL); + status = _cairo_surface_paint (pad_image, + CAIRO_OPERATOR_SOURCE, &pad_pattern.base, + NULL); _cairo_pattern_fini (&pad_pattern.base); if (unlikely (status)) goto BAIL; @@ -5917,11 +5915,10 @@ _cairo_pdf_surface_paint (void *abstract_surface, cairo_pdf_smask_group_t *group; cairo_pdf_resource_t pattern_res, gstate_res; cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_int_status_t status; - _cairo_pdf_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_paint (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_paint (&extents, + &surface->base, op, source, clip); if (unlikely (status)) return status; @@ -6037,11 +6034,10 @@ _cairo_pdf_surface_mask (void *abstract_surface, cairo_pdf_surface_t *surface = abstract_surface; cairo_pdf_smask_group_t *group; cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_int_status_t status; - _cairo_pdf_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_mask (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_mask (&extents, + &surface->base, op, source, mask, clip); if (unlikely (status)) return status; @@ -6166,11 +6162,10 @@ _cairo_pdf_surface_stroke (void *abstract_surface, cairo_pdf_smask_group_t *group; cairo_pdf_resource_t pattern_res, gstate_res; cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_int_status_t status; - _cairo_pdf_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_stroke (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_stroke (&extents, + &surface->base, op, source, path, style, ctm, clip); @@ -6305,10 +6300,9 @@ _cairo_pdf_surface_fill (void *abstract_surface, cairo_pdf_smask_group_t *group; cairo_pdf_resource_t pattern_res, gstate_res; cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; - _cairo_pdf_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_fill (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_fill (&extents, + &surface->base, op, source, path, clip); if (unlikely (status)) @@ -6471,7 +6465,6 @@ _cairo_pdf_surface_fill_stroke (void *abstract_surface, cairo_int_status_t status; cairo_pdf_resource_t fill_pattern_res, stroke_pattern_res, gstate_res; cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; /* During analysis we return unsupported and let the _fill and * _stroke functions that are on the fallback path do the analysis @@ -6498,8 +6491,8 @@ _cairo_pdf_surface_fill_stroke (void *abstract_surface, /* Compute the operation extents using the stroke which will naturally * be larger than the fill extents. */ - _cairo_pdf_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_stroke (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_stroke (&extents, + &surface->base, stroke_op, stroke_source, path, stroke_style, stroke_ctm, clip); @@ -6630,12 +6623,11 @@ _cairo_pdf_surface_show_text_glyphs (void *abstract_surface, cairo_pdf_smask_group_t *group; cairo_pdf_resource_t pattern_res, gstate_res; cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_bool_t overlap; cairo_int_status_t status; - _cairo_pdf_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_glyphs (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_glyphs (&extents, + &surface->base, op, source, scaled_font, glyphs, num_glyphs, @@ -6798,37 +6790,24 @@ static const cairo_surface_backend_t cairo_pdf_surface_backend = { NULL, /* acquire_source_image */ NULL, /* release_source_image */ - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + NULL, /* snapshot */ + NULL, /* _cairo_pdf_surface_copy_page */ _cairo_pdf_surface_show_page, + _cairo_pdf_surface_get_extents, - NULL, /* old_show_glyphs */ _cairo_pdf_surface_get_font_options, + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ /* Here are the drawing functions */ - _cairo_pdf_surface_paint, _cairo_pdf_surface_mask, _cairo_pdf_surface_stroke, _cairo_pdf_surface_fill, - NULL, /* show_glyphs */ - NULL, /* snapshot */ - - NULL, /* is_compatible */ _cairo_pdf_surface_fill_stroke, - NULL, /* create_solid_pattern_surface */ - NULL, /* can_repaint_solid_pattern_surface */ + NULL, /* show_glyphs */ _cairo_pdf_surface_has_show_text_glyphs, _cairo_pdf_surface_show_text_glyphs, }; diff --git a/src/cairo-polygon-intersect.c b/src/cairo-polygon-intersect.c index e2ed6e97..d9d0cf26 100644 --- a/src/cairo-polygon-intersect.c +++ b/src/cairo-polygon-intersect.c @@ -1454,13 +1454,78 @@ _cairo_polygon_intersect (cairo_polygon_t *a, int winding_a, } assert (j == num_events); - //fprintf(stderr, "a "); _cairo_debug_print_polygon(stderr,a); - //fprintf(stderr, "b "); _cairo_debug_print_polygon(stderr,b); +#if 0 + { + FILE *file = fopen ("clip_a.txt", "w"); + _cairo_debug_print_polygon (file, a); + fclose (file); + } + { + FILE *file = fopen ("clip_b.txt", "w"); + _cairo_debug_print_polygon (file, b); + fclose (file); + } +#endif a->num_edges = 0; status = intersection_sweep (event_ptrs, num_events, a); if (events != stack_events) free (events); +#if 0 + { + FILE *file = fopen ("clip_result.txt", "w"); + _cairo_debug_print_polygon (file, a); + fclose (file); + } +#endif + + return status; +} + +cairo_status_t +_cairo_polygon_intersect_with_boxes (cairo_polygon_t *polygon, + cairo_fill_rule_t *winding, + cairo_box_t *boxes, + int num_boxes) +{ + cairo_polygon_t b; + cairo_status_t status; + int n; + + if (num_boxes == 0) { + polygon->num_edges = 0; + return CAIRO_STATUS_SUCCESS; + } + + for (n = 0; n < num_boxes; n++) { + if (polygon->extents.p1.x >= boxes[n].p1.x && + polygon->extents.p2.x <= boxes[n].p2.x && + polygon->extents.p1.y >= boxes[n].p1.y && + polygon->extents.p2.y <= boxes[n].p2.y) + { + return CAIRO_STATUS_SUCCESS; + } + } + + _cairo_polygon_init (&b, NULL, 0); + for (n = 0; n < num_boxes; n++) { + cairo_point_t p1, p2; + + p1.y = boxes[n].p1.y; + p2.y = boxes[n].p2.y; + + p2.x = p1.x = boxes[n].p1.x; + _cairo_polygon_add_external_edge (&b, &p1, &p2); + + p2.x = p1.x = boxes[n].p2.x; + _cairo_polygon_add_external_edge (&b, &p2, &p1); + } + + status = _cairo_polygon_intersect (polygon, *winding, + &b, CAIRO_FILL_RULE_WINDING); + _cairo_polygon_fini (&b); + + *winding = CAIRO_FILL_RULE_WINDING; return status; } diff --git a/src/cairo-polygon.c b/src/cairo-polygon.c index 6436712b..a44cba3f 100644 --- a/src/cairo-polygon.c +++ b/src/cairo-polygon.c @@ -127,19 +127,19 @@ _cairo_polygon_init_boxes (cairo_polygon_t *polygon, polygon->num_limits = 0; for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { - for (i = 0; i < chunk->count; i++) { - cairo_point_t p1, p2; - - p1 = chunk->base[i].p1; - p2.x = p1.x; - p2.y = chunk->base[i].p2.y; - _cairo_polygon_add_edge (polygon, &p1, &p2, 1); - - p1 = chunk->base[i].p2; - p2.x = p1.x; - p2.y = chunk->base[i].p1.y; - _cairo_polygon_add_edge (polygon, &p1, &p2, 1); - } + for (i = 0; i < chunk->count; i++) { + cairo_point_t p1, p2; + + p1 = chunk->base[i].p1; + p2.x = p1.x; + p2.y = chunk->base[i].p2.y; + _cairo_polygon_add_edge (polygon, &p1, &p2, 1); + + p1 = chunk->base[i].p2; + p2.x = p1.x; + p2.y = chunk->base[i].p1.y; + _cairo_polygon_add_edge (polygon, &p1, &p2, 1); + } } return polygon->status; @@ -491,3 +491,29 @@ _cairo_polygon_add_contour (cairo_polygon_t *polygon, return polygon->status; } + +void +_cairo_polygon_translate (cairo_polygon_t *polygon, int dx, int dy) +{ + int n; + + dx = _cairo_fixed_from_int (dx); + dy = _cairo_fixed_from_int (dy); + + polygon->extents.p1.x += dx; + polygon->extents.p2.x += dx; + polygon->extents.p1.y += dy; + polygon->extents.p2.y += dy; + + for (n = 0; n < polygon->num_edges; n++) { + cairo_edge_t *e = &polygon->edges[n]; + + e->top += dy; + e->bottom += dy; + + e->line.p1.x += dx; + e->line.p2.x += dx; + e->line.p1.y += dy; + e->line.p2.y += dy; + } +} diff --git a/src/cairo-ps-surface.c b/src/cairo-ps-surface.c index a8048871..dcd21612 100644 --- a/src/cairo-ps-surface.c +++ b/src/cairo-ps-surface.c @@ -55,10 +55,14 @@ #define _BSD_SOURCE /* for ctime_r(), snprintf(), strdup() */ #include "cairoint.h" + #include "cairo-ps.h" #include "cairo-ps-surface-private.h" + #include "cairo-pdf-operators-private.h" #include "cairo-pdf-shading-private.h" + +#include "cairo-array-private.h" #include "cairo-composite-rectangles-private.h" #include "cairo-default-context-private.h" #include "cairo-error-private.h" @@ -79,7 +83,7 @@ #include <zlib.h> #include <errno.h> -#define DEBUG_PS 0 +#define DEBUG_PS 1 #if DEBUG_PS #define DEBUG_FALLBACK(s) \ @@ -1153,41 +1157,40 @@ _extract_ps_surface (cairo_surface_t *surface, cairo_ps_surface_t **ps_surface) { cairo_surface_t *target; - cairo_status_t status_ignored; if (surface->status) return FALSE; if (surface->finished) { if (set_error_on_failure) - status_ignored = _cairo_surface_set_error (surface, - _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); + _cairo_surface_set_error (surface, + _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); return FALSE; } if (! _cairo_surface_is_paginated (surface)) { if (set_error_on_failure) - status_ignored = _cairo_surface_set_error (surface, - _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); + _cairo_surface_set_error (surface, + _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); return FALSE; } target = _cairo_paginated_surface_get_target (surface); if (target->status) { if (set_error_on_failure) - status_ignored = _cairo_surface_set_error (surface, target->status); + _cairo_surface_set_error (surface, target->status); return FALSE; } if (target->finished) { if (set_error_on_failure) - status_ignored = _cairo_surface_set_error (surface, - _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); + _cairo_surface_set_error (surface, + _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); return FALSE; } if (! _cairo_surface_is_ps (target)) { if (set_error_on_failure) - status_ignored = _cairo_surface_set_error (surface, - _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); + _cairo_surface_set_error (surface, + _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); return FALSE; } @@ -1783,7 +1786,7 @@ mask_supported (cairo_ps_surface_t *surface, const cairo_pattern_t *mask) cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) mask; if (surface_pattern->surface->type == CAIRO_SURFACE_TYPE_IMAGE) { /* check if mask if opaque or bilevel alpha */ - if (_cairo_ps_surface_analyze_surface_pattern_transparency (surface, surface_pattern) == CAIRO_STATUS_SUCCESS) { + if (_cairo_ps_surface_analyze_surface_pattern_transparency (surface, surface_pattern) == CAIRO_INT_STATUS_SUCCESS) { surface->ps_level_used = CAIRO_PS_LEVEL_3; return TRUE; } @@ -3780,17 +3783,18 @@ _cairo_ps_surface_paint (void *abstract_surface, cairo_ps_surface_t *surface = abstract_surface; cairo_output_stream_t *stream = surface->stream; cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_status_t status; - _cairo_ps_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_paint (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_paint (&extents, + &surface->base, op, source, clip); if (unlikely (status)) return status; - if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) - return _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded); + if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) { + status = _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded); + goto cleanup_composite; + } assert (_cairo_ps_surface_operation_supported (surface, op, source, NULL, &extents.bounded)); @@ -3801,7 +3805,7 @@ _cairo_ps_surface_paint (void *abstract_surface, status = _cairo_ps_surface_set_clip (surface, &extents); if (unlikely (status)) - return status; + goto cleanup_composite; if (source->type == CAIRO_PATTERN_TYPE_SURFACE && (source->extend == CAIRO_EXTEND_NONE || @@ -3809,26 +3813,28 @@ _cairo_ps_surface_paint (void *abstract_surface, { status = _cairo_pdf_operators_flush (&surface->pdf_operators); if (unlikely (status)) - return status; + goto cleanup_composite; _cairo_output_stream_printf (stream, "q\n"); status = _cairo_ps_surface_paint_surface (surface, (cairo_surface_pattern_t *) source, &extents.bounded, op, FALSE); if (unlikely (status)) - return status; + goto cleanup_composite; _cairo_output_stream_printf (stream, "Q\n"); } else { status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op); if (unlikely (status)) - return status; + goto cleanup_composite; _cairo_output_stream_printf (stream, "0 0 %f %f rectfill\n", surface->width, surface->height); } - return CAIRO_STATUS_SUCCESS; +cleanup_composite: + _cairo_composite_rectangles_fini (&extents); + return status; } static cairo_int_status_t @@ -3841,17 +3847,18 @@ _cairo_ps_surface_mask (void *abstract_surface, cairo_ps_surface_t *surface = abstract_surface; cairo_output_stream_t *stream = surface->stream; cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_status_t status; - _cairo_ps_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_mask (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_mask (&extents, + &surface->base, op, source, mask, clip); if (unlikely (status)) return status; - if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) - return _cairo_ps_surface_analyze_operation (surface, op, source, mask, &extents.bounded); + if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) { + status = _cairo_ps_surface_analyze_operation (surface, op, source, mask, &extents.bounded); + goto cleanup_composite; + } assert (_cairo_ps_surface_operation_supported (surface, op, source, mask, &extents.bounded)); @@ -3862,22 +3869,24 @@ _cairo_ps_surface_mask (void *abstract_surface, status = _cairo_ps_surface_set_clip (surface, &extents); if (unlikely (status)) - return status; + goto cleanup_composite; status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op); if (unlikely (status)) - return status; + goto cleanup_composite; _cairo_output_stream_printf (stream, "q\n"); status = _cairo_ps_surface_paint_surface (surface, (cairo_surface_pattern_t *) mask, &extents.bounded, op, TRUE); if (unlikely (status)) - return status; + goto cleanup_composite; _cairo_output_stream_printf (stream, "Q\n"); - return CAIRO_STATUS_SUCCESS; +cleanup_composite: + _cairo_composite_rectangles_fini (&extents); + return status; } static cairo_int_status_t @@ -3894,11 +3903,10 @@ _cairo_ps_surface_stroke (void *abstract_surface, { cairo_ps_surface_t *surface = abstract_surface; cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_int_status_t status; - _cairo_ps_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_stroke (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_stroke (&extents, + &surface->base, op, source, path, style, ctm, clip); @@ -3906,21 +3914,27 @@ _cairo_ps_surface_stroke (void *abstract_surface, return status; /* use the more accurate extents */ - if (extents.is_bounded) { + { + cairo_rectangle_int_t r; + cairo_box_t b; + status = _cairo_path_fixed_stroke_extents (path, style, ctm, ctm_inverse, tolerance, - &extents.mask); + &r); if (unlikely (status)) - return status; + goto cleanup_composite; - if (! _cairo_rectangle_intersect (&extents.bounded, &extents.mask)) - return CAIRO_STATUS_SUCCESS; + _cairo_box_from_rectangle (&b, &r); + status = _cairo_composite_rectangles_intersect_mask_extents (&extents, &b); + if (unlikely (status)) + goto cleanup_composite; } - - if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) - return _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded); + if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) { + status = _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded); + goto cleanup_composite; + } assert (_cairo_ps_surface_operation_supported (surface, op, source, NULL, &extents.bounded)); @@ -3931,17 +3945,21 @@ _cairo_ps_surface_stroke (void *abstract_surface, status = _cairo_ps_surface_set_clip (surface, &extents); if (unlikely (status)) - return status; + goto cleanup_composite; status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op); if (unlikely (status)) - return status; + goto cleanup_composite; + + status = _cairo_pdf_operators_stroke (&surface->pdf_operators, + path, + style, + ctm, + ctm_inverse); - return _cairo_pdf_operators_stroke (&surface->pdf_operators, - path, - style, - ctm, - ctm_inverse); +cleanup_composite: + _cairo_composite_rectangles_fini (&extents); + return status; } static cairo_int_status_t @@ -3956,29 +3974,35 @@ _cairo_ps_surface_fill (void *abstract_surface, { cairo_ps_surface_t *surface = abstract_surface; cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_int_status_t status; - _cairo_ps_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_fill (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_fill (&extents, + &surface->base, op, source, path, clip); if (unlikely (status)) return status; /* use the more accurate extents */ - if (extents.is_bounded) { + { + cairo_rectangle_int_t r; + cairo_box_t b; + _cairo_path_fixed_fill_extents (path, fill_rule, tolerance, - &extents.mask); + &r); - if (! _cairo_rectangle_intersect (&extents.bounded, &extents.mask)) - return CAIRO_STATUS_SUCCESS; + _cairo_box_from_rectangle (&b, &r); + status = _cairo_composite_rectangles_intersect_mask_extents (&extents, &b); + if (unlikely (status)) + goto cleanup_composite; } - if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) - return _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded); + if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) { + status = _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded); + goto cleanup_composite; + } assert (_cairo_ps_surface_operation_supported (surface, op, source, NULL, &extents.bounded)); @@ -3989,11 +4013,11 @@ _cairo_ps_surface_fill (void *abstract_surface, status = _cairo_pdf_operators_flush (&surface->pdf_operators); if (unlikely (status)) - return status; + goto cleanup_composite; status = _cairo_ps_surface_set_clip (surface, &extents); if (unlikely (status)) - return status; + goto cleanup_composite; if (source->type == CAIRO_PATTERN_TYPE_SURFACE && (source->extend == CAIRO_EXTEND_NONE || @@ -4005,26 +4029,28 @@ _cairo_ps_surface_fill (void *abstract_surface, path, fill_rule); if (unlikely (status)) - return status; + goto cleanup_composite; status = _cairo_ps_surface_paint_surface (surface, (cairo_surface_pattern_t *) source, &extents.bounded, op, FALSE); if (unlikely (status)) - return status; + goto cleanup_composite; _cairo_output_stream_printf (surface->stream, "Q\n"); _cairo_pdf_operators_reset (&surface->pdf_operators); } else { status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op); if (unlikely (status)) - return status; + goto cleanup_composite; status = _cairo_pdf_operators_fill (&surface->pdf_operators, path, fill_rule); } +cleanup_composite: + _cairo_composite_rectangles_fini (&extents); return status; } @@ -4050,26 +4076,23 @@ _cairo_ps_surface_show_text_glyphs (void *abstract_surface, { cairo_ps_surface_t *surface = abstract_surface; cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_bool_t overlap; cairo_status_t status; - _cairo_ps_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_glyphs (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_glyphs (&extents, + &surface->base, op, source, scaled_font, glyphs, num_glyphs, clip, &overlap); - if (unlikely (status)) { - if (status == CAIRO_INT_STATUS_NOTHING_TO_DO) - return CAIRO_INT_STATUS_SUCCESS; - + if (unlikely (status)) return status; - } - if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) - return _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded); + if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) { + status = _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded); + goto cleanup_composite; + } assert (_cairo_ps_surface_operation_supported (surface, op, source, NULL, &extents.bounded)); @@ -4080,18 +4103,22 @@ _cairo_ps_surface_show_text_glyphs (void *abstract_surface, status = _cairo_ps_surface_set_clip (surface, &extents); if (unlikely (status)) - return status; + goto cleanup_composite; status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op); if (unlikely (status)) - return status; + goto cleanup_composite; + + status = _cairo_pdf_operators_show_text_glyphs (&surface->pdf_operators, + utf8, utf8_len, + glyphs, num_glyphs, + clusters, num_clusters, + cluster_flags, + scaled_font); - return _cairo_pdf_operators_show_text_glyphs (&surface->pdf_operators, - utf8, utf8_len, - glyphs, num_glyphs, - clusters, num_clusters, - cluster_flags, - scaled_font); +cleanup_composite: + _cairo_composite_rectangles_fini (&extents); + return status; } static void @@ -4222,23 +4249,16 @@ static const cairo_surface_backend_t cairo_ps_surface_backend = { NULL, /* acquire_source_image */ NULL, /* release_source_image */ - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + NULL, /* snapshot */ + NULL, /* cairo_ps_surface_copy_page */ _cairo_ps_surface_show_page, + _cairo_ps_surface_get_extents, - NULL, /* old_show_glyphs */ _cairo_ps_surface_get_font_options, + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ /* Here are the drawing functions */ @@ -4246,13 +4266,8 @@ static const cairo_surface_backend_t cairo_ps_surface_backend = { _cairo_ps_surface_mask, _cairo_ps_surface_stroke, _cairo_ps_surface_fill, + NULL, /* fill-stroke */ NULL, /* show_glyphs */ - NULL, /* snapshot */ - - NULL, /* is_compatible */ - NULL, /* fill_stroke */ - NULL, /* create_solid_pattern_surface */ - NULL, /* can_repaint_solid_pattern_surface */ _cairo_ps_surface_has_show_text_glyphs, _cairo_ps_surface_show_text_glyphs, }; diff --git a/src/cairo-quartz-image-surface.c b/src/cairo-quartz-image-surface.c index bbe5fa7e..b04c4213 100644 --- a/src/cairo-quartz-image-surface.c +++ b/src/cairo-quartz-image-surface.c @@ -60,13 +60,22 @@ _cairo_quartz_image_surface_create_similar (void *asurface, int width, int height) { - cairo_surface_t *result; cairo_surface_t *isurf = _cairo_image_surface_create_with_content (content, width, height); - if (cairo_surface_status(isurf)) - return isurf; + cairo_surface_t *result = cairo_quartz_image_surface_create (isurf); + cairo_surface_destroy (isurf); - result = cairo_quartz_image_surface_create (isurf); + return result; +} + +static cairo_surface_t * +_cairo_quartz_image_surface_create_similar_image (void *asurface, + cairo_format_t format, + int width, + int height) +{ + cairo_surface_t *isurf = cairo_image_surface_create (format, width, height); + cairo_surface_t *result = cairo_quartz_image_surface_create (isurf); cairo_surface_destroy (isurf); return result; @@ -96,23 +105,19 @@ _cairo_quartz_image_surface_acquire_source_image (void *asurface, return CAIRO_STATUS_SUCCESS; } -static cairo_status_t -_cairo_quartz_image_surface_acquire_dest_image (void *asurface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t **image_out, - cairo_rectangle_int_t *image_rect, - void **image_extra) +static cairo_surface_t * +_cairo_quartz_image_surface_map_to_image (void *asurface, + const cairo_rectangle_int_t *extents) { cairo_quartz_image_surface_t *surface = (cairo_quartz_image_surface_t *) asurface; + return _cairo_surface_create_for_rectangle_int (surface->imageSurface, extents); +} - *image_out = surface->imageSurface; - image_rect->x = 0; - image_rect->y = 0; - image_rect->width = surface->width; - image_rect->height = surface->height; - *image_extra = NULL; - - return CAIRO_STATUS_SUCCESS; +static cairo_int_status_t +_cairo_quartz_image_surface_unmap_image (void *asurface, + cairo_image_surface_t *image) +{ + cairo_surface_destroy (&image->base); } static cairo_bool_t @@ -123,7 +128,7 @@ _cairo_quartz_image_surface_get_extents (void *asurface, extents->x = 0; extents->y = 0; - extents->width = surface->width; + extents->width = surface->width; extents->height = surface->height; return TRUE; } @@ -139,6 +144,8 @@ _cairo_quartz_image_surface_flush (void *asurface) CGImageRef oldImage = surface->image; CGImageRef newImage = NULL; + /* XXX only flush if the image has been modified. */ + /* To be released by the ReleaseCallback */ cairo_surface_reference ((cairo_surface_t*) surface->imageSurface); @@ -158,6 +165,82 @@ _cairo_quartz_image_surface_flush (void *asurface) return CAIRO_STATUS_SUCCESS; } +static cairo_int_status_t +_cairo_quartz_image_surface_paint (void *abstract_surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_clip_t *clip) +{ + cairo_quartz_image_surface_t *surface = abstract_surface; + return _cairo_surface_paint (&surface->imageSurface->base, + op, source, clip); +} + +static cairo_int_status_t +_cairo_quartz_image_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_quartz_image_surface_t *surface = abstract_surface; + return _cairo_surface_mask (&surface->imageSurface->base, + op, source, mask, clip); +} + +static cairo_int_status_t +_cairo_quartz_image_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_quartz_image_surface_t *surface = abstract_surface; + return _cairo_surface_stroke (&surface->imageSurface->base, + op, source, path, + style, ctm, ctm_inverse, + tolerance, antialias, clip); +} + +static cairo_int_status_t +_cairo_quartz_image_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_quartz_image_surface_t *surface = abstract_surface; + return _cairo_surface_fill (&surface->imageSurface->base, + op, source, path, + fill_rule, tolerance, antialias, + clip); +} + +static cairo_int_status_t +_cairo_quartz_image_surface_glyphs (void *abstract_surface, + cairo_operator_t op, + const cairo_pattern_t *source, + cairo_glyph_t *glyphs, + int num_glyphs, + cairo_scaled_font_t *scaled_font, + const cairo_clip_t *clip) +{ + cairo_quartz_image_surface_t *surface = abstract_surface; + return _cairo_surface_show_glyphs (&surface->imageSurface->base, + op, source, + glyphs, num_glyphs, scaled_font, + clip, num_remaining); +} + + static const cairo_surface_backend_t cairo_quartz_image_surface_backend = { CAIRO_SURFACE_TYPE_QUARTZ_IMAGE, _cairo_quartz_image_surface_finish, @@ -165,39 +248,29 @@ static const cairo_surface_backend_t cairo_quartz_image_surface_backend = { _cairo_default_context_create, _cairo_quartz_image_surface_create_similar, - NULL, /* create_similar_image */ - NULL, /* map_to_image */ - NULL, /* unmap_image */ + _cairo_quartz_image_surface_create_similar_image, + _cairo_quartz_image_surface_map_to_image, + _cairo_quartz_image_surface_unmap_image, _cairo_quartz_image_surface_acquire_source_image, NULL, /* release_source_image */ - _cairo_quartz_image_surface_acquire_dest_image, - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + NULL, /* snapshot */ + NULL, /* copy_page */ NULL, /* show_page */ + _cairo_quartz_image_surface_get_extents, - NULL, /* old_show_glyphs */ NULL, /* get_font_options */ + _cairo_quartz_image_surface_flush, NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ - - NULL, /* paint */ - NULL, /* mask */ - NULL, /* stroke */ - NULL, /* fill */ - NULL, /* surface_show_glyphs */ - NULL, /* snapshot */ - NULL, /* is_similar */ - NULL /* fill_stroke */ + _cairo_quartz_image_surface_paint, + _cairo_quartz_image_surface_mask, + _cairo_quartz_image_surface_stroke, + _cairo_quartz_image_surface_fill, + NULL /* fill-stroke */ + _cairo_quartz_image_surface_glyphs, }; /** @@ -227,6 +300,9 @@ cairo_quartz_image_surface_create (cairo_surface_t *surface) cairo_format_t format; unsigned char *data; + if (surface->status) + return surface; + if (cairo_surface_get_type(surface) != CAIRO_SURFACE_TYPE_IMAGE) return SURFACE_ERROR_TYPE_MISMATCH; diff --git a/src/cairo-quartz-surface.c b/src/cairo-quartz-surface.c index 0f015c81..60ce8d17 100644 --- a/src/cairo-quartz-surface.c +++ b/src/cairo-quartz-surface.c @@ -39,10 +39,13 @@ #include "cairo-quartz-private.h" +#include "cairo-composite-rectangles-private.h" +#include "cairo-compositor-private.h" #include "cairo-default-context-private.h" #include "cairo-error-private.h" #include "cairo-image-surface-private.h" #include "cairo-pattern-private.h" +#include "cairo-surface-backend-private.h" #include "cairo-surface-clipper-private.h" #include <dlfcn.h> @@ -500,8 +503,7 @@ _cairo_cgcontext_set_cairo_operator (CGContextRef context, cairo_operator_t op) { CGBlendMode blendmode; - if (op == CAIRO_OPERATOR_DEST) - return CAIRO_INT_STATUS_NOTHING_TO_DO; + assert (op != CAIRO_OPERATOR_DEST); /* Quartz doesn't support SATURATE at all. COLOR_DODGE and * COLOR_BURN in Quartz follow the ISO32000 definition, but cairo @@ -538,8 +540,7 @@ _cairo_quartz_surface_set_cairo_operator (cairo_quartz_surface_t *surface, cairo * fallbacks, but we have to workaround operators which behave * differently in Quartz. */ if (surface->base.content == CAIRO_CONTENT_ALPHA) { - if (op == CAIRO_OPERATOR_ATOP) - return CAIRO_INT_STATUS_NOTHING_TO_DO; + assert (op != CAIRO_OPERATOR_ATOP); /* filtered by surface layer */ if (op == CAIRO_OPERATOR_SOURCE || op == CAIRO_OPERATOR_IN || @@ -794,7 +795,7 @@ _cairo_surface_to_cgimage (cairo_surface_t *source, cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *) source; if (IS_EMPTY (surface)) { *image_out = NULL; - return CAIRO_STATUS_SUCCESS; + return CAIRO_INT_STATUS_NOTHING_TO_DO; } if (_cairo_quartz_is_cgcontext_bitmap_context (surface->cgContext)) { @@ -924,8 +925,6 @@ _cairo_quartz_cairo_repeating_surface_pattern_to_quartz (cairo_quartz_surface_t status = _cairo_surface_to_cgimage (pat_surf, &image); if (unlikely (status)) return status; - if (unlikely (image == NULL)) - return CAIRO_INT_STATUS_NOTHING_TO_DO; info = malloc (sizeof (SurfacePatternDrawInfo)); if (unlikely (!info)) @@ -1082,11 +1081,12 @@ _cairo_quartz_setup_gradient_source (cairo_quartz_drawing_state_t *state, static cairo_int_status_t _cairo_quartz_setup_state (cairo_quartz_drawing_state_t *state, - cairo_quartz_surface_t *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_clip_t *clip) + cairo_composite_rectangles_int_t *extents) { + cairo_quartz_surface_t *surface = extents->surface; + cairo_operator_t op = extents->op; + const cairo_pattern_t *source = &extents->surface_pattern.base; + const cairo_clip_t *clip = extents->clip; cairo_bool_t needs_temp; cairo_status_t status; @@ -1205,8 +1205,6 @@ _cairo_quartz_setup_state (cairo_quartz_drawing_state_t *state, status = _cairo_surface_to_cgimage (pat_surf, &img); if (unlikely (status)) return status; - if (unlikely (img == NULL)) - return CAIRO_INT_STATUS_NOTHING_TO_DO; state->image = img; @@ -1318,8 +1316,10 @@ _cairo_quartz_setup_state (cairo_quartz_drawing_state_t *state, static void _cairo_quartz_teardown_state (cairo_quartz_drawing_state_t *state, - cairo_quartz_surface_t *surface) + cairo_composite_rectangles_int_t *extents) { + cairo_quartz_surface_t *surfce = (cairo_quartz_surface_t *)extents; + if (state->layer) { CGContextDrawLayerInRect (surface->cgContext, state->clipRect, @@ -1383,7 +1383,6 @@ _cairo_quartz_draw_source (cairo_quartz_drawing_state_t *state, } } - /* * get source/dest image implementation */ @@ -1552,39 +1551,28 @@ _cairo_quartz_surface_release_source_image (void *abstract_surface, } -static cairo_status_t -_cairo_quartz_surface_acquire_dest_image (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t **image_out, - cairo_rectangle_int_t *image_rect, - void **image_extra) +static cairo_surface_t * +_cairo_quartz_surface_map_to_image (void *abstract_surface, + const cairo_rectangle_int_t *extents) { cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface; - cairo_int_status_t status; - - ND ((stderr, "%p _cairo_quartz_surface_acquire_dest_image\n", surface)); + cairo_image_surface_t *image; + cairo_surface_t *surface; - status = _cairo_quartz_get_image (surface, image_out); + status = _cairo_quartz_get_image (surface, &image); if (unlikely (status)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); + return _cairo_surace_create_in_error (status); - *image_rect = surface->extents; - *image_extra = NULL; + surface = _cairo_surface_create_for_rectangle_int (&image->base, extents); + cairo_surface_destroy (&image->base); - return CAIRO_STATUS_SUCCESS; + return surface; } -static void -_cairo_quartz_surface_release_dest_image (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t *image, - cairo_rectangle_int_t *image_rect, - void *image_extra) +static cairo_int_status_t +_cairo_quartz_surface_unmap_image (void *abstract_surface, + cairo_image_surface_t *image) { - //cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface; - - //ND ((stderr, "%p _cairo_quartz_surface_release_dest_image\n", surface)); - cairo_surface_destroy (&image->base); } @@ -1624,173 +1612,218 @@ _cairo_quartz_surface_create_similar (void *abstract_surface, return similar; } -static cairo_status_t -_cairo_quartz_surface_clone_similar (void *abstract_surface, - cairo_surface_t *src, - int src_x, - int src_y, - int width, - int height, - int *clone_offset_x, - int *clone_offset_y, - cairo_surface_t **clone_out) +static cairo_bool_t +_cairo_quartz_surface_get_extents (void *abstract_surface, + cairo_rectangle_int_t *extents) { - cairo_quartz_surface_t *new_surface = NULL; - cairo_format_t new_format; - CGImageRef quartz_image = NULL; - cairo_status_t status; + cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface; - *clone_out = NULL; + *extents = surface->extents; + return TRUE; +} - // verify width and height of surface - if (!_cairo_quartz_verify_surface_size (width, height)) - return CAIRO_INT_STATUS_UNSUPPORTED; +static cairo_int_status_t +_cairo_quartz_cg_paint (const cairo_compositor_t *compositor, + cairo_composite_rectangles_int_t *extents) +{ + cairo_quartz_drawing_state_t state; + cairo_int_status_t rv; - if (width == 0 || height == 0) { - *clone_out = &_cairo_quartz_surface_create_internal (NULL, CAIRO_CONTENT_COLOR_ALPHA, - width, height)->base; - *clone_offset_x = 0; - *clone_offset_y = 0; - return CAIRO_STATUS_SUCCESS; - } + ND ((stderr, "%p _cairo_quartz_surface_paint op %d source->type %d\n", surface, op, source->type)); - if (_cairo_surface_is_quartz (src)) { - cairo_quartz_surface_t *qsurf = (cairo_quartz_surface_t *) src; + rv = _cairo_quartz_setup_state (&state, extents); + if (unlikely (rv)) + goto BAIL; - if (IS_EMPTY (qsurf)) { - *clone_out = &_cairo_quartz_surface_create_internal (NULL, - CAIRO_CONTENT_COLOR_ALPHA, - qsurf->extents.width, - qsurf->extents.height)->base; - *clone_offset_x = 0; - *clone_offset_y = 0; - return CAIRO_STATUS_SUCCESS; - } - } + _cairo_quartz_draw_source (&state, extents->op); + +BAIL: + _cairo_quartz_teardown_state (&state, extents); + + ND ((stderr, "-- paint\n")); + return rv; +} - status = _cairo_surface_to_cgimage (src, &quartz_image); +static cairo_int_status_t +_cairo_quartz_cg_mask_with_surface (cairo_composite_extents_t *extents, + cairo_surface_t *mask_surf, + const cairo_matrix_t *mask_mat, + CGInterpolationQuality filter) +{ + cairo_quartz_surface_t *surface = extents->surface; + cairo_operator_t op = extents->op; + const cairo_pattern_t *source = &extents->surface_pattern.base; + cairo_clip_t *clip = extents->clip; + CGRect rect; + CGImageRef img; + cairo_status_t status; + CGAffineTransform mask_matrix; + cairo_quartz_drawing_state_t state; + + status = _cairo_surface_to_cgimage (mask_surf, &img); if (unlikely (status)) - return CAIRO_INT_STATUS_UNSUPPORTED; + return status; - new_format = CAIRO_FORMAT_ARGB32; /* assumed */ - if (_cairo_surface_is_image (src)) - new_format = ((cairo_image_surface_t *) src)->format; + status = _cairo_quartz_setup_state (&state, extents); + if (unlikely (status)) + goto BAIL; - new_surface = (cairo_quartz_surface_t *) - cairo_quartz_surface_create (new_format, width, height); + rect = CGRectMake (0.0, 0.0, CGImageGetWidth (img), CGImageGetHeight (img)); + _cairo_quartz_cairo_matrix_to_quartz (mask_mat, &mask_matrix); - if (quartz_image == NULL) - goto FINISH; + /* ClipToMask is essentially drawing an image, so we need to flip the CTM + * to get the image to appear oriented the right way */ + CGContextConcatCTM (state.cgMaskContext, CGAffineTransformInvert (mask_matrix)); + CGContextTranslateCTM (state.cgMaskContext, 0.0, rect.size.height); + CGContextScaleCTM (state.cgMaskContext, 1.0, -1.0); - if (!new_surface || new_surface->base.status) { - CGImageRelease (quartz_image); - return CAIRO_INT_STATUS_UNSUPPORTED; - } + state.filter = filter; - CGContextSaveGState (new_surface->cgContext); + CGContextSetInterpolationQuality (state.cgMaskContext, filter); + CGContextSetShouldAntialias (state.cgMaskContext, filter != kCGInterpolationNone); - _cairo_quartz_surface_set_cairo_operator (new_surface, CAIRO_OPERATOR_SOURCE); + CGContextClipToMask (state.cgMaskContext, rect, img); - CGContextTranslateCTM (new_surface->cgContext, -src_x, -src_y); - CGContextDrawImage (new_surface->cgContext, - CGRectMake (0, 0, CGImageGetWidth (quartz_image), CGImageGetHeight (quartz_image)), - quartz_image); + CGContextScaleCTM (state.cgMaskContext, 1.0, -1.0); + CGContextTranslateCTM (state.cgMaskContext, 0.0, -rect.size.height); + CGContextConcatCTM (state.cgMaskContext, mask_matrix); - CGContextRestoreGState (new_surface->cgContext); + _cairo_quartz_draw_source (&state, extents->op); - CGImageRelease (quartz_image); +BAIL: + _cairo_quartz_teardown_state (&state, extents); -FINISH: - *clone_offset_x = src_x; - *clone_offset_y = src_y; - *clone_out = &new_surface->base; + CGImageRelease (img); - return CAIRO_STATUS_SUCCESS; + return status; } -static cairo_bool_t -_cairo_quartz_surface_get_extents (void *abstract_surface, - cairo_rectangle_int_t *extents) +static cairo_int_status_t +_cairo_quartz_cg_mask_with_solid (cairo_quartz_surface_t *surface, + cairo_composite_rectangles_t *extents) { - cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface; + cairo_quartz_drawing_state_t state; + double alpha = extents->mask_pattern.solid.color.alpha; + cairo_status_t status; - *extents = surface->extents; - return TRUE; + status = _cairo_quartz_setup_state (&state, extents); + if (unlikely (status)) + return status; + + CGContextSetAlpha (surface->cgContext, alpha); + _cairo_quartz_draw_source (&state, extents->op); + + _cairo_quartz_teardown_state (&state, extents); + + return CAIRO_STATUS_SUCCESS; } static cairo_int_status_t -_cairo_quartz_surface_paint_cg (cairo_quartz_surface_t *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_clip_t *clip) +_cairo_quartz_cg_mask (const cairo_compositor_t *compositor, + cairo_composite_rectangles_int_t *extents) { - cairo_quartz_drawing_state_t state; - cairo_int_status_t rv = CAIRO_STATUS_SUCCESS; + cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *)extents->surface; + cairo_operator_t op = extents->op; + const cairo_pattern_t *source = &extents->source_pattern.base; + const cairo_pattern_t *mask = &extents->mask_pattern.base; + cairo_surface_t *mask_surf; + cairo_matrix_t matrix; + cairo_status_t status; + cairo_bool_t need_temp; + CGInterpolationQuality filter; - ND ((stderr, "%p _cairo_quartz_surface_paint op %d source->type %d\n", surface, op, source->type)); + ND ((stderr, "%p _cairo_quartz_surface_mask op %d source->type %d mask->type %d\n", surface, op, source->type, mask->type)); - if (IS_EMPTY (surface)) - return CAIRO_INT_STATUS_NOTHING_TO_DO; + if (mask->type == CAIRO_PATTERN_TYPE_SOLID) + return _cairo_quartz_cg_mask_with_solid (surface, extents); - rv = _cairo_quartz_setup_state (&state, surface, op, source, clip); - if (unlikely (rv)) - goto BAIL; + need_temp = (mask->type != CAIRO_PATTERN_TYPE_SURFACE || + mask->extend != CAIRO_EXTEND_NONE); - _cairo_quartz_draw_source (&state, op); + filter = _cairo_quartz_filter_to_quartz (source->filter); -BAIL: - _cairo_quartz_teardown_state (&state, surface); + if (! need_temp) { + mask_surf = extents->mask_pattern.surface.surface; - ND ((stderr, "-- paint\n")); - return rv; -} + /* When an opaque surface used as a mask in Quartz, its + * luminosity is used as the alpha value, so we con only use + * surfaces with alpha without creating a temporary mask. */ + need_temp = ! (mask_surf->content & CAIRO_CONTENT_ALPHA); + } -static cairo_int_status_t -_cairo_quartz_surface_paint (void *abstract_surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_clip_t *clip) -{ - cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface; - cairo_int_status_t rv; - cairo_image_surface_t *image; + if (! need_temp) { + CGInterpolationQuality mask_filter; + cairo_bool_t simple_transform; - rv = _cairo_quartz_surface_paint_cg (surface, - op, - source, - clip); + matrix = mask->matrix; - if (likely (rv != CAIRO_INT_STATUS_UNSUPPORTED)) - return rv; + mask_filter = _cairo_quartz_filter_to_quartz (mask->filter); + if (mask_filter == kCGInterpolationNone) { + simple_transform = _cairo_matrix_is_translation (&matrix); + if (simple_transform) { + matrix.x0 = ceil (matrix.x0 - 0.5); + matrix.y0 = ceil (matrix.y0 - 0.5); + } + } else { + simple_transform = _cairo_matrix_is_integer_translation (&matrix, + NULL, + NULL); + } - rv = _cairo_quartz_get_image (surface, &image); - if (likely (rv == CAIRO_STATUS_SUCCESS)) { - rv = _cairo_surface_paint (&image->base, op, source, clip); - cairo_surface_destroy (&image->base); + /* Quartz only allows one interpolation to be set for mask and + * source, so we can skip the temp surface only if the source + * filtering makes the mask look correct. */ + if (source->type == CAIRO_PATTERN_TYPE_SURFACE) + need_temp = ! (simple_transform || filter == mask_filter); + else + filter = mask_filter; } - return rv; + if (need_temp) { + /* Render the mask to a surface */ + mask_surf = _cairo_quartz_surface_create_similar (surface, + CAIRO_CONTENT_ALPHA, + surface->extents.width, + surface->extents.height); + status = mask_surf->status; + if (unlikely (status)) + goto BAIL; + + /* mask_surf is clear, so use OVER instead of SOURCE to avoid a + * temporary layer or fallback to cairo-image. */ + status = _cairo_surface_paint (mask_surf, CAIRO_OPERATOR_OVER, mask, NULL); + if (unlikely (status)) + goto BAIL; + + cairo_matrix_init_identity (&matrix); + } + + status = _cairo_quartz_cg_mask_with_surface (extents, + mask_surf, &matrix, filter); + +BAIL: + + if (need_temp) + cairo_surface_destroy (mask_surf); + + return status; } static cairo_int_status_t -_cairo_quartz_surface_fill_cg (cairo_quartz_surface_t *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_quartz_cg_fill (const cairo_compositor_t *compositor, + cairo_composite_rectangles_int_t *extents, + const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + cairo_antialias_t antialias) { + cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *)extents->surface; cairo_quartz_drawing_state_t state; cairo_int_status_t rv = CAIRO_STATUS_SUCCESS; ND ((stderr, "%p _cairo_quartz_surface_fill op %d source->type %d\n", surface, op, source->type)); - if (IS_EMPTY (surface)) - return CAIRO_INT_STATUS_NOTHING_TO_DO; - - rv = _cairo_quartz_setup_state (&state, surface, op, source, clip); + rv = _cairo_quartz_setup_state (&state, extents); if (unlikely (rv)) goto BAIL; @@ -1810,75 +1843,34 @@ _cairo_quartz_surface_fill_cg (cairo_quartz_surface_t *surface, else CGContextEOClip (state.cgMaskContext); - _cairo_quartz_draw_source (&state, op); + _cairo_quartz_draw_source (&state, extents->op); } BAIL: - _cairo_quartz_teardown_state (&state, surface); + _cairo_quartz_teardown_state (&state, extents); ND ((stderr, "-- fill\n")); return rv; } static cairo_int_status_t -_cairo_quartz_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_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface; - cairo_int_status_t rv; - cairo_image_surface_t *image; - - rv = _cairo_quartz_surface_fill_cg (surface, - op, - source, - path, - fill_rule, - tolerance, - antialias, - clip); - - if (likely (rv != CAIRO_INT_STATUS_UNSUPPORTED)) - return rv; - - rv = _cairo_quartz_get_image (surface, &image); - if (likely (rv == CAIRO_STATUS_SUCCESS)) { - rv = _cairo_surface_fill (&image->base, op, source, - path, fill_rule, tolerance, antialias, - clip); - cairo_surface_destroy (&image->base); - } - - return rv; -} - -static cairo_int_status_t -_cairo_quartz_surface_stroke_cg (cairo_quartz_surface_t *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_quartz_cg_stroke (const cairo_compositor_t *compositor, + cairo_composite_rectangles_int_t *extents, + 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) { + cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *)extents->surface; cairo_quartz_drawing_state_t state; cairo_int_status_t rv = CAIRO_STATUS_SUCCESS; CGAffineTransform strokeTransform, invStrokeTransform; ND ((stderr, "%p _cairo_quartz_surface_stroke op %d source->type %d\n", surface, op, source->type)); - if (IS_EMPTY (surface)) - return CAIRO_INT_STATUS_NOTHING_TO_DO; - - rv = _cairo_quartz_setup_state (&state, surface, op, source, clip); + rv = _cairo_quartz_setup_state (&state, extents); if (unlikely (rv)) goto BAIL; @@ -1930,63 +1922,26 @@ _cairo_quartz_surface_stroke_cg (cairo_quartz_surface_t *surface, _cairo_quartz_cairo_matrix_to_quartz (ctm_inverse, &invStrokeTransform); CGContextConcatCTM (state.cgMaskContext, invStrokeTransform); - _cairo_quartz_draw_source (&state, op); + _cairo_quartz_draw_source (&state, extents->op); } BAIL: - _cairo_quartz_teardown_state (&state, surface); + _cairo_quartz_teardown_state (&state, extents); ND ((stderr, "-- stroke\n")); return rv; } -static cairo_int_status_t -_cairo_quartz_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_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface; - cairo_int_status_t rv; - cairo_image_surface_t *image; - - rv = _cairo_quartz_surface_stroke_cg (surface, op, source, - path, style, ctm, ctm_inverse, - tolerance, antialias, - clip); - - if (likely (rv != CAIRO_INT_STATUS_UNSUPPORTED)) - return rv; - - rv = _cairo_quartz_get_image (surface, &image); - if (likely (rv == CAIRO_STATUS_SUCCESS)) { - rv = _cairo_surface_stroke (&image->base, op, source, - path, style, ctm, ctm_inverse, - tolerance, antialias, - clip); - cairo_surface_destroy (&image->base); - } - - return rv; -} - #if CAIRO_HAS_QUARTZ_FONT static cairo_int_status_t -_cairo_quartz_surface_show_glyphs_cg (cairo_quartz_surface_t *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, - int *remaining_glyphs) +_cairo_quartz_cg_glyphs (const cairo_compositor_t *compositor, + cairo_composite_rectangles_int_t *extents, + cairo_glyph_t *glyphs, + int num_glyphs, + cairo_scaled_font_t *scaled_font, + cairo_bool_t overlap) { + cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *)_surface; CGAffineTransform textTransform, invTextTransform; CGGlyph glyphs_static[CAIRO_STACK_ARRAY_LENGTH (CGSize)]; CGSize cg_advances_static[CAIRO_STACK_ARRAY_LENGTH (CGSize)]; @@ -1995,23 +1950,17 @@ _cairo_quartz_surface_show_glyphs_cg (cairo_quartz_surface_t *surface, COMPILE_TIME_ASSERT (sizeof (CGGlyph) <= sizeof (CGSize)); cairo_quartz_drawing_state_t state; - cairo_int_status_t rv = CAIRO_STATUS_SUCCESS; + cairo_int_status_t rv = CAIRO_INT_STATUS_UNSUPPORTED; cairo_quartz_float_t xprev, yprev; int i; CGFontRef cgfref = NULL; cairo_bool_t didForceFontSmoothing = FALSE; - if (IS_EMPTY (surface)) - return CAIRO_INT_STATUS_NOTHING_TO_DO; - - if (num_glyphs <= 0) - return CAIRO_INT_STATUS_NOTHING_TO_DO; - if (cairo_scaled_font_get_type (scaled_font) != CAIRO_FONT_TYPE_QUARTZ) return CAIRO_INT_STATUS_UNSUPPORTED; - rv = _cairo_quartz_setup_state (&state, surface, op, source, clip); + rv = _cairo_quartz_setup_state (&state, extents); if (unlikely (rv)) goto BAIL; @@ -2106,13 +2055,13 @@ _cairo_quartz_surface_show_glyphs_cg (cairo_quartz_surface_t *surface, CGContextTranslateCTM (state.cgMaskContext, -glyphs[0].x, -glyphs[0].y); if (state.action != DO_DIRECT) - _cairo_quartz_draw_source (&state, op); + _cairo_quartz_draw_source (&state, extents->op); BAIL: if (didForceFontSmoothing) CGContextSetAllowsFontSmoothingPtr (state.cgMaskContext, FALSE); - _cairo_quartz_teardown_state (&state, surface); + _cairo_quartz_teardown_state (&state, extents); if (cg_glyphs != glyphs_static) free (cg_glyphs); @@ -2121,254 +2070,90 @@ BAIL: } #endif /* CAIRO_HAS_QUARTZ_FONT */ -static cairo_int_status_t -_cairo_quartz_surface_show_glyphs (void *abstract_surface, - cairo_operator_t op, - const cairo_pattern_t *source, - cairo_glyph_t *glyphs, - int num_glyphs, - cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip, - int *remaining_glyphs) -{ - cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface; - cairo_int_status_t rv = CAIRO_INT_STATUS_UNSUPPORTED; - cairo_image_surface_t *image; +static const cairo_compositor_t _cairo_quartz_cg_compositor = { + &_cairo_fallback_compositor, + _cairo_quartz_cg_paint, + _cairo_quartz_cg_mask, + _cairo_quartz_cg_stroke, + _cairo_quartz_cg_fill, #if CAIRO_HAS_QUARTZ_FONT - rv = _cairo_quartz_surface_show_glyphs_cg (surface, op, source, - glyphs, num_glyphs, - scaled_font, clip, remaining_glyphs); - - if (likely (rv != CAIRO_INT_STATUS_UNSUPPORTED)) - return rv; - + _cairo_quartz_cg_glyphs, +#else + NULL, #endif +}; - rv = _cairo_quartz_get_image (surface, &image); - if (likely (rv == CAIRO_STATUS_SUCCESS)) { - rv = _cairo_surface_show_text_glyphs (&image->base, op, source, - NULL, 0, - glyphs, num_glyphs, - NULL, 0, 0, - scaled_font, clip); - cairo_surface_destroy (&image->base); - } - - return rv; +static cairo_int_status_t +_cairo_quartz_surface_paint (void *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_clip_t *clip) +{ + return _cairo_compositor_paint (&_cairo_quartz_cg_compositor, + surface, op, source, clip); } static cairo_int_status_t -_cairo_quartz_surface_mask_with_surface (cairo_quartz_surface_t *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - cairo_surface_t *mask_surf, - const cairo_matrix_t *mask_mat, - CGInterpolationQuality filter, - const cairo_clip_t *clip) +_cairo_quartz_surface_mask (void *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_pattern_t *mask, + const cairo_clip_t *clip) { - CGRect rect; - CGImageRef img; - cairo_status_t status = CAIRO_STATUS_SUCCESS; - CGAffineTransform mask_matrix; - cairo_quartz_drawing_state_t state; - - if (IS_EMPTY (surface)) - return CAIRO_INT_STATUS_NOTHING_TO_DO; - - status = _cairo_surface_to_cgimage (mask_surf, &img); - if (unlikely (status)) - return status; - - status = _cairo_quartz_setup_state (&state, surface, op, source, clip); - if (unlikely (status)) - goto BAIL; - - if (unlikely (img == NULL)) - goto BAIL; - - rect = CGRectMake (0.0, 0.0, CGImageGetWidth (img), CGImageGetHeight (img)); - _cairo_quartz_cairo_matrix_to_quartz (mask_mat, &mask_matrix); - - /* ClipToMask is essentially drawing an image, so we need to flip the CTM - * to get the image to appear oriented the right way */ - CGContextConcatCTM (state.cgMaskContext, CGAffineTransformInvert (mask_matrix)); - CGContextTranslateCTM (state.cgMaskContext, 0.0, rect.size.height); - CGContextScaleCTM (state.cgMaskContext, 1.0, -1.0); - - state.filter = filter; - - CGContextSetInterpolationQuality (state.cgMaskContext, filter); - CGContextSetShouldAntialias (state.cgMaskContext, filter != kCGInterpolationNone); - - CGContextClipToMask (state.cgMaskContext, rect, img); - - CGContextScaleCTM (state.cgMaskContext, 1.0, -1.0); - CGContextTranslateCTM (state.cgMaskContext, 0.0, -rect.size.height); - CGContextConcatCTM (state.cgMaskContext, mask_matrix); - - _cairo_quartz_draw_source (&state, op); - -BAIL: - _cairo_quartz_teardown_state (&state, surface); - - CGImageRelease (img); - - return status; + return _cairo_compositor_mask (&_cairo_quartz_cg_compositor, + surface, op, source, mask, + clip); } static cairo_int_status_t -_cairo_quartz_surface_mask_with_solid (cairo_quartz_surface_t *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - double alpha, - const cairo_clip_t *clip) +_cairo_quartz_surface_fill (void *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_quartz_drawing_state_t state; - cairo_status_t status; - - status = _cairo_quartz_setup_state (&state, surface, op, source, clip); - if (unlikely (status)) - goto BAIL; - - CGContextSetAlpha (surface->cgContext, alpha); - _cairo_quartz_draw_source (&state, op); - -BAIL: - _cairo_quartz_teardown_state (&state, surface); - - return status; + return _cairo_compositor_fill (&_cairo_quartz_cg_compositor, + surface, op, source, path, + fill_rule, tolerance, antialias, + clip); } static cairo_int_status_t -_cairo_quartz_surface_mask_cg (cairo_quartz_surface_t *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_pattern_t *mask, - const cairo_clip_t *clip) +_cairo_quartz_surface_stroke (void *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_surface_t *mask_surf; - cairo_matrix_t matrix; - cairo_status_t status; - cairo_bool_t need_temp; - CGInterpolationQuality filter; - - ND ((stderr, "%p _cairo_quartz_surface_mask op %d source->type %d mask->type %d\n", surface, op, source->type, mask->type)); - - if (IS_EMPTY (surface)) - return CAIRO_INT_STATUS_NOTHING_TO_DO; - - if (mask->type == CAIRO_PATTERN_TYPE_SOLID) { - const cairo_solid_pattern_t *mask_solid; - - mask_solid = (const cairo_solid_pattern_t *) mask; - return _cairo_quartz_surface_mask_with_solid (surface, op, source, - mask_solid->color.alpha, - clip); - } - - need_temp = (mask->type != CAIRO_PATTERN_TYPE_SURFACE || - mask->extend != CAIRO_EXTEND_NONE); - - filter = _cairo_quartz_filter_to_quartz (source->filter); - - if (! need_temp) { - mask_surf = ((const cairo_surface_pattern_t *) mask)->surface; - - /* When an opaque surface used as a mask in Quartz, its - * luminosity is used as the alpha value, so we con only use - * surfaces with alpha without creating a temporary mask. */ - need_temp = ! (mask_surf->content & CAIRO_CONTENT_ALPHA); - } - - if (! need_temp) { - CGInterpolationQuality mask_filter; - cairo_bool_t simple_transform; - - matrix = mask->matrix; - - mask_filter = _cairo_quartz_filter_to_quartz (mask->filter); - if (mask_filter == kCGInterpolationNone) { - simple_transform = _cairo_matrix_is_translation (&matrix); - if (simple_transform) { - matrix.x0 = ceil (matrix.x0 - 0.5); - matrix.y0 = ceil (matrix.y0 - 0.5); - } - } else { - simple_transform = _cairo_matrix_is_integer_translation (&matrix, - NULL, - NULL); - } - - /* Quartz only allows one interpolation to be set for mask and - * source, so we can skip the temp surface only if the source - * filtering makes the mask look correct. */ - if (source->type == CAIRO_PATTERN_TYPE_SURFACE) - need_temp = ! (simple_transform || filter == mask_filter); - else - filter = mask_filter; - } - - if (need_temp) { - /* Render the mask to a surface */ - mask_surf = _cairo_quartz_surface_create_similar (surface, - CAIRO_CONTENT_ALPHA, - surface->extents.width, - surface->extents.height); - status = mask_surf->status; - if (unlikely (status)) - goto BAIL; - - /* mask_surf is clear, so use OVER instead of SOURCE to avoid a - * temporary layer or fallback to cairo-image. */ - status = _cairo_surface_paint (mask_surf, CAIRO_OPERATOR_OVER, mask, NULL); - if (unlikely (status)) - goto BAIL; - - cairo_matrix_init_identity (&matrix); - } - - status = _cairo_quartz_surface_mask_with_surface (surface, op, source, - mask_surf, - &matrix, - filter, - clip); - -BAIL: - - if (need_temp) - cairo_surface_destroy (mask_surf); - - return status; + return _cairo_compositor_stroke (&_cairo_quartz_cg_compositor, + surface, op, source, path, + style, ctm,ctm_inverse, + tolerance, antialias, clip); } static cairo_int_status_t -_cairo_quartz_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_quartz_surface_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, + int *remaining_glyphs) { - cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface; - cairo_int_status_t rv; - cairo_image_surface_t *image; - - rv = _cairo_quartz_surface_mask_cg (surface, - op, - source, - mask, - clip); - - if (likely (rv != CAIRO_INT_STATUS_UNSUPPORTED)) - return rv; - - rv = _cairo_quartz_get_image (surface, &image); - if (likely (rv == CAIRO_STATUS_SUCCESS)) { - rv = _cairo_surface_mask (&image->base, op, source, mask, clip); - cairo_surface_destroy (&image->base); - } - - return rv; + return _cairo_compositor_glyphs (&_cairo_quartz_cg_compositor, + surface, op, source, + glyphs, num_glyphs, scaled_font, + clip, remaining_glyphs); } static cairo_status_t @@ -2422,38 +2207,28 @@ static const struct _cairo_surface_backend cairo_quartz_surface_backend = { _cairo_quartz_surface_create_similar, NULL, /* similar image */ - NULL, /* map to image */ - NULL, /* unmap image */ + _cairo_quartz_surface_map_to_image, + _cairo_quartz_surface_unmap_image, _cairo_quartz_surface_acquire_source_image, _cairo_quartz_surface_release_source_image, - _cairo_quartz_surface_acquire_dest_image, - _cairo_quartz_surface_release_dest_image, - _cairo_quartz_surface_clone_similar, - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + _cairo_quartz_surface_snapshot, + NULL, /* copy_page */ NULL, /* show_page */ + _cairo_quartz_surface_get_extents, - NULL, /* old_show_glyphs */ NULL, /* get_font_options */ + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ _cairo_quartz_surface_paint, _cairo_quartz_surface_mask, _cairo_quartz_surface_stroke, _cairo_quartz_surface_fill, - _cairo_quartz_surface_show_glyphs, - - _cairo_quartz_surface_snapshot, - NULL, /* is_similar */ - NULL /* fill_stroke */ + NULL /* fill-stroke */ + _cairo_quartz_surface_glyphs, }; cairo_quartz_surface_t * @@ -2578,7 +2353,6 @@ cairo_quartz_surface_create (cairo_format_t format, int stride; int bitsPerComponent; - // verify width and height of surface if (!_cairo_quartz_verify_surface_size (width, height)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE)); diff --git a/src/cairo-recording-surface-private.h b/src/cairo-recording-surface-private.h index ea38c198..6e93eab0 100644 --- a/src/cairo-recording-surface-private.h +++ b/src/cairo-recording-surface-private.h @@ -40,6 +40,7 @@ #include "cairoint.h" #include "cairo-path-fixed-private.h" #include "cairo-pattern-private.h" +#include "cairo-surface-backend-private.h" typedef enum { /* The 5 basic drawing operations. */ @@ -178,6 +179,11 @@ _cairo_recording_surface_get_bbox (cairo_recording_surface_t *recording, cairo_box_t *bbox, const cairo_matrix_t *transform); +cairo_private cairo_status_t +_cairo_recording_surface_get_ink_bbox (cairo_recording_surface_t *surface, + cairo_box_t *bbox, + const cairo_matrix_t *transform); + static inline cairo_bool_t _cairo_recording_surface_get_bounds (cairo_surface_t *surface, cairo_rectangle_t *extents) diff --git a/src/cairo-recording-surface.c b/src/cairo-recording-surface.c index 6d4cb379..7a18b53a 100644 --- a/src/cairo-recording-surface.c +++ b/src/cairo-recording-surface.c @@ -77,6 +77,8 @@ */ #include "cairoint.h" + +#include "cairo-array-private.h" #include "cairo-analysis-surface-private.h" #include "cairo-clip-private.h" #include "cairo-combsort-private.h" @@ -86,6 +88,7 @@ #include "cairo-image-surface-private.h" #include "cairo-recording-surface-private.h" #include "cairo-surface-wrapper-private.h" +#include "cairo-traps-private.h" typedef enum { CAIRO_RECORDING_REPLAY, @@ -493,42 +496,6 @@ _cairo_recording_surface_finish (void *abstract_surface) return CAIRO_STATUS_SUCCESS; } -static cairo_status_t -_cairo_recording_surface_acquire_source_image_transformed (void *abstract_surface, - cairo_matrix_t *device_transform, - cairo_image_surface_t **image_out, - void **image_extra) -{ - cairo_status_t status; - cairo_recording_surface_t *surface = abstract_surface; - cairo_surface_t *image; - double width; - double height; - - width = surface->extents.width * device_transform->xx; - height = surface->extents.height * device_transform->yy; - image = _cairo_image_surface_create_with_content (surface->base.content, - width, height); - if (unlikely (image->status)) - return image->status; - - cairo_surface_set_device_offset (image, - -surface->extents.x, - -surface->extents.y); - - _cairo_surface_set_device_scale (image, - device_transform->xx, device_transform->yy); - status = _cairo_recording_surface_replay (&surface->base, image); - if (unlikely (status)) { - cairo_surface_destroy (image); - return status; - } - - *image_out = (cairo_image_surface_t *) image; - *image_extra = NULL; - return CAIRO_STATUS_SUCCESS; -} - struct proxy { cairo_surface_t base; cairo_surface_t *image; @@ -680,15 +647,6 @@ _command_init (cairo_recording_surface_t *surface, return status; } -static const cairo_rectangle_int_t * -_cairo_recording_surface_extents (cairo_recording_surface_t *surface) -{ - if (surface->unbounded) - return &_cairo_unbounded_rectangle; - - return &surface->extents; -} - static void _cairo_recording_surface_break_self_copy_loop (cairo_recording_surface_t *surface) { @@ -713,7 +671,6 @@ _cairo_recording_surface_paint (void *abstract_surface, cairo_recording_surface_t *surface = abstract_surface; cairo_command_paint_t *command; cairo_composite_rectangles_t composite; - const cairo_rectangle_int_t *extents; if (op == CAIRO_OPERATOR_CLEAR && clip == NULL) { if (surface->optimize_clears) { @@ -723,8 +680,8 @@ _cairo_recording_surface_paint (void *abstract_surface, } } - extents = _cairo_recording_surface_extents (surface); - status = _cairo_composite_rectangles_init_for_paint (&composite, extents, + status = _cairo_composite_rectangles_init_for_paint (&composite, + &surface->base, op, source, clip); if (unlikely (status)) @@ -776,10 +733,9 @@ _cairo_recording_surface_mask (void *abstract_surface, cairo_recording_surface_t *surface = abstract_surface; cairo_command_mask_t *command; cairo_composite_rectangles_t composite; - const cairo_rectangle_int_t *extents; - extents = _cairo_recording_surface_extents (surface); - status = _cairo_composite_rectangles_init_for_mask (&composite, extents, + status = _cairo_composite_rectangles_init_for_mask (&composite, + &surface->base, op, source, mask, clip); if (unlikely (status)) @@ -842,10 +798,9 @@ _cairo_recording_surface_stroke (void *abstract_surface, cairo_recording_surface_t *surface = abstract_surface; cairo_command_stroke_t *command; cairo_composite_rectangles_t composite; - const cairo_rectangle_int_t *extents; - extents = _cairo_recording_surface_extents (surface); - status = _cairo_composite_rectangles_init_for_stroke (&composite, extents, + status = _cairo_composite_rectangles_init_for_stroke (&composite, + &surface->base, op, source, path, style, ctm, clip); @@ -918,10 +873,9 @@ _cairo_recording_surface_fill (void *abstract_surface, cairo_recording_surface_t *surface = abstract_surface; cairo_command_fill_t *command; cairo_composite_rectangles_t composite; - const cairo_rectangle_int_t *extents; - extents = _cairo_recording_surface_extents (surface); - status = _cairo_composite_rectangles_init_for_fill (&composite, extents, + status = _cairo_composite_rectangles_init_for_fill (&composite, + &surface->base, op, source, path, clip); if (unlikely (status)) @@ -996,10 +950,9 @@ _cairo_recording_surface_show_text_glyphs (void *abstract_surface, cairo_recording_surface_t *surface = abstract_surface; cairo_command_show_text_glyphs_t *command; cairo_composite_rectangles_t composite; - const cairo_rectangle_int_t *extents; - extents = _cairo_recording_surface_extents (surface); - status = _cairo_composite_rectangles_init_for_glyphs (&composite, extents, + status = _cairo_composite_rectangles_init_for_glyphs (&composite, + &surface->base, op, source, scaled_font, glyphs, num_glyphs, @@ -1121,6 +1074,9 @@ _cairo_recording_surface_snapshot (void *abstract_other) surface->bbtree.left = surface->bbtree.right = NULL; surface->bbtree.chain = INVALID_CHAIN; + surface->indices = NULL; + surface->num_indices = 0; + _cairo_array_init (&surface->commands, sizeof (cairo_command_t *)); status = _cairo_recording_surface_replay (&other->base, &surface->base); if (unlikely (status)) { @@ -1128,9 +1084,6 @@ _cairo_recording_surface_snapshot (void *abstract_other) return _cairo_surface_create_in_error (status); } - surface->indices = NULL; - surface->num_indices = 0; - return &surface->base; } @@ -1160,23 +1113,16 @@ static const cairo_surface_backend_t cairo_recording_surface_backend = { _cairo_recording_surface_acquire_source_image, _cairo_recording_surface_release_source_image, - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + _cairo_recording_surface_snapshot, + NULL, /* copy_page */ NULL, /* show_page */ + _cairo_recording_surface_get_extents, - NULL, /* old_show_glyphs */ NULL, /* get_font_options */ + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ /* Here are the 5 basic drawing operations, (which are in some * sense the only things that cairo_recording_surface should need to @@ -1187,18 +1133,10 @@ static const cairo_surface_backend_t cairo_recording_surface_backend = { _cairo_recording_surface_mask, _cairo_recording_surface_stroke, _cairo_recording_surface_fill, + NULL, /* fill-stroke */ NULL, - - _cairo_recording_surface_snapshot, - - NULL, /* is_similar */ - NULL, /* fill_stroke */ - NULL, /* create_solid_pattern_surface */ - NULL, /* can_repaint_solid_pattern_surface */ - _cairo_recording_surface_has_show_text_glyphs, _cairo_recording_surface_show_text_glyphs, - _cairo_recording_surface_acquire_source_image_transformed }; cairo_int_status_t @@ -1723,3 +1661,30 @@ _cairo_recording_surface_get_bbox (cairo_recording_surface_t *surface, return _recording_surface_get_ink_bbox (surface, bbox, transform); } + +cairo_status_t +_cairo_recording_surface_get_ink_bbox (cairo_recording_surface_t *surface, + cairo_box_t *bbox, + const cairo_matrix_t *transform) +{ + return _recording_surface_get_ink_bbox (surface, bbox, transform); +} + +cairo_bool_t +cairo_recording_surface_get_extents (cairo_surface_t *surface, + cairo_rectangle_t *extents) +{ + cairo_recording_surface_t *record; + + if (surface->status || ! _cairo_surface_is_recording (surface)) { + _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); + return FALSE; + } + + record = (cairo_recording_surface_t *)surface; + if (record->unbounded) + return FALSE; + + *extents = record->extents_pixels; + return TRUE; +} diff --git a/src/cairo-rectangular-scan-converter.c b/src/cairo-rectangular-scan-converter.c index 56e552b7..b4214c88 100644 --- a/src/cairo-rectangular-scan-converter.c +++ b/src/cairo-rectangular-scan-converter.c @@ -379,18 +379,20 @@ _active_edges_to_spans (sweep_line_t *sweep) for (cell = sweep->coverage.head.next; cell != &sweep->coverage.tail; cell = cell->next) { if (cell->x != prev_x && coverage != prev_coverage) { int n = sweep->num_spans++; + int c = coverage >> (CAIRO_FIXED_FRAC_BITS * 2 - 8); sweep->spans[n].x = prev_x; - sweep->spans[n].coverage = coverage >> (CAIRO_FIXED_FRAC_BITS * 2 - 8); - sweep->spans[n].coverage -= sweep->spans[n].coverage >> 8; + sweep->spans[n].inverse = 0; + sweep->spans[n].coverage = c - (c >> 8); prev_coverage = coverage; } coverage += cell->covered; if (coverage != prev_coverage) { int n = sweep->num_spans++; + int c = coverage >> (CAIRO_FIXED_FRAC_BITS * 2 - 8); sweep->spans[n].x = cell->x; - sweep->spans[n].coverage = coverage >> (CAIRO_FIXED_FRAC_BITS * 2 - 8); - sweep->spans[n].coverage -= sweep->spans[n].coverage >> 8; + sweep->spans[n].inverse = 0; + sweep->spans[n].coverage = c - (c >> 8); prev_coverage = coverage; } coverage += cell->uncovered; @@ -401,13 +403,16 @@ _active_edges_to_spans (sweep_line_t *sweep) if (sweep->num_spans) { if (prev_x <= sweep->xmax) { int n = sweep->num_spans++; + int c = coverage >> (CAIRO_FIXED_FRAC_BITS * 2 - 8); sweep->spans[n].x = prev_x; - sweep->spans[n].coverage = coverage; + sweep->spans[n].inverse = 0; + sweep->spans[n].coverage = c - (c >> 8); } if (coverage && prev_x < sweep->xmax) { int n = sweep->num_spans++; sweep->spans[n].x = sweep->xmax; + sweep->spans[n].inverse = 1; sweep->spans[n].coverage = 0; } } @@ -489,13 +494,13 @@ generate (cairo_rectangular_scan_converter_t *self, cairo_status_t status; sweep_line_init (&sweep_line); - sweep_line.xmin = self->xmin; - sweep_line.xmax = self->xmax; + sweep_line.xmin = _cairo_fixed_integer_part (self->extents.p1.x); + sweep_line.xmax = _cairo_fixed_integer_part (self->extents.p2.x); sweep_line.start = rectangles; if ((status = setjmp (sweep_line.jmpbuf))) - goto BAIL; + goto out; - sweep_line.current_y = self->ymin; + sweep_line.current_y = _cairo_fixed_integer_part (self->extents.p1.y); start = *sweep_line.start++; do { if (start->top_y != sweep_line.current_y) { @@ -554,9 +559,7 @@ generate (cairo_rectangular_scan_converter_t *self, goto out; } - sweep_line.current_y++; - - do { + while (++sweep_line.current_y < _cairo_fixed_integer_part (self->extents.p2.y)) { if (stop->bottom_y != sweep_line.current_y) { render_rows (&sweep_line, renderer, stop->bottom_y - sweep_line.current_y); @@ -572,16 +575,9 @@ generate (cairo_rectangular_scan_converter_t *self, goto out; } while (stop->bottom_y == sweep_line.current_y); - sweep_line.current_y++; - } while (TRUE); + } out: - status = renderer->render_rows (renderer, - sweep_line.current_y, - self->ymax - sweep_line.current_y, - NULL, 0); - - BAIL: sweep_line_fini (&sweep_line); return status; @@ -611,18 +607,18 @@ static void generate_row(cairo_span_renderer_t *renderer, } if (! _cairo_fixed_is_integer (r->right)) { - spans[num_spans].x = x2; + spans[num_spans].x = x2++; spans[num_spans].coverage = coverage * _cairo_fixed_fractional_part (r->right) >> 8; num_spans++; } } else { - spans[num_spans].x = x1; + spans[num_spans].x = x2++; spans[num_spans].coverage = coverage * (r->right - r->left) >> 8; num_spans++; } - spans[num_spans].x = x2 + 1; + spans[num_spans].x = x2; spans[num_spans].coverage = 0; num_spans++; @@ -668,7 +664,8 @@ _cairo_rectangular_scan_converter_generate (void *converter, if (unlikely (self->num_rectangles == 0)) { return renderer->render_rows (renderer, - self->ymin, self->ymax - self->ymin, + _cairo_fixed_integer_part (self->extents.p1.y), + _cairo_fixed_integer_part (self->extents.p2.y - self->extents.p1.y), NULL, 0); } @@ -743,17 +740,22 @@ _cairo_rectangular_scan_converter_add_box (cairo_rectangular_scan_converter_t *s if (unlikely (rectangle == NULL)) return _cairo_error (CAIRO_STATUS_NO_MEMORY); - rectangle->left = box->p1.x; - rectangle->right = box->p2.x; rectangle->dir = dir; + rectangle->left = MAX (box->p1.x, self->extents.p1.x); + rectangle->right = MIN (box->p2.x, self->extents.p2.x); + if (unlikely (rectangle->right <= rectangle->left)) { + self->tail->count--; + return CAIRO_STATUS_SUCCESS; + } - rectangle->top = box->p1.y; - rectangle->top_y = _cairo_fixed_integer_floor (box->p1.y); - rectangle->bottom = box->p2.y; - rectangle->bottom_y = _cairo_fixed_integer_floor (box->p2.y); - assert (rectangle->bottom_y >= rectangle->top_y); - - self->num_rectangles++; + rectangle->top = MAX (box->p1.y, self->extents.p1.y); + rectangle->top_y = _cairo_fixed_integer_floor (rectangle->top); + rectangle->bottom = MIN (box->p2.y, self->extents.p2.y); + rectangle->bottom_y = _cairo_fixed_integer_floor (rectangle->bottom); + if (likely (rectangle->bottom > rectangle->top)) + self->num_rectangles++; + else + self->tail->count--; return CAIRO_STATUS_SUCCESS; } @@ -775,14 +777,9 @@ _cairo_rectangular_scan_converter_init (cairo_rectangular_scan_converter_t *self const cairo_rectangle_int_t *extents) { self->base.destroy = _cairo_rectangular_scan_converter_destroy; - self->base.add_edge = NULL; - self->base.add_polygon = NULL; self->base.generate = _cairo_rectangular_scan_converter_generate; - self->xmin = extents->x; - self->xmax = extents->x + extents->width; - self->ymin = extents->y; - self->ymax = extents->y + extents->height; + _cairo_box_from_rectangle (&self->extents, extents); self->chunks.base = self->buf; self->chunks.next = NULL; diff --git a/src/cairo-reference-count-private.h b/src/cairo-reference-count-private.h index 0cb5695d..75fdf353 100644 --- a/src/cairo-reference-count-private.h +++ b/src/cairo-reference-count-private.h @@ -45,6 +45,7 @@ typedef struct { } cairo_reference_count_t; #define _cairo_reference_count_inc(RC) _cairo_atomic_int_inc (&(RC)->ref_count) +#define _cairo_reference_count_dec(RC) _cairo_atomic_int_dec (&(RC)->ref_count) #define _cairo_reference_count_dec_and_test(RC) _cairo_atomic_int_dec_and_test (&(RC)->ref_count) #define CAIRO_REFERENCE_COUNT_INIT(RC, VALUE) ((RC)->ref_count = (VALUE)) diff --git a/src/cairo-scaled-font-private.h b/src/cairo-scaled-font-private.h index 029377b1..da7b3469 100644 --- a/src/cairo-scaled-font-private.h +++ b/src/cairo-scaled-font-private.h @@ -45,6 +45,8 @@ #include "cairo-mutex-type-private.h" #include "cairo-reference-count-private.h" +CAIRO_BEGIN_DECLS + typedef struct _cairo_scaled_glyph_page cairo_scaled_glyph_page_t; struct _cairo_scaled_font { @@ -112,20 +114,70 @@ struct _cairo_scaled_font { cairo_bool_t cache_frozen; cairo_bool_t global_cache_frozen; - /* - * One surface backend may store data in each glyph. - * Whichever surface manages to store its pointer here - * first gets to store data in each glyph - */ - const cairo_surface_backend_t *surface_backend; - void *surface_private; + cairo_list_t dev_privates; /* font backend managing this scaled font */ const cairo_scaled_font_backend_t *backend; cairo_list_t link; }; +struct _cairo_scaled_font_private { + cairo_list_t link; + const void *key; + void (*destroy) (cairo_scaled_font_private_t *, + cairo_scaled_font_t *); +}; + +struct _cairo_scaled_glyph { + cairo_hash_entry_t hash_entry; + + cairo_text_extents_t metrics; /* user-space metrics */ + cairo_text_extents_t fs_metrics; /* font-space metrics */ + cairo_box_t bbox; /* device-space bounds */ + int16_t x_advance; /* device-space rounded X advance */ + int16_t y_advance; /* device-space rounded Y advance */ + + unsigned int has_info; + cairo_image_surface_t *surface; /* device-space image */ + cairo_path_fixed_t *path; /* device-space outline */ + cairo_surface_t *recording_surface; /* device-space recording-surface */ + + const void *dev_private_key; + void *dev_private; + cairo_list_t dev_privates; +}; + +struct _cairo_scaled_glyph_private { + cairo_list_t link; + const void *key; + void (*destroy) (cairo_scaled_glyph_private_t *, + cairo_scaled_glyph_t *, + cairo_scaled_font_t *); +}; + +cairo_private cairo_scaled_font_private_t * +_cairo_scaled_font_find_private (cairo_scaled_font_t *scaled_font, + const void *key); + +cairo_private void +_cairo_scaled_font_attach_private (cairo_scaled_font_t *scaled_font, + cairo_scaled_font_private_t *priv, + const void *key, + void (*destroy) (cairo_scaled_font_private_t *, + cairo_scaled_font_t *)); + +cairo_private cairo_scaled_glyph_private_t * +_cairo_scaled_glyph_find_private (cairo_scaled_glyph_t *scaled_glyph, + const void *key); + cairo_private void -_cairo_scaled_font_revoke_ownership (cairo_scaled_font_t *scaled_font); +_cairo_scaled_glyph_attach_private (cairo_scaled_glyph_t *scaled_glyph, + cairo_scaled_glyph_private_t *priv, + const void *key, + void (*destroy) (cairo_scaled_glyph_private_t *, + cairo_scaled_glyph_t *, + cairo_scaled_font_t *)); + +CAIRO_END_DECLS #endif /* CAIRO_SCALED_FONT_PRIVATE_H */ diff --git a/src/cairo-scaled-font.c b/src/cairo-scaled-font.c index 5b775469..be612a9b 100644 --- a/src/cairo-scaled-font.c +++ b/src/cairo-scaled-font.c @@ -43,6 +43,7 @@ #include "cairo-image-surface-private.h" #include "cairo-pattern-private.h" #include "cairo-scaled-font-private.h" +#include "cairo-surface-backend-private.h" #if _XOPEN_SOURCE >= 600 || defined (_ISOC99_SOURCE) #define ISFINITE(x) isfinite (x) @@ -199,10 +200,13 @@ static void _cairo_scaled_glyph_fini (cairo_scaled_font_t *scaled_font, cairo_scaled_glyph_t *scaled_glyph) { - const cairo_surface_backend_t *surface_backend = scaled_font->surface_backend; - - if (surface_backend != NULL && surface_backend->scaled_glyph_fini != NULL) - surface_backend->scaled_glyph_fini (scaled_glyph, scaled_font); + while (! cairo_list_is_empty (&scaled_glyph->dev_privates)) { + cairo_scaled_glyph_private_t *private = + cairo_list_first_entry (&scaled_glyph->dev_privates, + cairo_scaled_glyph_private_t, + link); + private->destroy (private, scaled_glyph, scaled_font); + } if (scaled_glyph->surface != NULL) cairo_surface_destroy (&scaled_glyph->surface->base); @@ -243,8 +247,7 @@ static const cairo_scaled_font_t _cairo_scaled_font_nil = { { NULL, NULL }, /* pages */ FALSE, /* cache_frozen */ FALSE, /* global_cache_frozen */ - NULL, /* surface_backend */ - NULL, /* surface_private */ + { NULL, NULL }, /* privates */ NULL /* backend */ }; @@ -445,6 +448,8 @@ _cairo_scaled_glyph_page_destroy (void *closure) cairo_scaled_font_t *scaled_font; unsigned int n; + assert (! cairo_list_is_empty (&page->link)); + scaled_font = (cairo_scaled_font_t *) page->cache_entry.hash; for (n = 0; n < page->num_glyphs; n++) { _cairo_hash_table_remove (scaled_font->glyphs, @@ -734,8 +739,7 @@ _cairo_scaled_font_init (cairo_scaled_font_t *scaled_font, CAIRO_MUTEX_INIT (scaled_font->mutex); - scaled_font->surface_backend = NULL; - scaled_font->surface_private = NULL; + cairo_list_init (&scaled_font->dev_privates); scaled_font->backend = backend; cairo_list_init (&scaled_font->link); @@ -826,9 +830,13 @@ _cairo_scaled_font_fini_internal (cairo_scaled_font_t *scaled_font) CAIRO_MUTEX_FINI (scaled_font->mutex); - if (scaled_font->surface_backend != NULL && - scaled_font->surface_backend->scaled_font_fini != NULL) - scaled_font->surface_backend->scaled_font_fini (scaled_font); + while (! cairo_list_is_empty (&scaled_font->dev_privates)) { + cairo_scaled_font_private_t *private = + cairo_list_first_entry (&scaled_font->dev_privates, + cairo_scaled_font_private_t, + link); + private->destroy (private, scaled_font); + } if (scaled_font->backend != NULL && scaled_font->backend->fini != NULL) scaled_font->backend->fini (scaled_font); @@ -836,30 +844,77 @@ _cairo_scaled_font_fini_internal (cairo_scaled_font_t *scaled_font) _cairo_user_data_array_fini (&scaled_font->user_data); } -/* XXX: allow multiple backends to share the font */ void -_cairo_scaled_font_revoke_ownership (cairo_scaled_font_t *scaled_font) +_cairo_scaled_font_fini (cairo_scaled_font_t *scaled_font) { - if (scaled_font->surface_backend == NULL) - return; + /* Release the lock to avoid the possibility of a recursive + * deadlock when the scaled font destroy closure gets called. */ + CAIRO_MUTEX_UNLOCK (_cairo_scaled_font_map_mutex); + _cairo_scaled_font_fini_internal (scaled_font); + CAIRO_MUTEX_LOCK (_cairo_scaled_font_map_mutex); +} - _cairo_scaled_font_reset_cache (scaled_font); +void +_cairo_scaled_font_attach_private (cairo_scaled_font_t *scaled_font, + cairo_scaled_font_private_t *private, + const void *key, + void (*destroy) (cairo_scaled_font_private_t *, + cairo_scaled_font_t *)) +{ + private->key = key; + private->destroy = destroy; + cairo_list_add (&private->link, &scaled_font->dev_privates); +} + +cairo_scaled_font_private_t * +_cairo_scaled_font_find_private (cairo_scaled_font_t *scaled_font, + const void *key) +{ + cairo_scaled_font_private_t *priv; - if (scaled_font->surface_backend->scaled_font_fini != NULL) - scaled_font->surface_backend->scaled_font_fini (scaled_font); + cairo_list_foreach_entry (priv, cairo_scaled_font_private_t, + &scaled_font->dev_privates, link) + { + if (priv->key == key) { + if (priv->link.prev != &scaled_font->dev_privates) + cairo_list_move (&priv->link, &scaled_font->dev_privates); + return priv; + } + } - scaled_font->surface_backend = NULL; - scaled_font->surface_private = NULL; + return NULL; } void -_cairo_scaled_font_fini (cairo_scaled_font_t *scaled_font) +_cairo_scaled_glyph_attach_private (cairo_scaled_glyph_t *scaled_glyph, + cairo_scaled_glyph_private_t *private, + const void *key, + void (*destroy) (cairo_scaled_glyph_private_t *, + cairo_scaled_glyph_t *, + cairo_scaled_font_t *)) { - /* Release the lock to avoid the possibility of a recursive - * deadlock when the scaled font destroy closure gets called. */ - CAIRO_MUTEX_UNLOCK (_cairo_scaled_font_map_mutex); - _cairo_scaled_font_fini_internal (scaled_font); - CAIRO_MUTEX_LOCK (_cairo_scaled_font_map_mutex); + private->key = key; + private->destroy = destroy; + cairo_list_add (&private->link, &scaled_glyph->dev_privates); +} + +cairo_scaled_glyph_private_t * +_cairo_scaled_glyph_find_private (cairo_scaled_glyph_t *scaled_glyph, + const void *key) +{ + cairo_scaled_glyph_private_t *priv; + + cairo_list_foreach_entry (priv, cairo_scaled_glyph_private_t, + &scaled_glyph->dev_privates, link) + { + if (priv->key == key) { + if (priv->link.prev != &scaled_glyph->dev_privates) + cairo_list_move (&priv->link, &scaled_glyph->dev_privates); + return priv; + } + } + + return NULL; } /** @@ -2209,6 +2264,8 @@ _cairo_scaled_font_glyph_approximate_extents (cairo_scaled_font_t *scaled_font, extents->height = ceil (y1 + pad) - extents->y; } +#if 0 +/* XXX win32 */ cairo_status_t _cairo_scaled_font_show_glyphs (cairo_scaled_font_t *scaled_font, cairo_operator_t op, @@ -2399,6 +2456,7 @@ CLEANUP_MASK: cairo_surface_destroy (mask); return _cairo_scaled_font_set_error (scaled_font, status); } +#endif /* Add a single-device-unit rectangle to a path. */ static cairo_status_t @@ -2844,6 +2902,7 @@ _cairo_scaled_glyph_lookup (cairo_scaled_font_t *scaled_font, memset (scaled_glyph, 0, sizeof (cairo_scaled_glyph_t)); _cairo_scaled_glyph_set_index (scaled_glyph, index); + cairo_list_init (&scaled_glyph->dev_privates); /* ask backend to initialize metrics and shape fields */ status = diff --git a/src/cairo-script-private.h b/src/cairo-script-private.h index 698a54e3..5b506f50 100644 --- a/src/cairo-script-private.h +++ b/src/cairo-script-private.h @@ -37,10 +37,11 @@ #define CAIRO_SCRIPT_PRIVATE_H #include "cairo.h" +#include "cairo-script.h" #include "cairo-compiler-private.h" #include "cairo-output-stream-private.h" -#include "cairo-script.h" +#include "cairo-types-private.h" CAIRO_BEGIN_DECLS diff --git a/src/cairo-script-surface.c b/src/cairo-script-surface.c index 56e9d80a..7199cd13 100644 --- a/src/cairo-script-surface.c +++ b/src/cairo-script-surface.c @@ -81,7 +81,7 @@ typedef struct _cairo_script_context cairo_script_context_t; typedef struct _cairo_script_surface cairo_script_surface_t; typedef struct _cairo_script_implicit_context cairo_script_implicit_context_t; -typedef struct _cairo_script_surface_font_private cairo_script_surface_font_private_t; +typedef struct _cairo_script_font cairo_script_font_t; typedef struct _operand { enum { @@ -121,8 +121,9 @@ struct _cairo_script_context { cairo_list_t defines; }; -struct _cairo_script_surface_font_private { - cairo_script_context_t *ctx; +struct _cairo_script_font { + cairo_scaled_font_private_t base; + cairo_bool_t has_sfnt; unsigned long id; unsigned long subset_glyph_index; @@ -173,7 +174,8 @@ _cairo_script_surface_create_internal (cairo_script_context_t *ctx, cairo_surface_t *passthrough); static void -_cairo_script_surface_scaled_font_fini (cairo_scaled_font_t *scaled_font); +_cairo_script_scaled_font_fini (cairo_scaled_font_private_t *abstract_private, + cairo_scaled_font_t *scaled_font); static void _cairo_script_implicit_context_init (cairo_script_implicit_context_t *cr); @@ -2022,14 +2024,11 @@ _device_destroy (void *abstract_device) cairo_status_t status; while (! cairo_list_is_empty (&ctx->fonts)) { - cairo_script_surface_font_private_t *font; + cairo_script_font_t *font; - font = cairo_list_first_entry (&ctx->fonts, - cairo_script_surface_font_private_t, - link); + font = cairo_list_first_entry (&ctx->fonts, cairo_script_font_t, link); + cairo_list_del (&font->base.link); cairo_list_del (&font->link); - if (font->parent->surface_private == font) - font->parent->surface_private = NULL; free (font); } @@ -2733,31 +2732,39 @@ _emit_font_options (cairo_script_surface_t *surface, } static void -_cairo_script_surface_scaled_font_fini (cairo_scaled_font_t *scaled_font) +_cairo_script_scaled_font_fini (cairo_scaled_font_private_t *abstract_private, + cairo_scaled_font_t *scaled_font) { - cairo_script_surface_font_private_t *font_private; + cairo_script_font_t *priv = (cairo_script_font_t *)abstract_private; + cairo_script_context_t *ctx = (cairo_script_context_t *)abstract_private->key; + cairo_status_t status; - font_private = scaled_font->surface_private; - if (font_private != NULL) { - cairo_status_t status; - cairo_device_t *device; + status = cairo_device_acquire (&ctx->base); + if (likely (status == CAIRO_STATUS_SUCCESS)) { + _cairo_output_stream_printf (ctx->stream, + "/f%lu undef /sf%lu undef\n", + priv->id, + priv->id); - status = cairo_device_acquire (device = &font_private->ctx->base); - if (likely (status == CAIRO_STATUS_SUCCESS)) { - _cairo_output_stream_printf (font_private->ctx->stream, - "/f%lu undef /sf%lu undef\n", - font_private->id, - font_private->id); + _bitmap_release_id (&ctx->font_id, priv->id); + cairo_device_release (&ctx->base); + } - _bitmap_release_id (&font_private->ctx->font_id, font_private->id); - cairo_list_del (&font_private->link); - free (font_private); + cairo_list_del (&priv->link); + cairo_list_del (&priv->base.link); + free (priv); +} - cairo_device_release (device); - } +static cairo_script_font_t * +_cairo_script_font_get (cairo_script_context_t *ctx, cairo_scaled_font_t *font) +{ + return (cairo_script_font_t *) _cairo_scaled_font_find_private (font, ctx); +} - scaled_font->surface_private = NULL; - } +static long unsigned +_cairo_script_font_id (cairo_script_context_t *ctx, cairo_scaled_font_t *font) +{ + return _cairo_script_font_get (ctx, font)->id; } static cairo_status_t @@ -2766,7 +2773,6 @@ _emit_type42_font (cairo_script_surface_t *surface, { cairo_script_context_t *ctx = to_context (surface); const cairo_scaled_font_backend_t *backend; - cairo_script_surface_font_private_t *font_private; cairo_output_stream_t *base85_stream; cairo_output_stream_t *zlib_stream; cairo_status_t status, status2; @@ -2824,27 +2830,29 @@ _emit_type42_font (cairo_script_surface_t *surface, if (status == CAIRO_STATUS_SUCCESS) status = status2; - font_private = scaled_font->surface_private; _cairo_output_stream_printf (ctx->stream, "~> >> font dup /f%lu exch def set-font-face", - font_private->id); + _cairo_script_font_id (ctx, scaled_font)); return status; } static cairo_status_t _emit_scaled_font_init (cairo_script_surface_t *surface, - cairo_scaled_font_t *scaled_font) + cairo_scaled_font_t *scaled_font, + cairo_script_font_t **font_out) { cairo_script_context_t *ctx = to_context (surface); - cairo_script_surface_font_private_t *font_private; + cairo_script_font_t *font_private; cairo_int_status_t status; - font_private = malloc (sizeof (cairo_script_surface_font_private_t)); + font_private = malloc (sizeof (cairo_script_font_t)); if (unlikely (font_private == NULL)) return _cairo_error (CAIRO_STATUS_NO_MEMORY); - font_private->ctx = ctx; + _cairo_scaled_font_attach_private (scaled_font, &font_private->base, ctx, + _cairo_script_scaled_font_fini); + font_private->parent = scaled_font; font_private->subset_glyph_index = 0; font_private->has_sfnt = TRUE; @@ -2858,16 +2866,17 @@ _emit_scaled_font_init (cairo_script_surface_t *surface, return status; } - scaled_font->surface_private = font_private; - scaled_font->surface_backend = &_cairo_script_surface_backend; - status = _emit_context (surface); - if (unlikely (status)) + if (unlikely (status)) { + free (font_private); return status; + } status = _emit_type42_font (surface, scaled_font); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) + if (status != CAIRO_INT_STATUS_UNSUPPORTED) { + *font_out = font_private; return status; + } font_private->has_sfnt = FALSE; _cairo_output_stream_printf (ctx->stream, @@ -2883,6 +2892,7 @@ _emit_scaled_font_init (cairo_script_surface_t *surface, scaled_font->fs_extents.max_y_advance, font_private->id); + *font_out = font_private; return CAIRO_STATUS_SUCCESS; } @@ -2895,7 +2905,7 @@ _emit_scaled_font (cairo_script_surface_t *surface, cairo_font_options_t options; cairo_bool_t matrix_updated = FALSE; cairo_status_t status; - cairo_script_surface_font_private_t *font_private; + cairo_script_font_t *font_private; cairo_scaled_font_get_ctm (scaled_font, &matrix); status = _emit_scaling_matrix (surface, &matrix, &matrix_updated); @@ -2907,13 +2917,7 @@ _emit_scaled_font (cairo_script_surface_t *surface, surface->cr.current_scaled_font = scaled_font; - if (! (scaled_font->surface_backend == NULL || - scaled_font->surface_backend == &_cairo_script_surface_backend)) - { - _cairo_scaled_font_revoke_ownership (scaled_font); - } - - font_private = scaled_font->surface_private; + font_private = _cairo_script_font_get (ctx, scaled_font); if (font_private == NULL) { cairo_scaled_font_get_font_matrix (scaled_font, &matrix); status = _emit_font_matrix (surface, &matrix); @@ -2925,13 +2929,10 @@ _emit_scaled_font (cairo_script_surface_t *surface, if (unlikely (status)) return status; - status = _emit_scaled_font_init (surface, scaled_font); + status = _emit_scaled_font_init (surface, scaled_font, &font_private); if (unlikely (status)) return status; - font_private = scaled_font->surface_private; - assert (font_private != NULL); - assert (target_is_active (surface)); _cairo_output_stream_printf (ctx->stream, " /scaled-font get /sf%lu exch def\n", @@ -2948,17 +2949,17 @@ _emit_scaled_font (cairo_script_surface_t *surface, static cairo_status_t _emit_scaled_glyph_vector (cairo_script_surface_t *surface, cairo_scaled_font_t *scaled_font, + cairo_script_font_t *font_private, cairo_scaled_glyph_t *scaled_glyph) { cairo_script_context_t *ctx = to_context (surface); - cairo_script_surface_font_private_t *font_private; cairo_script_implicit_context_t old_cr; cairo_status_t status; unsigned long index; - font_private = scaled_font->surface_private; index = ++font_private->subset_glyph_index; - scaled_glyph->surface_private = (void *) index; + scaled_glyph->dev_private_key = ctx; + scaled_glyph->dev_private = (void *) index; _cairo_output_stream_printf (ctx->stream, "%lu <<\n" @@ -2997,16 +2998,16 @@ _emit_scaled_glyph_vector (cairo_script_surface_t *surface, static cairo_status_t _emit_scaled_glyph_bitmap (cairo_script_surface_t *surface, cairo_scaled_font_t *scaled_font, + cairo_script_font_t *font_private, cairo_scaled_glyph_t *scaled_glyph) { cairo_script_context_t *ctx = to_context (surface); - cairo_script_surface_font_private_t *font_private; cairo_status_t status; unsigned long index; - font_private = scaled_font->surface_private; index = ++font_private->subset_glyph_index; - scaled_glyph->surface_private = (void *) index; + scaled_glyph->dev_private_key = ctx; + scaled_glyph->dev_private = (void *) index; _cairo_output_stream_printf (ctx->stream, "%lu <<\n" @@ -3049,15 +3050,10 @@ static cairo_status_t _emit_scaled_glyph_prologue (cairo_script_surface_t *surface, cairo_scaled_font_t *scaled_font) { - cairo_script_surface_font_private_t *font_private; - - assert (scaled_font->surface_backend == &_cairo_script_surface_backend); - - font_private = scaled_font->surface_private; + cairo_script_context_t *ctx = to_context (surface); - _cairo_output_stream_printf (to_context (surface)->stream, - "f%lu /glyphs get\n", - font_private->id); + _cairo_output_stream_printf (ctx->stream, "f%lu /glyphs get\n", + _cairo_script_font_id (ctx, scaled_font)); return CAIRO_STATUS_SUCCESS; } @@ -3068,7 +3064,8 @@ _emit_scaled_glyphs (cairo_script_surface_t *surface, cairo_glyph_t *glyphs, unsigned int num_glyphs) { - cairo_script_surface_font_private_t *font_private; + cairo_script_context_t *ctx = to_context (surface); + cairo_script_font_t *font_private; cairo_status_t status; unsigned int n; cairo_bool_t have_glyph_prologue = FALSE; @@ -3076,7 +3073,7 @@ _emit_scaled_glyphs (cairo_script_surface_t *surface, if (num_glyphs == 0) return CAIRO_STATUS_SUCCESS; - font_private = scaled_font->surface_private; + font_private = _cairo_script_font_get (ctx, scaled_font); if (font_private->has_sfnt) return CAIRO_STATUS_SUCCESS; @@ -3091,7 +3088,7 @@ _emit_scaled_glyphs (cairo_script_surface_t *surface, if (unlikely (status)) break; - if (scaled_glyph->surface_private != NULL) + if (scaled_glyph->dev_private_key == ctx) continue; status = _cairo_scaled_glyph_lookup (scaled_font, @@ -3111,7 +3108,7 @@ _emit_scaled_glyphs (cairo_script_surface_t *surface, } status = _emit_scaled_glyph_vector (surface, - scaled_font, + scaled_font, font_private, scaled_glyph); if (unlikely (status)) break; @@ -3137,6 +3134,7 @@ _emit_scaled_glyphs (cairo_script_surface_t *surface, status = _emit_scaled_glyph_bitmap (surface, scaled_font, + font_private, scaled_glyph); if (unlikely (status)) break; @@ -3234,7 +3232,7 @@ _cairo_script_surface_show_text_glyphs (void *abstract_surface, { cairo_script_surface_t *surface = abstract_surface; cairo_script_context_t *ctx = to_context (surface); - cairo_script_surface_font_private_t *font_private; + cairo_script_font_t *font_private; cairo_scaled_glyph_t *scaled_glyph; cairo_matrix_t matrix; cairo_status_t status; @@ -3289,7 +3287,7 @@ _cairo_script_surface_show_text_glyphs (void *abstract_surface, iy -= scaled_font->font_matrix.y0; _cairo_scaled_font_freeze_cache (scaled_font); - font_private = scaled_font->surface_private; + font_private = _cairo_script_font_get (ctx, scaled_font); _cairo_output_stream_printf (ctx->stream, "[%f %f ", @@ -3309,7 +3307,7 @@ _cairo_script_surface_show_text_glyphs (void *abstract_surface, goto BAIL; } - if ((long unsigned) scaled_glyph->surface_private > 256) + if ((long unsigned) scaled_glyph->dev_private > 256) break; } } @@ -3378,7 +3376,7 @@ _cairo_script_surface_show_text_glyphs (void *abstract_surface, if (font_private->has_sfnt) c = glyphs[n].index; else - c = (uint8_t) (long unsigned) scaled_glyph->surface_private; + c = (uint8_t) (long unsigned) scaled_glyph->dev_private; _cairo_output_stream_write (base85_stream, &c, 1); } else { @@ -3387,7 +3385,7 @@ _cairo_script_surface_show_text_glyphs (void *abstract_surface, glyphs[n].index); else _cairo_output_stream_printf (ctx->stream, " %lu", - (long unsigned) scaled_glyph->surface_private); + (long unsigned) scaled_glyph->dev_private); } dx = scaled_glyph->metrics.x_advance; @@ -3512,40 +3510,23 @@ _cairo_script_surface_backend = { _cairo_script_surface_acquire_source_image, _cairo_script_surface_release_source_image, - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + _cairo_script_surface_snapshot, + _cairo_script_surface_copy_page, _cairo_script_surface_show_page, + _cairo_script_surface_get_extents, - NULL, /* old_show_glyphs */ NULL, /* get_font_options */ + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ - _cairo_script_surface_scaled_font_fini, - NULL, /* scaled_glyph_fini */ - /* The 5 high level operations */ _cairo_script_surface_paint, _cairo_script_surface_mask, _cairo_script_surface_stroke, _cairo_script_surface_fill, - NULL, - - _cairo_script_surface_snapshot, - - NULL, /* is_similar */ - /* XXX need fill-stroke for passthrough */ - NULL, /* fill_stroke */ - NULL, /* create_solid_pattern_surface */ - NULL, /* can_repaint_solid_pattern_surface */ - - /* The alternate high-level text operation */ + NULL, /* fill/stroke */ + NULL, /* glyphs */ _cairo_script_surface_has_show_text_glyphs, _cairo_script_surface_show_text_glyphs }; diff --git a/src/cairo-slope.c b/src/cairo-slope.c index 827037f7..cc5f30cb 100644 --- a/src/cairo-slope.c +++ b/src/cairo-slope.c @@ -89,9 +89,9 @@ _cairo_slope_compare (const cairo_slope_t *a, const cairo_slope_t *b) */ if ((a->dx ^ b->dx) < 0 || (a->dy ^ b->dy) < 0) { if (a->dx > 0 || (a->dx == 0 && a->dy > 0)) - return +1; - else return -1; + else + return +1; } /* Finally, for identical slopes, we obviously return 0. */ diff --git a/src/cairo-spans-compositor-private.h b/src/cairo-spans-compositor-private.h new file mode 100644 index 00000000..41756392 --- /dev/null +++ b/src/cairo-spans-compositor-private.h @@ -0,0 +1,96 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#ifndef CAIRO_SPANS_COMPOSITOR_PRIVATE_H +#define CAIRO_SPANS_COMPOSITOR_PRIVATE_H + +#include "cairo-compositor-private.h" +#include "cairo-types-private.h" +#include "cairo-spans-private.h" + +CAIRO_BEGIN_DECLS + +typedef struct _cairo_abstract_span_renderer { + cairo_span_renderer_t base; + char data[2048]; +} cairo_abstract_span_renderer_t; + +struct cairo_spans_compositor { + cairo_compositor_t base; + + /* pixel-aligned fast paths */ + cairo_int_status_t (*fill_boxes) (void *surface, + cairo_operator_t op, + const cairo_color_t *color, + cairo_boxes_t *boxes); + + cairo_surface_t * (*pattern_to_surface) (cairo_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y); + + cairo_int_status_t (*composite_boxes) (void *surface, + cairo_operator_t op, + cairo_surface_t *source, + cairo_surface_t *mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + cairo_boxes_t *boxes, + const cairo_rectangle_int_t *extents); + + /* general shape masks using a span renderer */ + cairo_int_status_t (*renderer_init) (cairo_abstract_span_renderer_t *renderer, + const cairo_composite_rectangles_t *extents, + cairo_bool_t needs_clip); + + void (*renderer_fini) (cairo_abstract_span_renderer_t *renderer, + cairo_int_status_t status); +}; + +cairo_private void +_cairo_spans_compositor_init (cairo_spans_compositor_t *compositor, + const cairo_compositor_t *delegate); + +CAIRO_END_DECLS + +#endif /* CAIRO_SPANS_COMPOSITOR_PRIVATE_H */ diff --git a/src/cairo-spans-compositor.c b/src/cairo-spans-compositor.c new file mode 100644 index 00000000..4320a3ec --- /dev/null +++ b/src/cairo-spans-compositor.c @@ -0,0 +1,1007 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Joonas Pihlaja <jpihlaja@cc.helsinki.fi> + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#include "cairoint.h" + +#include "cairo-compositor-private.h" +#include "cairo-clip-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-paginated-private.h" +#include "cairo-pattern-private.h" +#include "cairo-region-private.h" +#include "cairo-recording-surface-private.h" +#include "cairo-spans-compositor-private.h" +#include "cairo-surface-subsurface-private.h" +#include "cairo-surface-snapshot-private.h" +#include "cairo-surface-observer-private.h" + +typedef struct { + cairo_polygon_t *polygon; + cairo_fill_rule_t fill_rule; + cairo_antialias_t antialias; +} composite_spans_info_t; + +static cairo_int_status_t +composite_polygon (const cairo_spans_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_polygon_t *polygon, + cairo_fill_rule_t fill_rule, + cairo_antialias_t antialias); + +static cairo_int_status_t +composite_boxes (const cairo_spans_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes); + +static cairo_int_status_t +clip_and_composite_polygon (const cairo_spans_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_polygon_t *polygon, + cairo_fill_rule_t fill_rule, + cairo_antialias_t antialias); +static cairo_surface_t * +get_clip_surface (const cairo_spans_compositor_t *compositor, + cairo_surface_t *dst, + const cairo_clip_t *clip, + const cairo_rectangle_int_t *extents) +{ + cairo_composite_rectangles_t composite; + cairo_surface_t *surface; + cairo_box_t box; + cairo_polygon_t polygon; + const cairo_clip_path_t *clip_path; + cairo_antialias_t antialias; + cairo_fill_rule_t fill_rule; + cairo_int_status_t status; + + assert (clip->path); + + surface = _cairo_surface_create_similar_solid (dst, + CAIRO_CONTENT_ALPHA, + extents->width, + extents->height, + CAIRO_COLOR_TRANSPARENT); + + _cairo_box_from_rectangle (&box, extents); + _cairo_polygon_init (&polygon, &box, 1); + + clip_path = clip->path; + status = _cairo_path_fixed_fill_to_polygon (&clip_path->path, + clip_path->tolerance, + &polygon); + if (unlikely (status)) + goto cleanup_polygon; + + polygon.limits = NULL; + polygon.num_limits = 0; + + antialias = clip_path->antialias; + fill_rule = clip_path->fill_rule; + clip_path = clip_path->prev; + while (clip_path) { + if (clip_path->antialias == antialias) { + cairo_polygon_t next; + + _cairo_polygon_init (&next, NULL, 0); + status = _cairo_path_fixed_fill_to_polygon (&clip_path->path, + clip_path->tolerance, + &next); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = _cairo_polygon_intersect (&polygon, fill_rule, + &next, clip_path->fill_rule); + _cairo_polygon_fini (&next); + if (unlikely (status)) + goto cleanup_polygon; + + fill_rule = CAIRO_FILL_RULE_WINDING; + } + + clip_path = clip_path->prev; + } + + _cairo_polygon_translate (&polygon, -extents->x, -extents->y); + status = _cairo_composite_rectangles_init_for_polygon (&composite, surface, + CAIRO_OPERATOR_ADD, + &_cairo_pattern_white.base, + &polygon, + NULL); + if (unlikely (status)) + goto cleanup_polygon; + + status = composite_polygon (compositor, &composite, + &polygon, fill_rule, antialias); + _cairo_composite_rectangles_fini (&composite); + _cairo_polygon_fini (&polygon); + if (unlikely (status)) + goto error; + + _cairo_polygon_init (&polygon, &box, 1); + + clip_path = clip->path; + antialias = clip_path->antialias == CAIRO_ANTIALIAS_DEFAULT ? CAIRO_ANTIALIAS_NONE : CAIRO_ANTIALIAS_DEFAULT; + clip_path = clip_path->prev; + while (clip_path) { + if (clip_path->antialias == antialias) { + if (polygon.num_edges == 0) { + status = _cairo_path_fixed_fill_to_polygon (&clip_path->path, + clip_path->tolerance, + &polygon); + + fill_rule = clip_path->fill_rule; + polygon.limits = NULL; + polygon.num_limits = 0; + } else { + cairo_polygon_t next; + + _cairo_polygon_init (&next, NULL, 0); + status = _cairo_path_fixed_fill_to_polygon (&clip_path->path, + clip_path->tolerance, + &next); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = _cairo_polygon_intersect (&polygon, fill_rule, + &next, clip_path->fill_rule); + _cairo_polygon_fini (&next); + fill_rule = CAIRO_FILL_RULE_WINDING; + } + if (unlikely (status)) + goto error; + } + + clip_path = clip_path->prev; + } + + if (polygon.num_edges) { + _cairo_polygon_translate (&polygon, -extents->x, -extents->y); + status = _cairo_composite_rectangles_init_for_polygon (&composite, surface, + CAIRO_OPERATOR_IN, + &_cairo_pattern_white.base, + &polygon, + NULL); + if (unlikely (status)) + goto cleanup_polygon; + + status = composite_polygon (compositor, &composite, + &polygon, fill_rule, antialias); + _cairo_composite_rectangles_fini (&composite); + _cairo_polygon_fini (&polygon); + if (unlikely (status)) + goto error; + } + + return surface; + +cleanup_polygon: + _cairo_polygon_fini (&polygon); +error: + cairo_surface_destroy (surface); + return _cairo_surface_create_in_error (status); +} + +static cairo_int_status_t +fixup_unbounded_mask (const cairo_spans_compositor_t *compositor, + const cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_composite_rectangles_t composite; + cairo_surface_t *clip; + cairo_int_status_t status; + + clip = get_clip_surface (compositor, extents->surface, extents->clip, + &extents->unbounded); + if (unlikely (clip->status)) + return clip->status; + + status = _cairo_composite_rectangles_init_for_boxes (&composite, + extents->surface, + CAIRO_OPERATOR_DEST_OUT, + &_cairo_pattern_white.base, + boxes, + NULL); + if (unlikely (status)) + goto cleanup_clip; + + _cairo_pattern_init_for_surface (&composite.mask_pattern.surface, clip); + composite.mask_pattern.base.filter = CAIRO_FILTER_NEAREST; + composite.mask_pattern.base.extend = CAIRO_EXTEND_NONE; + + status = composite_boxes (compositor, &composite, boxes); + + _cairo_pattern_fini (&composite.mask_pattern.base); + _cairo_composite_rectangles_fini (&composite); + +cleanup_clip: + cairo_surface_destroy (clip); + return status; +} + +static cairo_int_status_t +fixup_unbounded_polygon (const cairo_spans_compositor_t *compositor, + const cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_polygon_t polygon, intersect; + cairo_composite_rectangles_t composite; + cairo_fill_rule_t fill_rule; + cairo_antialias_t antialias; + cairo_int_status_t status; + + /* Can we treat the clip as a regular clear-polygon and use it to fill? */ + status = _cairo_clip_get_polygon (extents->clip, &polygon, + &fill_rule, &antialias); + if (status == CAIRO_INT_STATUS_UNSUPPORTED) + return status; + + status= _cairo_polygon_init_boxes (&intersect, boxes); + if (unlikely (status)) + goto cleanup_polygon; + + status = _cairo_polygon_intersect (&polygon, fill_rule, + &intersect, CAIRO_FILL_RULE_WINDING); + _cairo_polygon_fini (&intersect); + + if (unlikely (status)) + goto cleanup_polygon; + + status = _cairo_composite_rectangles_init_for_polygon (&composite, + extents->surface, + CAIRO_OPERATOR_DEST_OUT, + &_cairo_pattern_white.base, + &polygon, + NULL); + if (unlikely (status)) + goto cleanup_polygon; + + status = composite_polygon (compositor, &composite, + &polygon, fill_rule, antialias); + + _cairo_composite_rectangles_fini (&composite); +cleanup_polygon: + _cairo_polygon_fini (&polygon); + + return status; +} + +static cairo_int_status_t +fixup_unbounded_boxes (const cairo_spans_compositor_t *compositor, + const cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_boxes_t tmp, clear; + cairo_box_t box; + cairo_int_status_t status; + + assert (boxes->is_pixel_aligned); + + if (extents->bounded.width == extents->unbounded.width && + extents->bounded.height == extents->unbounded.height) + { + return CAIRO_STATUS_SUCCESS; + } + + /* subtract the drawn boxes from the unbounded area */ + _cairo_boxes_init (&clear); + + box.p1.x = _cairo_fixed_from_int (extents->unbounded.x + extents->unbounded.width); + box.p1.y = _cairo_fixed_from_int (extents->unbounded.y); + box.p2.x = _cairo_fixed_from_int (extents->unbounded.x); + box.p2.y = _cairo_fixed_from_int (extents->unbounded.y + extents->unbounded.height); + + if (boxes->num_boxes) { + _cairo_boxes_init (&tmp); + + status = _cairo_boxes_add (&tmp, CAIRO_ANTIALIAS_DEFAULT, &box); + assert (status == CAIRO_INT_STATUS_SUCCESS); + + tmp.chunks.next = &boxes->chunks; + tmp.num_boxes += boxes->num_boxes; + + status = _cairo_bentley_ottmann_tessellate_boxes (&tmp, + CAIRO_FILL_RULE_WINDING, + &clear); + tmp.chunks.next = NULL; + if (unlikely (status)) + goto error; + } else { + box.p1.x = _cairo_fixed_from_int (extents->unbounded.x); + box.p2.x = _cairo_fixed_from_int (extents->unbounded.x + extents->unbounded.width); + + status = _cairo_boxes_add (&clear, CAIRO_ANTIALIAS_DEFAULT, &box); + assert (status == CAIRO_INT_STATUS_SUCCESS); + } + + /* Now intersect with the clip boxes */ + if (extents->clip->num_boxes) { + _cairo_boxes_init_for_array (&tmp, + extents->clip->boxes, + extents->clip->num_boxes); + status = _cairo_boxes_intersect (&clear, &tmp, &clear); + if (unlikely (status)) + goto error; + } + + /* If we have a clip polygon, we need to intersect with that as well */ + if (extents->clip->path) { + status = fixup_unbounded_polygon (compositor, extents, &clear); + if (status == CAIRO_INT_STATUS_UNSUPPORTED) + status = fixup_unbounded_mask (compositor, extents, &clear); + } else { + status = compositor->fill_boxes (extents->surface, + CAIRO_OPERATOR_CLEAR, + CAIRO_COLOR_TRANSPARENT, + &clear); + } + +error: + _cairo_boxes_fini (&clear); + return status; +} + +static cairo_surface_t * +unwrap_surface (const cairo_pattern_t *pattern) +{ + cairo_surface_t *surface; + + surface = ((const cairo_surface_pattern_t *) pattern)->surface; + if (_cairo_surface_is_paginated (surface)) + surface = _cairo_paginated_surface_get_recording (surface); + if (_cairo_surface_is_snapshot (surface)) + surface = _cairo_surface_snapshot_get_target (surface); + if (_cairo_surface_is_observer (surface)) + surface = _cairo_surface_observer_get_target (surface); + return surface; +} + +static cairo_bool_t +is_recording_pattern (const cairo_pattern_t *pattern) +{ + cairo_surface_t *surface; + + if (pattern->type != CAIRO_PATTERN_TYPE_SURFACE) + return FALSE; + + surface = ((const cairo_surface_pattern_t *) pattern)->surface; + return _cairo_surface_is_recording (surface); +} + +static cairo_bool_t +recording_pattern_contains_sample (const cairo_pattern_t *pattern, + const cairo_rectangle_int_t *sample) +{ + cairo_recording_surface_t *surface; + + if (! is_recording_pattern (pattern)) + return FALSE; + + if (pattern->extend == CAIRO_EXTEND_NONE) + return TRUE; + + surface = (cairo_recording_surface_t *) unwrap_surface (pattern); + if (surface->unbounded) + return TRUE; + + if (sample->x >= surface->extents.x && + sample->y >= surface->extents.y && + sample->x + sample->width <= surface->extents.x + surface->extents.width && + sample->y + sample->height <= surface->extents.y + surface->extents.height) + { + return TRUE; + } + + return FALSE; +} + +static cairo_bool_t +op_reduces_to_source (const cairo_composite_rectangles_t *extents) +{ + if (extents->op == CAIRO_OPERATOR_SOURCE) + return TRUE; + + if (extents->surface->is_clear) + return extents->op == CAIRO_OPERATOR_OVER || extents->op == CAIRO_OPERATOR_ADD; + + return FALSE; +} + +static cairo_int_status_t +composite_aligned_boxes (const cairo_spans_compositor_t *compositor, + const cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_surface_t *dst = extents->surface; + cairo_operator_t op = extents->op; + const cairo_pattern_t *source = &extents->source_pattern.base; + cairo_int_status_t status; + cairo_bool_t need_clip_mask = extents->clip->path != NULL; + cairo_bool_t op_is_source; + cairo_bool_t no_mask; + cairo_bool_t inplace; + + if (need_clip_mask && ! extents->is_bounded) + return CAIRO_INT_STATUS_UNSUPPORTED; + + op_is_source = op_reduces_to_source (extents); + no_mask = extents->mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID && + CAIRO_ALPHA_IS_OPAQUE (extents->mask_pattern.solid.color.alpha); + inplace = ! need_clip_mask && op_is_source && no_mask; + + if (op == CAIRO_OPERATOR_SOURCE && (need_clip_mask || ! no_mask)) { + /* SOURCE with a mask is actually a LERP in cairo semantics */ + /* XXX push this choice down to the backend */ + return CAIRO_INT_STATUS_UNSUPPORTED; + } + + /* Are we just copying a recording surface? */ + if (inplace && + recording_pattern_contains_sample (&extents->source_pattern.base, + &extents->source_sample_area)) + { + cairo_clip_t *recording_clip; + const cairo_pattern_t *source = &extents->source_pattern.base; + + /* XXX could also do tiling repeat modes... */ + + /* first clear the area about to be overwritten */ + if (! dst->is_clear) + status = compositor->fill_boxes (dst, + CAIRO_OPERATOR_CLEAR, + CAIRO_COLOR_TRANSPARENT, + boxes); + + recording_clip = _cairo_clip_from_boxes (boxes); + status = _cairo_recording_surface_replay_with_clip (unwrap_surface (source), + &source->matrix, + dst, recording_clip); + _cairo_clip_destroy (recording_clip); + + return status; + } + + if (! need_clip_mask && no_mask && source->type == CAIRO_PATTERN_TYPE_SOLID) { + const cairo_color_t *color; + + color = &((cairo_solid_pattern_t *) source)->color; + if (op_is_source) + op = CAIRO_OPERATOR_SOURCE; + status = compositor->fill_boxes (dst, op, color, boxes); +#if 0 + } else if (inplace && source->type == CAIRO_PATTERN_TYPE_SURFACE) { + status = upload_inplace (compositor, extents, boxes); +#endif + } else { + cairo_surface_t *src; + cairo_surface_t *mask = NULL; + int src_x, src_y; + int mask_x = 0, mask_y = 0; + + /* All typical cases will have been resolved before now... */ + if (need_clip_mask) { + mask = get_clip_surface (compositor, dst, extents->clip, + &extents->bounded); + if (unlikely (mask->status)) + return mask->status; + + mask_x = -extents->bounded.x; + mask_y = -extents->bounded.y; + } + + /* XXX but this is still ugly */ + if (! no_mask) { + src = compositor->pattern_to_surface (dst, + &extents->mask_pattern.base, + TRUE, + &extents->bounded, + &extents->mask_sample_area, + &src_x, &src_y); + if (unlikely (src->status)) { + cairo_surface_destroy (mask); + return src->status; + } + + if (mask != NULL) { + status = compositor->composite_boxes (mask, CAIRO_OPERATOR_IN, + src, NULL, + src_x, src_y, + 0, 0, + mask_x, mask_y, + boxes, &extents->bounded); + + cairo_surface_destroy (src); + } else { + mask = src; + mask_x = src_x; + mask_y = src_y; + } + } + + if (mask && op == CAIRO_OPERATOR_CLEAR) { + source = &_cairo_pattern_white.base; + op = CAIRO_OPERATOR_DEST_OUT; + } + + src = compositor->pattern_to_surface (dst, source, FALSE, + &extents->bounded, + &extents->source_sample_area, + &src_x, &src_y); + if (likely (src->status == CAIRO_STATUS_SUCCESS)) { + status = compositor->composite_boxes (dst, op, src, mask, + src_x, src_y, + mask_x, mask_y, + 0, 0, + boxes, &extents->bounded); + cairo_surface_destroy (src); + } else + status = src->status; + + cairo_surface_destroy (mask); + } + + if (status == CAIRO_INT_STATUS_SUCCESS && ! extents->is_bounded) + status = fixup_unbounded_boxes (compositor, extents, boxes); + + return status; +} + +static cairo_bool_t +composite_needs_clip (const cairo_composite_rectangles_t *composit, + const cairo_box_t *extents) +{ + cairo_bool_t needs_clip; + + needs_clip = ! composit->is_bounded; + if (needs_clip) + needs_clip = ! _cairo_clip_contains_box (composit->clip, extents); + + return needs_clip; +} + +static cairo_int_status_t +composite_boxes (const cairo_spans_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_abstract_span_renderer_t renderer; + cairo_rectangular_scan_converter_t converter; + const struct _cairo_boxes_chunk *chunk; + cairo_int_status_t status; + cairo_box_t box; + + _cairo_box_from_rectangle (&box, &extents->bounded); + if (composite_needs_clip (extents, &box)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + _cairo_rectangular_scan_converter_init (&converter, &extents->bounded); + for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { + const cairo_box_t *box = chunk->base; + int i; + + for (i = 0; i < chunk->count; i++) { + status = _cairo_rectangular_scan_converter_add_box (&converter, &box[i], 1); + if (unlikely (status)) + goto cleanup_converter; + } + } + + status = compositor->renderer_init (&renderer, extents, FALSE); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = converter.base.generate (&converter.base, &renderer.base); + compositor->renderer_fini (&renderer, status); + +cleanup_converter: + converter.base.destroy (&converter.base); + return status; +} + +static cairo_int_status_t +composite_polygon (const cairo_spans_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_polygon_t *polygon, + cairo_fill_rule_t fill_rule, + cairo_antialias_t antialias) +{ + cairo_abstract_span_renderer_t renderer; + cairo_scan_converter_t *converter; + cairo_bool_t needs_clip; + cairo_int_status_t status; + + needs_clip = composite_needs_clip (extents, &polygon->extents); + if (needs_clip) { + return CAIRO_INT_STATUS_UNSUPPORTED; + converter = _cairo_clip_tor_scan_converter_create (extents->clip, + polygon, + fill_rule, antialias); + } else { + const cairo_rectangle_int_t *r = &extents->bounded; + + if (antialias == CAIRO_ANTIALIAS_FAST) { + converter = _cairo_tor22_scan_converter_create (r->x, r->y, + r->x + r->width, + r->y + r->height, + fill_rule, antialias); + status = _cairo_tor22_scan_converter_add_polygon (converter, polygon); + } else if (antialias == CAIRO_ANTIALIAS_NONE) { + converter = _cairo_mono_scan_converter_create (r->x, r->y, + r->x + r->width, + r->y + r->height, + fill_rule); + status = _cairo_mono_scan_converter_add_polygon (converter, polygon); + } else { + converter = _cairo_tor_scan_converter_create (r->x, r->y, + r->x + r->width, + r->y + r->height, + fill_rule, antialias); + status = _cairo_tor_scan_converter_add_polygon (converter, polygon); + } + } + if (unlikely (status)) + goto cleanup_converter; + + status = compositor->renderer_init (&renderer, extents, needs_clip); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = converter->generate (converter, &renderer.base); + compositor->renderer_fini (&renderer, status); + +cleanup_converter: + converter->destroy (converter); + return status; +} + +static cairo_int_status_t +trim_extents_to_boxes (cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_box_t box; + + _cairo_boxes_extents (boxes, &box); + return _cairo_composite_rectangles_intersect_mask_extents (extents, &box); +} + +static cairo_int_status_t +trim_extents_to_polygon (cairo_composite_rectangles_t *extents, + cairo_polygon_t *polygon) +{ + return _cairo_composite_rectangles_intersect_mask_extents (extents, + &polygon->extents); +} + +static cairo_int_status_t +clip_and_composite_boxes (const cairo_spans_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_int_status_t status; + cairo_polygon_t polygon; + + status = trim_extents_to_boxes (extents, boxes); + if (unlikely (status)) + return status; + + if (boxes->num_boxes == 0) { + if (extents->is_bounded) + return CAIRO_STATUS_SUCCESS; + + return fixup_unbounded_boxes (compositor, extents, boxes); + } + + /* Can we reduce drawing through a clip-mask to simply drawing the clip? */ + if (extents->clip->path != NULL && extents->is_bounded) { + cairo_polygon_t polygon; + cairo_fill_rule_t fill_rule; + cairo_antialias_t antialias; + cairo_clip_t *clip; + + clip = _cairo_clip_copy (extents->clip); + clip = _cairo_clip_intersect_boxes (clip, boxes); + status = _cairo_clip_get_polygon (clip, &polygon, + &fill_rule, &antialias); + _cairo_clip_path_destroy (clip->path); + clip->path = NULL; + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + cairo_clip_t *saved_clip = extents->clip; + extents->clip = clip; + + status = clip_and_composite_polygon (compositor, extents, &polygon, + fill_rule, antialias); + + clip = extents->clip; + extents->clip = saved_clip; + + _cairo_polygon_fini (&polygon); + } + _cairo_clip_destroy (clip); + + if (status != CAIRO_INT_STATUS_UNSUPPORTED) + return status; + } + + if (boxes->is_pixel_aligned) { + status = composite_aligned_boxes (compositor, extents, boxes); + if (status != CAIRO_INT_STATUS_UNSUPPORTED) + return status; + } + + status = composite_boxes (compositor, extents, boxes); + if (status != CAIRO_INT_STATUS_UNSUPPORTED) + return status; + + status = _cairo_polygon_init_boxes (&polygon, boxes); + if (unlikely (status)) + return status; + + status = composite_polygon (compositor, extents, &polygon, + CAIRO_FILL_RULE_WINDING, + CAIRO_ANTIALIAS_DEFAULT); + _cairo_polygon_fini (&polygon); + + return status; +} + +static cairo_int_status_t +clip_and_composite_polygon (const cairo_spans_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_polygon_t *polygon, + cairo_fill_rule_t fill_rule, + cairo_antialias_t antialias) +{ + cairo_int_status_t status; + + if (_cairo_polygon_is_empty (polygon)) { + cairo_boxes_t boxes; + + if (extents->is_bounded) + return CAIRO_STATUS_SUCCESS; + + _cairo_boxes_init (&boxes); + return fixup_unbounded_boxes (compositor, extents, &boxes); + } + +#if 0 /* XXX not accurate currently... */ + if (antialias == CAIRO_ANTIALIAS_NONE) + return CAIRO_INT_STATUS_UNSUPPORTED; +#endif + + if (extents->is_bounded && extents->clip->path) { + cairo_polygon_t clipper; + cairo_antialias_t clip_antialias; + cairo_fill_rule_t clip_fill_rule; + + status = _cairo_clip_get_polygon (extents->clip, + &clipper, + &clip_fill_rule, + &clip_antialias); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + cairo_clip_t *old_clip; + + if (clip_antialias == antialias) { + status = _cairo_polygon_intersect (polygon, fill_rule, + &clipper, clip_fill_rule); + _cairo_polygon_fini (&clipper); + if (unlikely (status)) + return status; + + old_clip = extents->clip; + extents->clip = _cairo_clip_copy_region (extents->clip); + _cairo_clip_destroy (old_clip); + } else { + _cairo_polygon_fini (&clipper); + } + } + } + + status = trim_extents_to_polygon (extents, polygon); + if (unlikely (status)) + return status; + + return composite_polygon (compositor, extents, + polygon, fill_rule, antialias); +} + +/* high-level compositor interface */ + +static cairo_int_status_t +_cairo_spans_compositor_paint (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents) +{ + const cairo_spans_compositor_t *compositor = (cairo_spans_compositor_t*)_compositor; + cairo_boxes_t boxes; + cairo_int_status_t status; + + _cairo_clip_steal_boxes (extents->clip, &boxes); + status = clip_and_composite_boxes (compositor, extents, &boxes); + _cairo_clip_unsteal_boxes (extents->clip, &boxes); + + return status; +} + +static cairo_int_status_t +_cairo_spans_compositor_mask (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents) +{ + const cairo_spans_compositor_t *compositor = (cairo_spans_compositor_t*)_compositor; + cairo_int_status_t status; + cairo_boxes_t boxes; + + _cairo_clip_steal_boxes (extents->clip, &boxes); + status = clip_and_composite_boxes (compositor, extents, &boxes); + _cairo_clip_unsteal_boxes (extents->clip, &boxes); + + return status; +} + +static cairo_int_status_t +_cairo_spans_compositor_stroke (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + 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_spans_compositor_t *compositor = (cairo_spans_compositor_t*)_compositor; + cairo_int_status_t status; + + status = CAIRO_INT_STATUS_UNSUPPORTED; + if (_cairo_path_fixed_stroke_is_rectilinear (path)) { + cairo_boxes_t boxes; + + _cairo_boxes_init (&boxes); + if (! _cairo_clip_contains_rectangle (extents->clip, &extents->mask)) + _cairo_boxes_limit (&boxes, + extents->clip->boxes, + extents->clip->num_boxes); + + status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path, + style, + ctm, + antialias, + &boxes); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = clip_and_composite_boxes (compositor, extents, &boxes); + _cairo_boxes_fini (&boxes); + } + + if (status == CAIRO_INT_STATUS_UNSUPPORTED) { + cairo_polygon_t polygon; + + if (extents->mask.width > extents->unbounded.width || + extents->mask.height > extents->unbounded.height) + { + _cairo_polygon_init_with_clip (&polygon, extents->clip); + } + else + { + _cairo_polygon_init_with_clip (&polygon, NULL); + } + status = _cairo_path_fixed_stroke_to_polygon (path, + style, + ctm, ctm_inverse, + tolerance, + &polygon); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + status = clip_and_composite_polygon (compositor, extents, &polygon, + CAIRO_FILL_RULE_WINDING, + antialias); + } + _cairo_polygon_fini (&polygon); + } + + return status; +} + +static cairo_int_status_t +_cairo_spans_compositor_fill (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + cairo_antialias_t antialias) +{ + const cairo_spans_compositor_t *compositor = (cairo_spans_compositor_t*)_compositor; + cairo_int_status_t status; + + status = CAIRO_INT_STATUS_UNSUPPORTED; + if (_cairo_path_fixed_fill_is_rectilinear (path)) { + cairo_boxes_t boxes; + + _cairo_boxes_init (&boxes); + if (! _cairo_clip_contains_rectangle (extents->clip, &extents->mask)) + _cairo_boxes_limit (&boxes, + extents->clip->boxes, + extents->clip->num_boxes); + status = _cairo_path_fixed_fill_rectilinear_to_boxes (path, + fill_rule, + antialias, + &boxes); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = clip_and_composite_boxes (compositor, extents, &boxes); + _cairo_boxes_fini (&boxes); + } + if (status == CAIRO_INT_STATUS_UNSUPPORTED) { + cairo_polygon_t polygon; + + if (extents->mask.width > extents->unbounded.width || + extents->mask.height > extents->unbounded.height) + { + cairo_box_t limits; + _cairo_box_from_rectangle (&limits, &extents->unbounded); + _cairo_polygon_init (&polygon, &limits, 1); + } + else + { + _cairo_polygon_init (&polygon, NULL, 0); + } + + status = _cairo_path_fixed_fill_to_polygon (path, tolerance, &polygon); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + status = _cairo_polygon_intersect_with_boxes (&polygon, &fill_rule, + extents->clip->boxes, + extents->clip->num_boxes); + } + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + if (extents->is_bounded) { + if (extents->clip->boxes != &extents->clip->embedded_box) + free (extents->clip->boxes); + + extents->clip->num_boxes = 1; + extents->clip->boxes = &extents->clip->embedded_box; + extents->clip->boxes[0] = polygon.extents; + } + status = clip_and_composite_polygon (compositor, extents, &polygon, + fill_rule, antialias); + } + _cairo_polygon_fini (&polygon); + } + + return status; +} + +void +_cairo_spans_compositor_init (cairo_spans_compositor_t *compositor, + const cairo_compositor_t *delegate) +{ + compositor->base.delegate = delegate; + + compositor->base.paint = _cairo_spans_compositor_paint; + compositor->base.mask = _cairo_spans_compositor_mask; + compositor->base.fill = _cairo_spans_compositor_fill; + compositor->base.stroke = _cairo_spans_compositor_stroke; + compositor->base.glyphs = NULL; +} diff --git a/src/cairo-spans-private.h b/src/cairo-spans-private.h index 00a4df86..c42b5afa 100644 --- a/src/cairo-spans-private.h +++ b/src/cairo-spans-private.h @@ -36,11 +36,9 @@ /* A structure representing an open-ended horizontal span of constant * pixel coverage. */ typedef struct _cairo_half_open_span { - /* The inclusive x-coordinate of the start of the span. */ - int x; - - /* The pixel coverage for the pixels to the right. */ - int coverage; + int32_t x; /* The inclusive x-coordinate of the start of the span. */ + uint8_t coverage; /* The pixel coverage for the pixels to the right. */ + uint8_t inverse; /* between regular mask and clip */ } cairo_half_open_span_t; /* Span renderer interface. Instances of renderers are provided by @@ -73,17 +71,6 @@ struct _cairo_scan_converter { /* Destroy this scan converter. */ cairo_destroy_func_t destroy; - /* Add a single edge to the converter. */ - cairo_status_t (*add_edge) (void *abstract_converter, - const cairo_point_t *p1, - const cairo_point_t *p2, - int top, int bottom, - int dir); - - /* Add a polygon (set of edges) to the converter. */ - cairo_status_t (*add_polygon) (void *abstract_converter, - const cairo_polygon_t *polygon); - /* Generates coverage spans for rows for the added edges and calls * the renderer function for each row. After generating spans the * only valid thing to do with the converter is to destroy it. */ @@ -101,13 +88,43 @@ _cairo_tor_scan_converter_create (int xmin, int ymin, int xmax, int ymax, - cairo_fill_rule_t fill_rule); + cairo_fill_rule_t fill_rule, + cairo_antialias_t antialias); +cairo_private cairo_status_t +_cairo_tor_scan_converter_add_polygon (void *converter, + const cairo_polygon_t *polygon); + +cairo_private cairo_scan_converter_t * +_cairo_tor22_scan_converter_create (int xmin, + int ymin, + int xmax, + int ymax, + cairo_fill_rule_t fill_rule, + cairo_antialias_t antialias); +cairo_private cairo_status_t +_cairo_tor22_scan_converter_add_polygon (void *converter, + const cairo_polygon_t *polygon); + +cairo_private cairo_scan_converter_t * +_cairo_mono_scan_converter_create (int xmin, + int ymin, + int xmax, + int ymax, + cairo_fill_rule_t fill_rule); +cairo_private cairo_status_t +_cairo_mono_scan_converter_add_polygon (void *converter, + const cairo_polygon_t *polygon); + +cairo_private cairo_scan_converter_t * +_cairo_clip_tor_scan_converter_create (cairo_clip_t *clip, + cairo_polygon_t *polygon, + cairo_fill_rule_t fill_rule, + cairo_antialias_t antialias); typedef struct _cairo_rectangular_scan_converter { cairo_scan_converter_t base; - int xmin, xmax; - int ymin, ymax; + cairo_box_t extents; struct _cairo_rectangular_scan_converter_chunk { struct _cairo_rectangular_scan_converter_chunk *next; diff --git a/src/cairo-spans.c b/src/cairo-spans.c index f6586506..b8d41800 100644 --- a/src/cairo-spans.c +++ b/src/cairo-spans.c @@ -32,87 +32,6 @@ #include "cairo-fixed-private.h" #include "cairo-types-private.h" -static cairo_scan_converter_t * -_create_scan_converter (cairo_fill_rule_t fill_rule, - cairo_antialias_t antialias, - const cairo_composite_rectangles_t *rects) -{ - if (antialias == CAIRO_ANTIALIAS_NONE) { - ASSERT_NOT_REACHED; - return NULL; - } - - return _cairo_tor_scan_converter_create (rects->bounded.x, - rects->bounded.y, - rects->bounded.x + rects->bounded.width, - rects->bounded.y + rects->bounded.height, - fill_rule); -} - -/* XXX Add me to the compositor interface. Ok, first create the compositor - * interface, and then add this with associated fallback! - */ -cairo_status_t -_cairo_surface_composite_polygon (cairo_surface_t *surface, - cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_fill_rule_t fill_rule, - cairo_antialias_t antialias, - const cairo_composite_rectangles_t *rects, - cairo_polygon_t *polygon, - cairo_region_t *clip_region) -{ - cairo_span_renderer_t *renderer; - cairo_scan_converter_t *converter; - cairo_status_t status; - cairo_clip_path_t *clip_path = rects->clip->path; - - if (rects->is_bounded) { - if (polygon->num_edges == 0) - return CAIRO_STATUS_SUCCESS; - - if (clip_path) { /* XXX */ - cairo_polygon_t clipper; - cairo_fill_rule_t clipper_fill_rule; - cairo_antialias_t clipper_antialias; - - if (_cairo_clip_get_polygon (rects->clip, &clipper, - &clipper_fill_rule, - &clipper_antialias) == CAIRO_INT_STATUS_SUCCESS) { - if (clipper_antialias != CAIRO_ANTIALIAS_NONE && - _cairo_polygon_intersect (polygon, fill_rule, - &clipper, clipper_fill_rule) == CAIRO_STATUS_SUCCESS) - { - rects->clip->path = NULL; - } - - _cairo_polygon_fini (&clipper); - } - } - } - - converter = _create_scan_converter (fill_rule, antialias, rects); - status = converter->add_polygon (converter, polygon); - if (unlikely (status)) - goto CLEANUP_CONVERTER; - - renderer = _cairo_surface_create_span_renderer (op, pattern, surface, - antialias, rects, - clip_region); - status = converter->generate (converter, renderer); - if (unlikely (status)) - goto CLEANUP_RENDERER; - - status = renderer->finish (renderer); - - CLEANUP_RENDERER: - renderer->destroy (renderer); - CLEANUP_CONVERTER: - converter->destroy (converter); - rects->clip->path = clip_path; - return status; -} - static void _cairo_nil_destroy (void *abstract) { @@ -120,31 +39,6 @@ _cairo_nil_destroy (void *abstract) } static cairo_status_t -_cairo_nil_scan_converter_add_polygon (void *abstract_converter, - const cairo_polygon_t *polygon) -{ - (void) abstract_converter; - (void) polygon; - return _cairo_scan_converter_status (abstract_converter); -} - -static cairo_status_t -_cairo_nil_scan_converter_add_edge (void *abstract_converter, - const cairo_point_t *p1, - const cairo_point_t *p2, - int top, int bottom, - int dir) -{ - (void) abstract_converter; - (void) p1; - (void) p2; - (void) top; - (void) bottom; - (void) dir; - return _cairo_scan_converter_status (abstract_converter); -} - -static cairo_status_t _cairo_nil_scan_converter_generate (void *abstract_converter, cairo_span_renderer_t *renderer) { @@ -168,8 +62,6 @@ _cairo_scan_converter_set_error (void *abstract_converter, if (error == CAIRO_STATUS_SUCCESS) ASSERT_NOT_REACHED; if (converter->status == CAIRO_STATUS_SUCCESS) { - converter->add_polygon = _cairo_nil_scan_converter_add_polygon; - converter->add_edge = _cairo_nil_scan_converter_add_edge; converter->generate = _cairo_nil_scan_converter_generate; converter->status = error; } diff --git a/src/cairo-spline.c b/src/cairo-spline.c index 2467178f..34ad5856 100644 --- a/src/cairo-spline.c +++ b/src/cairo-spline.c @@ -36,15 +36,61 @@ #include "cairoint.h" +#include "cairo-box-private.h" #include "cairo-slope-private.h" cairo_bool_t +_cairo_spline_intersects (const cairo_point_t *a, + const cairo_point_t *b, + const cairo_point_t *c, + const cairo_point_t *d, + const cairo_box_t *box) +{ + cairo_box_t bounds; + + if (_cairo_box_contains_point (box, a) || + _cairo_box_contains_point (box, b) || + _cairo_box_contains_point (box, c) || + _cairo_box_contains_point (box, d)) + { + return TRUE; + } + + bounds.p2 = bounds.p1 = *a; + _cairo_box_add_point (&bounds, b); + _cairo_box_add_point (&bounds, c); + _cairo_box_add_point (&bounds, d); + + if (bounds.p2.x <= box->p1.x || bounds.p1.x >= box->p2.x || + bounds.p2.y <= box->p1.y || bounds.p1.y >= box->p2.y) + { + return FALSE; + } + +#if 0 /* worth refining? */ + bounds.p2 = bounds.p1 = *a; + _cairo_box_add_curve_to (&bounds, b, c, d); + if (bounds.p2.x <= box->p1.x || bounds.p1.x >= box->p2.x || + bounds.p2.y <= box->p1.y || bounds.p1.y >= box->p2.y) + { + return FALSE; + } +#endif + + return TRUE; +} + +cairo_bool_t _cairo_spline_init (cairo_spline_t *spline, cairo_spline_add_point_func_t add_point_func, void *closure, const cairo_point_t *a, const cairo_point_t *b, const cairo_point_t *c, const cairo_point_t *d) { + /* If both tangents are zero, this is just a straight line */ + if (a->x == b->x && a->y == b->y && c->x == d->x && c->y == d->y) + return FALSE; + spline->add_point_func = add_point_func; spline->closure = closure; @@ -69,6 +115,8 @@ _cairo_spline_init (cairo_spline_t *spline, else return FALSE; /* just treat this as a straight-line from a -> d */ + /* XXX if the initial, final and vector are all equal, this is just a line */ + return TRUE; } @@ -213,7 +261,6 @@ _cairo_spline_decompose (cairo_spline_t *spline, double tolerance) { cairo_spline_knots_t s1; cairo_status_t status; - cairo_slope_t slope; s1 = spline->knots; spline->last_point = s1.a; @@ -221,8 +268,8 @@ _cairo_spline_decompose (cairo_spline_t *spline, double tolerance) if (unlikely (status)) return status; - _cairo_slope_init (&slope, &spline->knots.c, &spline->knots.d); - return spline->add_point_func (spline->closure, &spline->knots.d, &slope); + return spline->add_point_func (spline->closure, + &spline->knots.d, &spline->final_slope); } /* Note: this function is only good for computing bounds in device space. */ diff --git a/src/cairo-stroke-style.c b/src/cairo-stroke-style.c index b9c3a0db..9b7e407c 100644 --- a/src/cairo-stroke-style.c +++ b/src/cairo-stroke-style.c @@ -101,6 +101,7 @@ _cairo_stroke_style_fini (cairo_stroke_style_t *style) */ void _cairo_stroke_style_max_distance_from_path (const cairo_stroke_style_t *style, + const cairo_path_fixed_t *path, const cairo_matrix_t *ctm, double *dx, double *dy) { @@ -110,6 +111,7 @@ _cairo_stroke_style_max_distance_from_path (const cairo_stroke_style_t *style, style_expansion = M_SQRT1_2; if (style->line_join == CAIRO_LINE_JOIN_MITER && + ! path->stroke_is_rectilinear && style_expansion < M_SQRT2 * style->miter_limit) { style_expansion = M_SQRT2 * style->miter_limit; @@ -117,8 +119,12 @@ _cairo_stroke_style_max_distance_from_path (const cairo_stroke_style_t *style, style_expansion *= style->line_width; - *dx = style_expansion * hypot (ctm->xx, ctm->xy); - *dy = style_expansion * hypot (ctm->yy, ctm->yx); + if (_cairo_matrix_has_unity_scale (ctm)) { + *dx = *dy = style_expansion; + } else { + *dx = style_expansion * hypot (ctm->xx, ctm->xy); + *dy = style_expansion * hypot (ctm->yy, ctm->yx); + } } /* diff --git a/src/cairo-surface-backend-private.h b/src/cairo-surface-backend-private.h new file mode 100644 index 00000000..cdcd3f8c --- /dev/null +++ b/src/cairo-surface-backend-private.h @@ -0,0 +1,196 @@ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it either under the terms of the GNU Lesser General Public + * License version 2.1 as published by the Free Software Foundation + * (the "LGPL") or, at your option, under the terms of the Mozilla + * Public License Version 1.1 (the "MPL"). If you do not alter this + * notice, a recipient may use your version of this file under either + * the MPL or the LGPL. + * + * You should have received a copy of the LGPL along with this library + * in the file COPYING-LGPL-2.1; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA + * You should have received a copy of the MPL along with this library + * in the file COPYING-MPL-1.1 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + */ + +#ifndef CAIRO_SURFACE_BACKEND_PRIVATE_H +#define CAIRO_SURFACE_BACKEND_PRIVATE_H + +CAIRO_BEGIN_DECLS + +struct _cairo_surface_backend { + cairo_surface_type_t type; + + cairo_warn cairo_status_t + (*finish) (void *surface); + + cairo_t * + (*create_context) (void *surface); + + cairo_surface_t * + (*create_similar) (void *surface, + cairo_content_t content, + int width, + int height); + cairo_surface_t * + (*create_similar_image) (void *surface, + cairo_format_t format, + int width, + int height); + + cairo_surface_t * + (*map_to_image) (void *surface, + const cairo_rectangle_int_t *extents); + cairo_int_status_t + (*unmap_image) (void *surface, + cairo_image_surface_t *image); + + cairo_warn cairo_status_t + (*acquire_source_image) (void *abstract_surface, + cairo_image_surface_t **image_out, + void **image_extra); + + cairo_warn void + (*release_source_image) (void *abstract_surface, + cairo_image_surface_t *image_out, + void *image_extra); + + cairo_surface_t * + (*snapshot) (void *surface); + + cairo_warn cairo_int_status_t + (*copy_page) (void *surface); + + cairo_warn cairo_int_status_t + (*show_page) (void *surface); + + /* Get the extents of the current surface. For many surface types + * this will be as simple as { x=0, y=0, width=surface->width, + * height=surface->height}. + * + * If this function is not implemented, or if it returns + * FALSE the surface is considered to be + * boundless and infinite bounds are used for it. + */ + cairo_bool_t + (*get_extents) (void *surface, + cairo_rectangle_int_t *extents); + + void + (*get_font_options) (void *surface, + cairo_font_options_t *options); + + cairo_warn cairo_status_t + (*flush) (void *surface); + + cairo_warn cairo_status_t + (*mark_dirty_rectangle) (void *surface, + int x, + int y, + int width, + int height); + + cairo_warn cairo_int_status_t + (*paint) (void *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_clip_t *clip); + + cairo_warn cairo_int_status_t + (*mask) (void *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_pattern_t *mask, + const cairo_clip_t *clip); + + cairo_warn cairo_int_status_t + (*stroke) (void *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_warn cairo_int_status_t + (*fill) (void *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_warn cairo_int_status_t + (*fill_stroke) (void *surface, + cairo_operator_t fill_op, + const cairo_pattern_t *fill_source, + cairo_fill_rule_t fill_rule, + double fill_tolerance, + cairo_antialias_t fill_antialias, + const cairo_path_fixed_t*path, + cairo_operator_t stroke_op, + const cairo_pattern_t *stroke_source, + const cairo_stroke_style_t *stroke_style, + const cairo_matrix_t *stroke_ctm, + const cairo_matrix_t *stroke_ctm_inverse, + double stroke_tolerance, + cairo_antialias_t stroke_antialias, + const cairo_clip_t *clip); + + cairo_warn cairo_int_status_t + (*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); + + cairo_bool_t + (*has_show_text_glyphs) (void *surface); + + cairo_warn cairo_int_status_t + (*show_text_glyphs) (void *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const char *utf8, + int utf8_len, + cairo_glyph_t *glyphs, + int num_glyphs, + const cairo_text_cluster_t *clusters, + int num_clusters, + cairo_text_cluster_flags_t cluster_flags, + cairo_scaled_font_t *scaled_font, + const cairo_clip_t *clip); +}; + +CAIRO_END_DECLS + +#endif /* CAIRO_SURFACE_BACKEND_PRIVATE_H */ diff --git a/src/cairo-surface-fallback-private.h b/src/cairo-surface-fallback-private.h index ffb6f919..ecf7b0ed 100644 --- a/src/cairo-surface-fallback-private.h +++ b/src/cairo-surface-fallback-private.h @@ -3,6 +3,7 @@ * * Copyright © 2002 University of Southern California * Copyright © 2005 Red Hat, Inc. + * 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 @@ -34,6 +35,8 @@ * * Contributor(s): * Carl D. Worth <cworth@cworth.org> + * Joonas Pihlaja <jpihlaja@cc.helsinki.fi> + * Chris Wilson <chris@chris-wilson.co.uk> */ #ifndef CAIRO_SURFACE_FALLBACK_PRIVATE_H @@ -41,99 +44,52 @@ #include "cairoint.h" -cairo_private cairo_status_t -_cairo_surface_fallback_paint (cairo_surface_t *surface, +CAIRO_BEGIN_DECLS + +cairo_private cairo_int_status_t +_cairo_surface_fallback_paint (void *abstract_surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_clip_t *clip); -cairo_private cairo_status_t -_cairo_surface_fallback_mask (cairo_surface_t *surface, +cairo_private cairo_int_status_t +_cairo_surface_fallback_mask (void *abstract_surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_pattern_t *mask, const cairo_clip_t *clip); -cairo_private cairo_status_t -_cairo_surface_fallback_stroke (cairo_surface_t *surface, - cairo_operator_t op, +cairo_private cairo_int_status_t +_cairo_surface_fallback_stroke (void *abstract_surface, + cairo_operator_t op, const cairo_pattern_t *source, const cairo_path_fixed_t *path, - const cairo_stroke_style_t *stroke_style, - const cairo_matrix_t *ctm, - const cairo_matrix_t *ctm_inverse, + 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_private cairo_status_t -_cairo_surface_fallback_fill (cairo_surface_t *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_private cairo_status_t -_cairo_surface_fallback_show_glyphs (cairo_surface_t *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - cairo_glyph_t *glyphs, - int num_glyphs, - cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip); +cairo_private cairo_int_status_t +_cairo_surface_fallback_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_private cairo_surface_t * -_cairo_surface_fallback_snapshot (cairo_surface_t *surface); - -cairo_private cairo_status_t -_cairo_surface_fallback_composite (cairo_operator_t op, - const cairo_pattern_t *src, - const cairo_pattern_t *mask, - cairo_surface_t *dst, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region); - -cairo_private cairo_status_t -_cairo_surface_fallback_fill_rectangles (cairo_surface_t *surface, - cairo_operator_t op, - const cairo_color_t *color, - cairo_rectangle_int_t *rects, - int num_rects); - -cairo_private cairo_status_t -_cairo_surface_fallback_composite_trapezoids (cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_surface_t *dst, - cairo_antialias_t antialias, - int src_x, - int src_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_trapezoid_t *traps, - int num_traps, - cairo_region_t *clip_region); +cairo_private cairo_int_status_t +_cairo_surface_fallback_glyphs (void *abstract_surface, + cairo_operator_t op, + const cairo_pattern_t *source, + cairo_glyph_t *glyphs, + int num_glyphs, + cairo_scaled_font_t *scaled_font, + const cairo_clip_t *clip); -cairo_private cairo_status_t -_cairo_surface_fallback_clone_similar (cairo_surface_t *surface, - cairo_surface_t *src, - int src_x, - int src_y, - int width, - int height, - int *clone_offset_x, - int *clone_offset_y, - cairo_surface_t **clone_out); +CAIRO_END_DECLS -#endif +#endif /* CAIRO_SURFACE_FALLBACK_PRIVATE_H */ diff --git a/src/cairo-surface-fallback.c b/src/cairo-surface-fallback.c index ec6946be..a0af1596 100644 --- a/src/cairo-surface-fallback.c +++ b/src/cairo-surface-fallback.c @@ -3,6 +3,7 @@ * * Copyright © 2002 University of Southern California * Copyright © 2005 Red Hat, Inc. + * 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 @@ -40,1545 +41,75 @@ #include "cairoint.h" -#include "cairo-boxes-private.h" -#include "cairo-clip-private.h" -#include "cairo-composite-rectangles-private.h" -#include "cairo-error-private.h" -#include "cairo-image-surface-private.h" -#include "cairo-pattern-private.h" -#include "cairo-region-private.h" -#include "cairo-spans-private.h" +#include "cairo-compositor-private.h" #include "cairo-surface-fallback-private.h" -typedef struct { - cairo_surface_t *dst; - cairo_rectangle_int_t extents; - cairo_image_surface_t *image; - cairo_rectangle_int_t image_rect; - void *image_extra; -} fallback_state_t; - -/** - * _fallback_init: - * - * Acquire destination image surface needed for an image-based - * fallback. - * - * Return value: %CAIRO_INT_STATUS_NOTHING_TO_DO if the extents are not - * visible, %CAIRO_STATUS_SUCCESS if some portion is visible and all - * went well, or some error status otherwise. - **/ -static cairo_int_status_t -_fallback_init (fallback_state_t *state, - cairo_surface_t *dst, - int x, - int y, - int width, - int height) -{ - cairo_status_t status; - - state->extents.x = x; - state->extents.y = y; - state->extents.width = width; - state->extents.height = height; - - state->dst = dst; - - status = _cairo_surface_acquire_dest_image (dst, &state->extents, - &state->image, &state->image_rect, - &state->image_extra); - if (unlikely (status)) - return status; - - - /* XXX: This NULL value tucked away in state->image is a rather - * ugly interface. Cleaner would be to push the - * CAIRO_INT_STATUS_NOTHING_TO_DO value down into - * _cairo_surface_acquire_dest_image and its backend - * counterparts. */ - assert (state->image != NULL); - - return CAIRO_STATUS_SUCCESS; -} - -static void -_fallback_fini (fallback_state_t *state) -{ - _cairo_surface_release_dest_image (state->dst, &state->extents, - state->image, &state->image_rect, - state->image_extra); -} - -typedef cairo_status_t -(*cairo_draw_func_t) (void *closure, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_surface_t *dst, - int dst_x, - int dst_y, - const cairo_rectangle_int_t *extents, - cairo_region_t *clip_region); - -static void do_unaligned_row(void (*blt)(void *closure, - int16_t x, int16_t y, - int16_t w, int16_t h, - uint16_t coverage), - void *closure, - const cairo_box_t *b, - int tx, int y, int h, - uint16_t coverage) -{ - int x1 = _cairo_fixed_integer_part (b->p1.x) - tx; - int x2 = _cairo_fixed_integer_part (b->p2.x) - tx; - if (x2 > x1) { - if (! _cairo_fixed_is_integer (b->p1.x)) { - blt(closure, x1, y, 1, h, - coverage * (256 - _cairo_fixed_fractional_part (b->p1.x))); - x1++; - } - - if (x2 > x1) - blt(closure, x1, y, x2-x1, h, (coverage << 8) - (coverage >> 8)); - - if (! _cairo_fixed_is_integer (b->p2.x)) - blt(closure, x2, y, 1, h, - coverage * _cairo_fixed_fractional_part (b->p2.x)); - } else - blt(closure, x1, y, 1, h, - coverage * (b->p2.x - b->p1.x)); -} - -static void do_unaligned_box(void (*blt)(void *closure, - int16_t x, int16_t y, - int16_t w, int16_t h, - uint16_t coverage), - void *closure, - const cairo_box_t *b, int tx, int ty) -{ - int y1 = _cairo_fixed_integer_part (b->p1.y) - ty; - int y2 = _cairo_fixed_integer_part (b->p2.y) - ty; - if (y2 > y1) { - if (! _cairo_fixed_is_integer (b->p1.y)) { - do_unaligned_row(blt, closure, b, tx, y1, 1, - 256 - _cairo_fixed_fractional_part (b->p1.y)); - y1++; - } - - if (y2 > y1) - do_unaligned_row(blt, closure, b, tx, y1, y2-y1, 256); - - if (! _cairo_fixed_is_integer (b->p2.y)) - do_unaligned_row(blt, closure, b, tx, y2, 1, - _cairo_fixed_fractional_part (b->p2.y)); - } else - do_unaligned_row(blt, closure, b, tx, y1, 1, - b->p2.y - b->p1.y); -} - -static void blt_in(void *closure, - int16_t x, int16_t y, - int16_t w, int16_t h, - uint16_t coverage) -{ - cairo_color_t color; - cairo_rectangle_int_t rect; - - if (coverage == 0xffff) - return; - - _cairo_color_init_rgba (&color, 0, 0, 0, coverage / (double) 0xffff); - - rect.x = x; - rect.y = y; - rect.width = w; - rect.height = h; - - _cairo_surface_fill_rectangles (closure, CAIRO_OPERATOR_IN, - &color, &rect, 1); -} - -static cairo_status_t -_create_composite_mask_pattern (cairo_surface_pattern_t *mask_pattern, - cairo_clip_t *clip, - cairo_draw_func_t draw_func, - void *draw_closure, - cairo_surface_t *dst, - const cairo_rectangle_int_t *extents) -{ - cairo_surface_t *mask; - cairo_status_t status; - cairo_region_t *clip_region; - int i; - - /* We need to use solid here, because to use CAIRO_OPERATOR_SOURCE with - * a mask (as called via _cairo_surface_mask) triggers assertion failures. - */ - mask = _cairo_surface_create_similar_solid (dst, - CAIRO_CONTENT_ALPHA, - extents->width, - extents->height, - CAIRO_COLOR_TRANSPARENT, - TRUE); - if (unlikely (mask->status)) - return mask->status; - - clip_region = _cairo_clip_get_region (clip); - if (clip_region && (extents->x | extents->y)) - cairo_region_translate (clip_region, -extents->x, -extents->y); - - status = draw_func (draw_closure, CAIRO_OPERATOR_ADD, - &_cairo_pattern_white.base, mask, - extents->x, extents->y, - extents, - clip_region); - - if (clip_region && (extents->x | extents->y)) - cairo_region_translate (clip_region, extents->x, extents->y); - - if (unlikely (status)) - goto CLEANUP; - - if (clip) { - for (i = 0; i < clip->num_boxes; i++) { - cairo_box_t *b = &clip->boxes[i]; - - if (! _cairo_fixed_is_integer (b->p1.x) || - ! _cairo_fixed_is_integer (b->p1.y) || - ! _cairo_fixed_is_integer (b->p2.x) || - ! _cairo_fixed_is_integer (b->p2.y)) - { - do_unaligned_box(blt_in, mask, b, extents->x, extents->y); - } - } - - if (clip->path != NULL) { - status = _cairo_clip_combine_with_surface (clip, mask, - extents->x, extents->y); - if (unlikely (status)) - goto CLEANUP; - } - } - - _cairo_pattern_init_for_surface (mask_pattern, mask); - - CLEANUP: - cairo_surface_destroy (mask); - - return status; -} - -/* Handles compositing with a clip surface when the operator allows - * us to combine the clip with the mask - */ -static cairo_status_t -_clip_and_composite_with_mask (cairo_clip_t *clip, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_draw_func_t draw_func, - void *draw_closure, - cairo_surface_t *dst, - const cairo_rectangle_int_t *extents) -{ - cairo_surface_pattern_t mask_pattern; - cairo_status_t status; - - status = _create_composite_mask_pattern (&mask_pattern, - clip, - draw_func, draw_closure, - dst, extents); - if (likely (status == CAIRO_STATUS_SUCCESS)) { - status = _cairo_surface_composite (op, - src, &mask_pattern.base, dst, - extents->x, extents->y, - 0, 0, - extents->x, extents->y, - extents->width, extents->height, - NULL); - - _cairo_pattern_fini (&mask_pattern.base); - } - - return status; -} - -/* Handles compositing with a clip surface when we have to do the operation - * in two pieces and combine them together. - */ -static cairo_status_t -_clip_and_composite_combine (cairo_clip_t *clip, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_draw_func_t draw_func, - void *draw_closure, - cairo_surface_t *dst, - const cairo_rectangle_int_t *extents) -{ - cairo_surface_t *intermediate; - cairo_surface_pattern_t pattern; - cairo_surface_pattern_t clip_pattern; - cairo_surface_t *clip_surface; - int clip_x, clip_y; - cairo_status_t status; - - /* We'd be better off here creating a surface identical in format - * to dst, but we have no way of getting that information. Instead - * we ask the backend to create a similar surface of identical content, - * in the belief that the backend will do something useful - like use - * an identical format. For example, the xlib backend will endeavor to - * use a compatible depth to enable core protocol routines. - */ - intermediate = - _cairo_surface_create_similar_scratch (dst, dst->content, - extents->width, - extents->height); - if (intermediate == NULL) { - intermediate = - _cairo_image_surface_create_with_content (dst->content, - extents->width, - extents->width); - } - if (unlikely (intermediate->status)) - return intermediate->status; - - /* Initialize the intermediate surface from the destination surface */ - _cairo_pattern_init_for_surface (&pattern, dst); - status = _cairo_surface_composite (CAIRO_OPERATOR_SOURCE, - &pattern.base, NULL, intermediate, - extents->x, extents->y, - 0, 0, - 0, 0, - extents->width, extents->height, - NULL); - _cairo_pattern_fini (&pattern.base); - if (unlikely (status)) - goto CLEANUP_SURFACE; - - status = (*draw_func) (draw_closure, op, - src, intermediate, - extents->x, extents->y, - extents, - NULL); - if (unlikely (status)) - goto CLEANUP_SURFACE; - - clip_surface = _cairo_clip_get_surface (clip, dst, &clip_x, &clip_y); - if (unlikely (clip_surface->status)) - goto CLEANUP_SURFACE; - - _cairo_pattern_init_for_surface (&clip_pattern, clip_surface); - - /* Combine that with the clip */ - status = _cairo_surface_composite (CAIRO_OPERATOR_DEST_IN, - &clip_pattern.base, NULL, intermediate, - extents->x - clip_x, - extents->y - clip_y, - 0, 0, - 0, 0, - extents->width, extents->height, - NULL); - if (unlikely (status)) - goto CLEANUP_CLIP; - - /* Punch the clip out of the destination */ - status = _cairo_surface_composite (CAIRO_OPERATOR_DEST_OUT, - &clip_pattern.base, NULL, dst, - extents->x - clip_x, - extents->y - clip_y, - 0, 0, - extents->x, extents->y, - extents->width, extents->height, - NULL); - if (unlikely (status)) - goto CLEANUP_CLIP; - - /* Now add the two results together */ - _cairo_pattern_init_for_surface (&pattern, intermediate); - status = _cairo_surface_composite (CAIRO_OPERATOR_ADD, - &pattern.base, NULL, dst, - 0, 0, - 0, 0, - extents->x, extents->y, - extents->width, extents->height, - NULL); - _cairo_pattern_fini (&pattern.base); - - CLEANUP_CLIP: - _cairo_pattern_fini (&clip_pattern.base); - CLEANUP_SURFACE: - cairo_surface_destroy (intermediate); - - return status; -} - -/* Handles compositing for %CAIRO_OPERATOR_SOURCE, which is special; it's - * defined as (src IN mask IN clip) ADD (dst OUT (mask IN clip)) - */ -static cairo_status_t -_clip_and_composite_source (cairo_clip_t *clip, - const cairo_pattern_t *src, - cairo_draw_func_t draw_func, - void *draw_closure, - cairo_surface_t *dst, - const cairo_rectangle_int_t *extents) -{ - cairo_surface_pattern_t mask_pattern; - cairo_region_t *clip_region = _cairo_clip_get_region (clip); - cairo_status_t status; - - /* Create a surface that is mask IN clip */ - status = _create_composite_mask_pattern (&mask_pattern, - clip, - draw_func, draw_closure, - dst, extents); - if (unlikely (status)) - return status; - - /* Compute dest' = dest OUT (mask IN clip) */ - status = _cairo_surface_composite (CAIRO_OPERATOR_DEST_OUT, - &mask_pattern.base, NULL, dst, - 0, 0, - 0, 0, - extents->x, extents->y, - extents->width, extents->height, - clip_region); - - if (unlikely (status)) - goto CLEANUP_MASK_PATTERN; - - /* Now compute (src IN (mask IN clip)) ADD dest' */ - status = _cairo_surface_composite (CAIRO_OPERATOR_ADD, - src, &mask_pattern.base, dst, - extents->x, extents->y, - 0, 0, - extents->x, extents->y, - extents->width, extents->height, - clip_region); - - CLEANUP_MASK_PATTERN: - _cairo_pattern_fini (&mask_pattern.base); - return status; -} - -/** - * _clip_and_composite: - * @clip: a #cairo_clip_t - * @op: the operator to draw with - * @src: source pattern - * @draw_func: function that can be called to draw with the mask onto a surface. - * @draw_closure: data to pass to @draw_func. - * @dst: destination surface - * @extents: rectangle holding a bounding box for the operation; this - * rectangle will be used as the size for the temporary - * surface. - * - * When there is a surface clip, we typically need to create an intermediate - * surface. This function handles the logic of creating a temporary surface - * drawing to it, then compositing the result onto the target surface. - * - * @draw_func is to called to draw the mask; it will be called no more - * than once. - * - * Return value: %CAIRO_STATUS_SUCCESS if the drawing succeeded. - **/ -static cairo_status_t -_clip_and_composite (cairo_clip_t *clip, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_draw_func_t draw_func, - void *draw_closure, - cairo_surface_t *dst, - const cairo_rectangle_int_t *extents) -{ - cairo_status_t status; - - if (op == CAIRO_OPERATOR_CLEAR) { - src = &_cairo_pattern_white.base; - op = CAIRO_OPERATOR_DEST_OUT; - } - - if (op == CAIRO_OPERATOR_SOURCE) { - status = _clip_and_composite_source (clip, - src, - draw_func, draw_closure, - dst, extents); - } else { - if (! _cairo_clip_is_region (clip)) { - if (_cairo_operator_bounded_by_mask (op)) { - status = _clip_and_composite_with_mask (clip, op, - src, - draw_func, draw_closure, - dst, extents); - } else { - status = _clip_and_composite_combine (clip, op, - src, - draw_func, draw_closure, - dst, extents); - } - } else { - status = draw_func (draw_closure, op, - src, dst, - 0, 0, - extents, - _cairo_clip_get_region (clip)); - } - } - - return status; -} - -/* Composites a region representing a set of trapezoids. - */ -static cairo_status_t -_composite_trap_region (cairo_clip_t *clip, - const cairo_pattern_t *src, - cairo_operator_t op, - cairo_surface_t *dst, - cairo_region_t *trap_region, - const cairo_rectangle_int_t *extents) -{ - cairo_status_t status; - cairo_surface_pattern_t mask_pattern; - cairo_pattern_t *mask = NULL; - int mask_x = 0, mask_y =0; - - if (clip != NULL) { - cairo_surface_t *clip_surface = NULL; - int clip_x, clip_y; - - clip_surface = _cairo_clip_get_surface (clip, dst, &clip_x, &clip_y); - if (unlikely (clip_surface->status)) - return clip_surface->status; - - if (op == CAIRO_OPERATOR_CLEAR) { - src = &_cairo_pattern_white.base; - op = CAIRO_OPERATOR_DEST_OUT; - } - - _cairo_pattern_init_for_surface (&mask_pattern, clip_surface); - mask_x = extents->x - clip_x; - mask_y = extents->y - clip_y; - mask = &mask_pattern.base; - } - - status = _cairo_surface_composite (op, src, mask, dst, - extents->x, extents->y, - mask_x, mask_y, - extents->x, extents->y, - extents->width, extents->height, - trap_region); - - if (mask != NULL) - _cairo_pattern_fini (mask); - - return status; -} - -typedef struct { - cairo_traps_t *traps; - cairo_antialias_t antialias; -} cairo_composite_traps_info_t; - -static cairo_status_t -_composite_traps_draw_func (void *closure, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_surface_t *dst, - int dst_x, - int dst_y, - const cairo_rectangle_int_t *extents, - cairo_region_t *clip_region) -{ - cairo_composite_traps_info_t *info = closure; - cairo_status_t status; - cairo_region_t *extents_region = NULL; - - if (dst_x != 0 || dst_y != 0) - _cairo_traps_translate (info->traps, - dst_x, - dst_y); - - if (clip_region == NULL && - !_cairo_operator_bounded_by_source (op)) { - extents_region = cairo_region_create_rectangle (extents); - if (unlikely (extents_region->status)) - return extents_region->status; - cairo_region_translate (extents_region, -dst_x, -dst_y); - clip_region = extents_region; - } - - status = _cairo_surface_composite_trapezoids (op, - src, dst, info->antialias, - extents->x, extents->y, - extents->x - dst_x, extents->y - dst_y, - extents->width, extents->height, - info->traps->traps, - info->traps->num_traps, - clip_region); - - if (extents_region) - cairo_region_destroy (extents_region); - - return status; -} - -enum { - HAS_CLEAR_REGION = 0x1, -}; - -static cairo_status_t -_clip_and_composite_region (const cairo_pattern_t *src, - cairo_operator_t op, - cairo_surface_t *dst, - cairo_region_t *trap_region, - cairo_clip_t *clip, - cairo_rectangle_int_t *extents) -{ - cairo_region_t clear_region; - unsigned int has_region = 0; - cairo_status_t status; - - if (! _cairo_operator_bounded_by_mask (op) && clip == NULL) { - /* If we optimize drawing with an unbounded operator to - * _cairo_surface_fill_rectangles() or to drawing with a - * clip region, then we have an additional region to clear. - */ - _cairo_region_init_rectangle (&clear_region, extents); - status = cairo_region_subtract (&clear_region, trap_region); - if (unlikely (status)) - return status; - - if (! cairo_region_is_empty (&clear_region)) - has_region |= HAS_CLEAR_REGION; - } - - if ((src->type == CAIRO_PATTERN_TYPE_SOLID || op == CAIRO_OPERATOR_CLEAR) && - clip == NULL) - { - const cairo_color_t *color; - - if (op == CAIRO_OPERATOR_CLEAR) - color = CAIRO_COLOR_TRANSPARENT; - else - color = &((cairo_solid_pattern_t *)src)->color; - - /* Solid rectangles special case */ - status = _cairo_surface_fill_region (dst, op, color, trap_region); - } else { - /* For a simple rectangle, we can just use composite(), for more - * rectangles, we have to set a clip region. The cost of rasterizing - * trapezoids is pretty high for most backends currently, so it's - * worthwhile even if a region is needed. - * - * If we have a clip surface, we set it as the mask; this only works - * for bounded operators other than SOURCE; for unbounded operators, - * clip and mask cannot be interchanged. For SOURCE, the operator - * as implemented by the backends is different in its handling - * of the mask then what we want. - * - * CAIRO_INT_STATUS_UNSUPPORTED will be returned if the region has - * more than rectangle and the destination doesn't support clip - * regions. In that case, we fall through. - */ - status = _composite_trap_region (clip, src, op, dst, - trap_region, extents); - } - - if (has_region & HAS_CLEAR_REGION) { - if (status == CAIRO_STATUS_SUCCESS) { - status = _cairo_surface_fill_region (dst, - CAIRO_OPERATOR_CLEAR, - CAIRO_COLOR_TRANSPARENT, - &clear_region); - } - _cairo_region_fini (&clear_region); - } - - return status; -} - -/* avoid using region code to re-validate boxes */ -static cairo_status_t -_fill_rectangles (cairo_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_traps_t *traps, - cairo_clip_t *clip) -{ - const cairo_color_t *color; - cairo_rectangle_int_t stack_rects[CAIRO_STACK_ARRAY_LENGTH (cairo_rectangle_int_t)]; - cairo_rectangle_int_t *rects = stack_rects; - cairo_status_t status; - int i; - - if (! traps->is_rectilinear || ! traps->maybe_region) - return CAIRO_INT_STATUS_UNSUPPORTED; - - /* XXX: convert clip region to geometric boxes? */ - if (clip != NULL) - return CAIRO_INT_STATUS_UNSUPPORTED; - - /* XXX: fallback for the region_subtract() operation */ - if (! _cairo_operator_bounded_by_mask (op)) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (! (src->type == CAIRO_PATTERN_TYPE_SOLID || op == CAIRO_OPERATOR_CLEAR)) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (traps->has_intersections) { - if (traps->is_rectangular) { - status = _cairo_bentley_ottmann_tessellate_rectangular_traps (traps, CAIRO_FILL_RULE_WINDING); - } else { - status = _cairo_bentley_ottmann_tessellate_rectilinear_traps (traps, CAIRO_FILL_RULE_WINDING); - } - if (unlikely (status)) - return status; - } - - for (i = 0; i < traps->num_traps; i++) { - if (! _cairo_fixed_is_integer (traps->traps[i].top) || - ! _cairo_fixed_is_integer (traps->traps[i].bottom) || - ! _cairo_fixed_is_integer (traps->traps[i].left.p1.x) || - ! _cairo_fixed_is_integer (traps->traps[i].right.p1.x)) - { - traps->maybe_region = FALSE; - return CAIRO_INT_STATUS_UNSUPPORTED; - } - } - - if (traps->num_traps > ARRAY_LENGTH (stack_rects)) { - rects = _cairo_malloc_ab (traps->num_traps, - sizeof (cairo_rectangle_int_t)); - if (unlikely (rects == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - for (i = 0; i < traps->num_traps; i++) { - int x1 = _cairo_fixed_integer_part (traps->traps[i].left.p1.x); - int y1 = _cairo_fixed_integer_part (traps->traps[i].top); - int x2 = _cairo_fixed_integer_part (traps->traps[i].right.p1.x); - int y2 = _cairo_fixed_integer_part (traps->traps[i].bottom); - - rects[i].x = x1; - rects[i].y = y1; - rects[i].width = x2 - x1; - rects[i].height = y2 - y1; - } - - if (op == CAIRO_OPERATOR_CLEAR) - color = CAIRO_COLOR_TRANSPARENT; - else - color = &((cairo_solid_pattern_t *)src)->color; - - status = _cairo_surface_fill_rectangles (dst, op, color, rects, i); - - if (rects != stack_rects) - free (rects); - - return status; -} - -/* fast-path for very common composite of a single rectangle */ -static cairo_status_t -_composite_rectangle (cairo_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_traps_t *traps, - cairo_clip_t *clip) -{ - cairo_rectangle_int_t rect; - - if (clip != NULL) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (traps->num_traps > 1 || ! traps->is_rectilinear || ! traps->maybe_region) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (! _cairo_fixed_is_integer (traps->traps[0].top) || - ! _cairo_fixed_is_integer (traps->traps[0].bottom) || - ! _cairo_fixed_is_integer (traps->traps[0].left.p1.x) || - ! _cairo_fixed_is_integer (traps->traps[0].right.p1.x)) - { - traps->maybe_region = FALSE; - return CAIRO_INT_STATUS_UNSUPPORTED; - } - - rect.x = _cairo_fixed_integer_part (traps->traps[0].left.p1.x); - rect.y = _cairo_fixed_integer_part (traps->traps[0].top); - rect.width = _cairo_fixed_integer_part (traps->traps[0].right.p1.x) - rect.x; - rect.height = _cairo_fixed_integer_part (traps->traps[0].bottom) - rect.y; - - return _cairo_surface_composite (op, src, NULL, dst, - rect.x, rect.y, - 0, 0, - rect.x, rect.y, - rect.width, rect.height, - NULL); -} - -/* Warning: This call modifies the coordinates of traps */ -static cairo_status_t -_clip_and_composite_trapezoids (const cairo_pattern_t *src, - cairo_operator_t op, - cairo_surface_t *dst, - cairo_traps_t *traps, - cairo_antialias_t antialias, - cairo_clip_t *clip, - cairo_rectangle_int_t *extents) -{ - cairo_composite_traps_info_t traps_info; - cairo_bool_t clip_surface = ! _cairo_clip_is_region (clip); - cairo_int_status_t status; - - if (traps->num_traps == 0 && _cairo_operator_bounded_by_mask (op)) - return CAIRO_STATUS_SUCCESS; - - /* Use a fast path if the trapezoids consist of a simple region, - * but we can only do this if we do not have a clip surface, or can - * substitute the mask with the clip. - */ - if (! clip_surface || - (_cairo_operator_bounded_by_mask (op) && op != CAIRO_OPERATOR_SOURCE)) - { - cairo_region_t *trap_region = NULL; - - if (_cairo_operator_bounded_by_source (op)) { - status = _fill_rectangles (dst, op, src, traps, clip); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - - status = _composite_rectangle (dst, op, src, traps, clip); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - } - - status = _cairo_traps_extract_region (traps, antialias, &trap_region); - if (unlikely (_cairo_int_status_is_error (status))) - return status; - - if (trap_region != NULL) { - status = cairo_region_intersect_rectangle (trap_region, extents); - if (unlikely (status)) { - cairo_region_destroy (trap_region); - return status; - } - - if (_cairo_operator_bounded_by_mask (op)) { - cairo_rectangle_int_t trap_extents; - - cairo_region_get_extents (trap_region, &trap_extents); - if (! _cairo_rectangle_intersect (extents, &trap_extents)) { - cairo_region_destroy (trap_region); - return CAIRO_INT_STATUS_SUCCESS; - } - } - - status = _clip_and_composite_region (src, op, dst, - trap_region, - clip_surface ? clip : NULL, - extents); - cairo_region_destroy (trap_region); - - if (likely (status != CAIRO_INT_STATUS_UNSUPPORTED)) - return status; - } - } - - /* No fast path, exclude self-intersections and clip trapezoids. */ - if (traps->has_intersections) { - if (traps->is_rectangular) - status = _cairo_bentley_ottmann_tessellate_rectangular_traps (traps, CAIRO_FILL_RULE_WINDING); - else if (traps->is_rectilinear) - status = _cairo_bentley_ottmann_tessellate_rectilinear_traps (traps, CAIRO_FILL_RULE_WINDING); - else - status = _cairo_bentley_ottmann_tessellate_traps (traps, CAIRO_FILL_RULE_WINDING); - if (unlikely (status)) - return status; - } - - /* Otherwise render the trapezoids to a mask and composite in the usual - * fashion. - */ - traps_info.traps = traps; - traps_info.antialias = antialias; - - return _clip_and_composite (clip, op, src, - _composite_traps_draw_func, - &traps_info, dst, extents); -} - -cairo_status_t -_cairo_surface_fallback_paint (cairo_surface_t *surface, +cairo_int_status_t +_cairo_surface_fallback_paint (void *surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_clip_t *clip) { - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t rect; - cairo_boxes_t boxes; - cairo_int_status_t status; - - if (!_cairo_surface_get_extents (surface, &rect)) - ASSERT_NOT_REACHED; - - status = _cairo_composite_rectangles_init_for_paint (&extents, &rect, - op, source, - clip); - if (unlikely (status)) - return status; - - status = _cairo_clip_to_boxes (extents.clip, &boxes); - if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { - cairo_traps_t traps; - - /* meh, surface-fallback is dying anyway... */ - status = _cairo_traps_init_boxes (&traps, &boxes); - if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { - status = _clip_and_composite_trapezoids (source, op, surface, - &traps, CAIRO_ANTIALIAS_DEFAULT, - extents.clip, - extents.is_bounded ? &extents.bounded : &extents.unbounded); - _cairo_traps_fini (&traps); - } - } - - _cairo_composite_rectangles_fini (&extents); - - return status; + return _cairo_compositor_paint (&_cairo_fallback_compositor, + surface, op, source, clip); } -static cairo_status_t -_cairo_surface_mask_draw_func (void *closure, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_surface_t *dst, - int dst_x, - int dst_y, - const cairo_rectangle_int_t *extents, - cairo_region_t *clip_region) -{ - cairo_pattern_t *mask = closure; - cairo_int_status_t status; - cairo_region_t *extents_region = NULL; - - if (clip_region == NULL && - !_cairo_operator_bounded_by_source (op)) { - extents_region = cairo_region_create_rectangle (extents); - if (unlikely (extents_region->status)) - return extents_region->status; - cairo_region_translate (extents_region, -dst_x, -dst_y); - clip_region = extents_region; - } - - if (src) { - status = _cairo_surface_composite (op, - src, mask, dst, - extents->x, extents->y, - extents->x, extents->y, - extents->x - dst_x, extents->y - dst_y, - extents->width, extents->height, - clip_region); - } else { - status = _cairo_surface_composite (op, - mask, NULL, dst, - extents->x, extents->y, - 0, 0, /* unused */ - extents->x - dst_x, extents->y - dst_y, - extents->width, extents->height, - clip_region); - } - - if (extents_region) - cairo_region_destroy (extents_region); - - return status; -} - -cairo_status_t -_cairo_surface_fallback_mask (cairo_surface_t *surface, +cairo_int_status_t +_cairo_surface_fallback_mask (void *surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_pattern_t *mask, const cairo_clip_t *clip) { - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t rect; - cairo_status_t status; - - if (!_cairo_surface_get_extents (surface, &rect)) - ASSERT_NOT_REACHED; - - status = _cairo_composite_rectangles_init_for_mask (&extents, &rect, - op, source, mask, clip); - if (unlikely (status)) - return status; - - status = _clip_and_composite (extents.clip, op, source, - _cairo_surface_mask_draw_func, - (void *) mask, - surface, - extents.is_bounded ? &extents.bounded : &extents.unbounded); - - _cairo_composite_rectangles_fini (&extents); - - return status; + return _cairo_compositor_mask (&_cairo_fallback_compositor, + surface, op, source, mask, clip); } -cairo_status_t -_cairo_surface_fallback_stroke (cairo_surface_t *surface, +cairo_int_status_t +_cairo_surface_fallback_stroke (void *surface, cairo_operator_t op, const cairo_pattern_t *source, - const cairo_path_fixed_t *path, - const cairo_stroke_style_t *stroke_style, - const cairo_matrix_t *ctm, - const cairo_matrix_t *ctm_inverse, + 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_polygon_t polygon; - cairo_traps_t traps; - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t rect; - cairo_int_status_t status; - - if (!_cairo_surface_get_extents (surface, &rect)) - ASSERT_NOT_REACHED; - - status = _cairo_composite_rectangles_init_for_stroke (&extents, &rect, - op, source, - path, stroke_style, ctm, - clip); - if (unlikely (status)) - return status; - - _cairo_polygon_init_with_clip (&polygon, extents.clip); - _cairo_traps_init_with_clip (&traps, extents.clip); - - status = CAIRO_INT_STATUS_UNSUPPORTED; - if (_cairo_path_fixed_stroke_is_rectilinear (path)) { - cairo_boxes_t boxes; - - /* Did I mention, that I need to rewrite surface-fallback? */ - _cairo_boxes_init_with_clip (&boxes, extents.clip); - status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path, - stroke_style, - ctm, - antialias, - &boxes); - if (status == CAIRO_INT_STATUS_SUCCESS) - status = _cairo_traps_init_boxes (&traps, &boxes); - _cairo_boxes_fini (&boxes); - - if (unlikely (_cairo_int_status_is_error (status))) - goto CLEANUP; - } - - /* Fall back to trapezoid fills. */ - if (status == CAIRO_INT_STATUS_UNSUPPORTED) { - status = _cairo_path_fixed_stroke_to_polygon (path, - stroke_style, - ctm, ctm_inverse, - tolerance, - &polygon); - if (unlikely (status)) - goto CLEANUP; - - status = _cairo_composite_rectangles_intersect_mask_extents (&extents, - &polygon.extents); - if (unlikely (status)) - goto CLEANUP; - - status = _cairo_bentley_ottmann_tessellate_polygon (&traps, - &polygon, - CAIRO_FILL_RULE_WINDING); - if (unlikely (status)) - goto CLEANUP; - } - - status = _clip_and_composite_trapezoids (source, op, surface, - &traps, antialias, - extents.clip, - extents.is_bounded ? &extents.bounded : &extents.unbounded); - CLEANUP: - _cairo_traps_fini (&traps); - _cairo_polygon_fini (&polygon); - - _cairo_composite_rectangles_fini (&extents); - - return status; -} - -cairo_status_t -_cairo_surface_fallback_fill (cairo_surface_t *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_polygon_t polygon; - cairo_traps_t traps; - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t rect; - cairo_int_status_t status; - - if (!_cairo_surface_get_extents (surface, &rect)) - ASSERT_NOT_REACHED; - - status = _cairo_composite_rectangles_init_for_fill (&extents, &rect, - op, source, path, - clip); - if (unlikely (status)) - return status; - - _cairo_traps_init_with_clip (&traps, extents.clip); - _cairo_polygon_init_with_clip (&polygon, extents.clip); - - if (_cairo_path_fixed_fill_is_empty (path)) - goto DO_TRAPS; - - status = CAIRO_INT_STATUS_UNSUPPORTED; - if (_cairo_path_fixed_fill_is_rectilinear (path)) { - cairo_boxes_t boxes; - - /* meh, surface-fallback is dying anyway... */ - _cairo_boxes_init_with_clip (&boxes, extents.clip); - status = _cairo_path_fixed_fill_rectilinear_to_boxes (path, - fill_rule, - antialias, - &boxes); - if (unlikely (status)) - goto CLEANUP; - - if (status == CAIRO_INT_STATUS_SUCCESS) - status = _cairo_traps_init_boxes (&traps, &boxes); - _cairo_boxes_fini (&boxes); - if (unlikely (_cairo_int_status_is_error (status))) - goto CLEANUP; - } - - /* Fall back to trapezoid fills. */ - if (status == CAIRO_INT_STATUS_UNSUPPORTED) { - status = _cairo_path_fixed_fill_to_polygon (path, tolerance, &polygon); - if (unlikely (status)) - goto CLEANUP; - - status = _cairo_composite_rectangles_intersect_mask_extents (&extents, - &polygon.extents); - if (unlikely (status)) - goto CLEANUP; - - status = _cairo_bentley_ottmann_tessellate_polygon (&traps, - &polygon, - fill_rule); - if (unlikely (status)) - goto CLEANUP; - } - - DO_TRAPS: - status = _clip_and_composite_trapezoids (source, op, surface, - &traps, antialias, - extents.clip, - extents.is_bounded ? &extents.bounded : &extents.unbounded); - CLEANUP: - _cairo_traps_fini (&traps); - _cairo_polygon_fini (&polygon); - - _cairo_composite_rectangles_fini (&extents); - - return status; -} - -typedef struct { - cairo_scaled_font_t *font; - cairo_glyph_t *glyphs; - int num_glyphs; -} cairo_show_glyphs_info_t; - -static cairo_status_t -_cairo_surface_old_show_glyphs_draw_func (void *closure, - cairo_operator_t op, - const cairo_pattern_t *src, - cairo_surface_t *dst, - int dst_x, - int dst_y, - const cairo_rectangle_int_t *extents, - cairo_region_t *clip_region) + const cairo_clip_t *clip) { - cairo_show_glyphs_info_t *glyph_info = closure; - cairo_int_status_t status; - - /* Modifying the glyph array is fine because we know that this function - * will be called only once, and we've already made a copy of the - * glyphs in the wrapper. - */ - if (dst_x != 0 || dst_y != 0) { - int i; - - for (i = 0; i < glyph_info->num_glyphs; ++i) { - ((cairo_glyph_t *) glyph_info->glyphs)[i].x -= dst_x; - ((cairo_glyph_t *) glyph_info->glyphs)[i].y -= dst_y; - } - } - - status = _cairo_surface_old_show_glyphs (glyph_info->font, op, src, - dst, - extents->x, extents->y, - extents->x - dst_x, - extents->y - dst_y, - extents->width, - extents->height, - glyph_info->glyphs, - glyph_info->num_glyphs, - clip_region); - - if (status == CAIRO_INT_STATUS_UNSUPPORTED) { - status = _cairo_scaled_font_show_glyphs (glyph_info->font, - op, - src, dst, - extents->x, extents->y, - extents->x - dst_x, - extents->y - dst_y, - extents->width, extents->height, - glyph_info->glyphs, - glyph_info->num_glyphs, - clip_region); - } - - return status; + return _cairo_compositor_stroke (&_cairo_fallback_compositor, + surface, op, source, path, + style, ctm,ctm_inverse, + tolerance, antialias, clip); } -cairo_status_t -_cairo_surface_fallback_show_glyphs (cairo_surface_t *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - cairo_glyph_t *glyphs, - int num_glyphs, - cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip) +cairo_int_status_t +_cairo_surface_fallback_fill (void *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_show_glyphs_info_t glyph_info; - cairo_composite_rectangles_t extents; - cairo_rectangle_int_t rect; - cairo_int_status_t status; - - if (!_cairo_surface_get_extents (surface, &rect)) - ASSERT_NOT_REACHED; - - status = _cairo_composite_rectangles_init_for_glyphs (&extents, &rect, - op, source, - scaled_font, - glyphs, num_glyphs, - clip, - NULL); - if (unlikely (status)) - return status; - - glyph_info.font = scaled_font; - glyph_info.glyphs = glyphs; - glyph_info.num_glyphs = num_glyphs; - - status = _clip_and_composite (extents.clip, op, source, - _cairo_surface_old_show_glyphs_draw_func, - &glyph_info, surface, - extents.is_bounded ? &extents.bounded : &extents.unbounded); - - _cairo_composite_rectangles_fini (&extents); - - return status; + return _cairo_compositor_fill (&_cairo_fallback_compositor, + surface, op, source, path, + fill_rule, tolerance, antialias, + clip); } -cairo_surface_t * -_cairo_surface_fallback_snapshot (cairo_surface_t *surface) -{ - cairo_surface_t *snapshot; - cairo_status_t status; - cairo_format_t format; - cairo_surface_pattern_t pattern; - cairo_image_surface_t *image; - void *image_extra; - - status = _cairo_surface_acquire_source_image (surface, - &image, &image_extra); - if (unlikely (status)) - return _cairo_surface_create_in_error (status); - - format = image->format; - if (format == CAIRO_FORMAT_INVALID) { - /* Non-standard images formats can be generated when retrieving - * images from unusual xservers, for example. - */ - format = _cairo_format_from_content (image->base.content); - } - snapshot = cairo_image_surface_create (format, - image->width, - image->height); - if (cairo_surface_status (snapshot)) { - _cairo_surface_release_source_image (surface, image, image_extra); - return snapshot; - } - - _cairo_pattern_init_for_surface (&pattern, &image->base); - status = _cairo_surface_paint (snapshot, - CAIRO_OPERATOR_SOURCE, - &pattern.base, - NULL); - _cairo_pattern_fini (&pattern.base); - _cairo_surface_release_source_image (surface, image, image_extra); - if (unlikely (status)) { - cairo_surface_destroy (snapshot); - return _cairo_surface_create_in_error (status); - } - - return snapshot; -} - -cairo_status_t -_cairo_surface_fallback_composite (cairo_operator_t op, - const cairo_pattern_t *src, - const cairo_pattern_t *mask, - cairo_surface_t *dst, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region) -{ - fallback_state_t state; - cairo_region_t *fallback_region = NULL; - cairo_status_t status; - - status = _fallback_init (&state, dst, dst_x, dst_y, width, height); - if (unlikely (status)) - return status; - - /* We know this will never fail with the image backend; but - * instead of calling into it directly, we call - * _cairo_surface_composite so that we get the correct device - * offset handling. - */ - - if (clip_region != NULL && (state.image_rect.x || state.image_rect.y)) { - fallback_region = cairo_region_copy (clip_region); - status = fallback_region->status; - if (unlikely (status)) - goto FAIL; - - cairo_region_translate (fallback_region, - -state.image_rect.x, - -state.image_rect.y); - clip_region = fallback_region; - } - - status = _cairo_surface_composite (op, src, mask, - &state.image->base, - src_x, src_y, mask_x, mask_y, - dst_x - state.image_rect.x, - dst_y - state.image_rect.y, - width, height, - clip_region); - FAIL: - if (fallback_region != NULL) - cairo_region_destroy (fallback_region); - _fallback_fini (&state); - - return status; -} - -cairo_status_t -_cairo_surface_fallback_fill_rectangles (cairo_surface_t *surface, - cairo_operator_t op, - const cairo_color_t *color, - cairo_rectangle_int_t *rects, - int num_rects) -{ - fallback_state_t state; - cairo_rectangle_int_t *offset_rects = NULL; - cairo_status_t status; - int x1, y1, x2, y2; - int i; - - assert (surface->snapshot_of == NULL); - - if (num_rects <= 0) - return CAIRO_STATUS_SUCCESS; - - /* Compute the bounds of the rectangles, so that we know what area of the - * destination surface to fetch - */ - x1 = rects[0].x; - y1 = rects[0].y; - x2 = rects[0].x + rects[0].width; - y2 = rects[0].y + rects[0].height; - - for (i = 1; i < num_rects; i++) { - if (rects[i].x < x1) - x1 = rects[i].x; - if (rects[i].y < y1) - y1 = rects[i].y; - - if ((int) (rects[i].x + rects[i].width) > x2) - x2 = rects[i].x + rects[i].width; - if ((int) (rects[i].y + rects[i].height) > y2) - y2 = rects[i].y + rects[i].height; - } - - status = _fallback_init (&state, surface, x1, y1, x2 - x1, y2 - y1); - if (unlikely (status)) - return status; - - /* If the fetched image isn't at 0,0, we need to offset the rectangles */ - - if (state.image_rect.x != 0 || state.image_rect.y != 0) { - offset_rects = _cairo_malloc_ab (num_rects, sizeof (cairo_rectangle_int_t)); - if (unlikely (offset_rects == NULL)) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto DONE; - } - - for (i = 0; i < num_rects; i++) { - offset_rects[i].x = rects[i].x - state.image_rect.x; - offset_rects[i].y = rects[i].y - state.image_rect.y; - offset_rects[i].width = rects[i].width; - offset_rects[i].height = rects[i].height; - } - - rects = offset_rects; - } - - status = _cairo_surface_fill_rectangles (&state.image->base, - op, color, - rects, num_rects); - - free (offset_rects); - - DONE: - _fallback_fini (&state); - - return status; -} - -cairo_status_t -_cairo_surface_fallback_composite_trapezoids (cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_surface_t *dst, - cairo_antialias_t antialias, - int src_x, - int src_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_trapezoid_t *traps, - int num_traps, - cairo_region_t *clip_region) -{ - fallback_state_t state; - cairo_region_t *fallback_region = NULL; - cairo_trapezoid_t *offset_traps = NULL; - cairo_status_t status; - - status = _fallback_init (&state, dst, dst_x, dst_y, width, height); - if (unlikely (status)) - return status; - - /* If the destination image isn't at 0,0, we need to offset the trapezoids */ - - if (state.image_rect.x != 0 || state.image_rect.y != 0) { - offset_traps = _cairo_malloc_ab (num_traps, sizeof (cairo_trapezoid_t)); - if (offset_traps == NULL) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto FAIL; - } - - _cairo_trapezoid_array_translate_and_scale (offset_traps, traps, num_traps, - - state.image_rect.x, - state.image_rect.y, - 1.0, 1.0); - traps = offset_traps; - - /* similarly we need to adjust the region */ - if (clip_region != NULL) { - fallback_region = cairo_region_copy (clip_region); - status = fallback_region->status; - if (unlikely (status)) - goto FAIL; - - cairo_region_translate (fallback_region, - -state.image_rect.x, - -state.image_rect.y); - clip_region = fallback_region; - } - } - - status = _cairo_surface_composite_trapezoids (op, pattern, - &state.image->base, - antialias, - src_x, src_y, - dst_x - state.image_rect.x, - dst_y - state.image_rect.y, - width, height, - traps, num_traps, - clip_region); - FAIL: - free (offset_traps); - - if (fallback_region != NULL) - cairo_region_destroy (fallback_region); - - _fallback_fini (&state); - - return status; -} - -cairo_status_t -_cairo_surface_fallback_clone_similar (cairo_surface_t *surface, - cairo_surface_t *src, - int src_x, - int src_y, - int width, - int height, - int *clone_offset_x, - int *clone_offset_y, - cairo_surface_t **clone_out) -{ - cairo_surface_t *new_surface; - cairo_surface_pattern_t pattern; - cairo_status_t status; - - new_surface = _cairo_surface_create_similar_scratch (surface, - src->content, - width, height); - if (new_surface == NULL) - return CAIRO_INT_STATUS_UNSUPPORTED; - if (unlikely (new_surface->status)) - return new_surface->status; - - /* We have to copy these here, so that the coordinate spaces are correct */ - new_surface->device_transform = src->device_transform; - new_surface->device_transform_inverse = src->device_transform_inverse; - - _cairo_pattern_init_for_surface (&pattern, src); - cairo_matrix_init_translate (&pattern.base.matrix, src_x, src_y); - pattern.base.filter = CAIRO_FILTER_NEAREST; - - status = _cairo_surface_paint (new_surface, - CAIRO_OPERATOR_SOURCE, - &pattern.base, - NULL); - _cairo_pattern_fini (&pattern.base); - - if (unlikely (status)) { - cairo_surface_destroy (new_surface); - return status; - } - - *clone_offset_x = src_x; - *clone_offset_y = src_y; - *clone_out = new_surface; - return CAIRO_STATUS_SUCCESS; +cairo_int_status_t +_cairo_surface_fallback_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_compositor_glyphs (&_cairo_fallback_compositor, + surface, op, source, + glyphs, num_glyphs, scaled_font, + clip); } diff --git a/src/cairo-surface-observer-private.h b/src/cairo-surface-observer-private.h index 61507b21..1b5d6d94 100644 --- a/src/cairo-surface-observer-private.h +++ b/src/cairo-surface-observer-private.h @@ -33,14 +33,16 @@ * Chris Wilson <chris@chris-wilson.co.uk> */ -#ifndef CAIRO_SURFACE_SNAPSHOT_PRIVATE_H -#define CAIRO_SURFACE_SNAPSHOT_PRIVATE_H +#ifndef CAIRO_SURFACE_OBSERVER_PRIVATE_H +#define CAIRO_SURFACE_OBSERVER_PRIVATE_H -#include "cairoint.h" /* cairo_surface_backend_t */ +#include "cairoint.h" #include "cairo-device-private.h" +#include "cairo-list-private.h" #include "cairo-recording-surface-private.h" #include "cairo-surface-private.h" +#include "cairo-surface-backend-private.h" #include "cairo-time-private.h" struct stat { @@ -180,11 +182,27 @@ struct _cairo_device_observer { cairo_observation_t log; }; +struct callback_list { + cairo_list_t link; + + cairo_surface_observer_callback_t func; + void *data; +}; + struct _cairo_surface_observer { cairo_surface_t base; cairo_surface_t *target; cairo_observation_t log; + + cairo_list_t paint_callbacks; + cairo_list_t mask_callbacks; + cairo_list_t fill_callbacks; + cairo_list_t stroke_callbacks; + cairo_list_t glyphs_callbacks; + + cairo_list_t flush_callbacks; + cairo_list_t finish_callbacks; }; static inline cairo_surface_t * diff --git a/src/cairo-surface-observer.c b/src/cairo-surface-observer.c index 3314b823..f2c41646 100644 --- a/src/cairo-surface-observer.c +++ b/src/cairo-surface-observer.c @@ -37,6 +37,7 @@ #include "cairo-surface-observer-private.h" +#include "cairo-array-private.h" #include "cairo-combsort-private.h" #include "cairo-composite-rectangles-private.h" #include "cairo-error-private.h" @@ -385,18 +386,38 @@ _cairo_surface_create_observer_internal (cairo_device_t *device, surface->base.type = surface->target->type; surface->base.is_clear = surface->target->is_clear; + cairo_list_init (&surface->paint_callbacks); + cairo_list_init (&surface->mask_callbacks); + cairo_list_init (&surface->fill_callbacks); + cairo_list_init (&surface->stroke_callbacks); + cairo_list_init (&surface->glyphs_callbacks); + + cairo_list_init (&surface->flush_callbacks); + cairo_list_init (&surface->finish_callbacks); + surface->log.num_surfaces++; to_device (surface)->log.num_surfaces++; return &surface->base; } +static inline void +do_callbacks (cairo_surface_observer_t *surface, cairo_list_t *head) +{ + struct callback_list *cb; + + cairo_list_foreach_entry (cb, struct callback_list, head, link) + cb->func (&surface->base, surface->target, cb->data); +} + static cairo_status_t _cairo_surface_observer_finish (void *abstract_surface) { cairo_surface_observer_t *surface = abstract_surface; + do_callbacks (surface, &surface->finish_callbacks); + cairo_surface_destroy (surface->target); log_fini (&surface->log); @@ -630,11 +651,11 @@ add_record (cairo_observation_t *log, static void sync (cairo_surface_t *target, int x, int y) { - cairo_rectangle_t extents; + cairo_rectangle_int_t extents; extents.x = x; extents.y = y; - extents.width = 1; + extents.width = 1; extents.height = 1; cairo_surface_unmap_image (target, @@ -687,7 +708,6 @@ _cairo_surface_observer_paint (void *abstract_surface, cairo_surface_observer_t *surface = abstract_surface; cairo_device_observer_t *device = to_device (surface); cairo_composite_rectangles_t composite; - cairo_rectangle_int_t extents; cairo_int_status_t status; cairo_time_t t; int x, y; @@ -704,9 +724,8 @@ _cairo_surface_observer_paint (void *abstract_surface, add_pattern (&device->log.paint.source, source, surface->target); add_clip (&device->log.paint.clip, clip); - _cairo_surface_get_extents (surface->target, &extents); status = _cairo_composite_rectangles_init_for_paint (&composite, - &extents, + surface->target, op, source, clip); if (unlikely (status)) { @@ -722,9 +741,9 @@ _cairo_surface_observer_paint (void *abstract_surface, _cairo_composite_rectangles_fini (&composite); t = _cairo_time_get (); - status = _cairo_surface_paint (surface->target, - op, source, - clip); + status = _cairo_surface_paint (surface->target, + op, source, + clip); if (unlikely (status)) return status; @@ -734,6 +753,8 @@ _cairo_surface_observer_paint (void *abstract_surface, add_record_paint (&surface->log, surface->target, op, source, clip, t); add_record_paint (&device->log, surface->target, op, source, clip, t); + do_callbacks (surface, &surface->paint_callbacks); + return CAIRO_STATUS_SUCCESS; } @@ -773,7 +794,6 @@ _cairo_surface_observer_mask (void *abstract_surface, cairo_surface_observer_t *surface = abstract_surface; cairo_device_observer_t *device = to_device (surface); cairo_composite_rectangles_t composite; - cairo_rectangle_int_t extents; cairo_int_status_t status; cairo_time_t t; int x, y; @@ -790,9 +810,8 @@ _cairo_surface_observer_mask (void *abstract_surface, add_pattern (&device->log.mask.mask, mask, surface->target); add_clip (&device->log.mask.clip, clip); - _cairo_surface_get_extents (surface->target, &extents); status = _cairo_composite_rectangles_init_for_mask (&composite, - &extents, + surface->target, op, source, mask, clip); if (unlikely (status)) { @@ -824,6 +843,8 @@ _cairo_surface_observer_mask (void *abstract_surface, surface->target, op, source, mask, clip, t); + do_callbacks (surface, &surface->mask_callbacks); + return CAIRO_STATUS_SUCCESS; } @@ -875,7 +896,6 @@ _cairo_surface_observer_fill (void *abstract_surface, cairo_surface_observer_t *surface = abstract_surface; cairo_device_observer_t *device = to_device (surface); cairo_composite_rectangles_t composite; - cairo_rectangle_int_t extents; cairo_int_status_t status; cairo_time_t t; int x, y; @@ -896,9 +916,8 @@ _cairo_surface_observer_fill (void *abstract_surface, add_path (&device->log.fill.path, path, TRUE); add_clip (&device->log.fill.clip, clip); - _cairo_surface_get_extents (surface->target, &extents); status = _cairo_composite_rectangles_init_for_fill (&composite, - &extents, + surface->target, op, source, path, clip); if (unlikely (status)) { @@ -934,6 +953,8 @@ _cairo_surface_observer_fill (void *abstract_surface, fill_rule, tolerance, antialias, clip, t); + do_callbacks (surface, &surface->fill_callbacks); + return CAIRO_STATUS_SUCCESS; } @@ -990,7 +1011,6 @@ _cairo_surface_observer_stroke (void *abstract_surface, cairo_surface_observer_t *surface = abstract_surface; cairo_device_observer_t *device = to_device (surface); cairo_composite_rectangles_t composite; - cairo_rectangle_int_t extents; cairo_int_status_t status; cairo_time_t t; int x, y; @@ -1013,9 +1033,8 @@ _cairo_surface_observer_stroke (void *abstract_surface, add_path (&device->log.stroke.path, path, FALSE); add_clip (&device->log.stroke.clip, clip); - _cairo_surface_get_extents (surface->target, &extents); status = _cairo_composite_rectangles_init_for_stroke (&composite, - &extents, + surface->target, op, source, path, style, ctm, clip); @@ -1055,6 +1074,8 @@ _cairo_surface_observer_stroke (void *abstract_surface, tolerance, antialias, clip, t); + do_callbacks (surface, &surface->stroke_callbacks); + return CAIRO_STATUS_SUCCESS; } @@ -1101,13 +1122,11 @@ _cairo_surface_observer_glyphs (void *abstract_surface, cairo_glyph_t *glyphs, int num_glyphs, cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip, - int *remaining_glyphs) + const cairo_clip_t *clip) { cairo_surface_observer_t *surface = abstract_surface; cairo_device_observer_t *device = to_device (surface); cairo_composite_rectangles_t composite; - cairo_rectangle_int_t extents; cairo_int_status_t status; cairo_glyph_t *dev_glyphs; cairo_time_t t; @@ -1123,9 +1142,8 @@ _cairo_surface_observer_glyphs (void *abstract_surface, add_pattern (&device->log.glyphs.source, source, surface->target); add_clip (&device->log.glyphs.clip, clip); - _cairo_surface_get_extents (surface->target, &extents); status = _cairo_composite_rectangles_init_for_glyphs (&composite, - &extents, + surface->target, op, source, scaled_font, glyphs, num_glyphs, @@ -1150,7 +1168,6 @@ _cairo_surface_observer_glyphs (void *abstract_surface, return _cairo_error (CAIRO_STATUS_NO_MEMORY); memcpy (dev_glyphs, glyphs, num_glyphs * sizeof (cairo_glyph_t)); - *remaining_glyphs = 0; t = _cairo_time_get (); status = _cairo_surface_show_text_glyphs (surface->target, op, source, NULL, 0, @@ -1175,6 +1192,8 @@ _cairo_surface_observer_glyphs (void *abstract_surface, glyphs, num_glyphs, scaled_font, clip, t); + do_callbacks (surface, &surface->glyphs_callbacks); + return CAIRO_STATUS_SUCCESS; } @@ -1183,6 +1202,8 @@ _cairo_surface_observer_flush (void *abstract_surface) { cairo_surface_observer_t *surface = abstract_surface; + do_callbacks (surface, &surface->flush_callbacks); + cairo_surface_flush (surface->target); return surface->target->status; } @@ -1314,33 +1335,23 @@ static const cairo_surface_backend_t _cairo_surface_observer_backend = { _cairo_surface_observer_acquire_source_image, _cairo_surface_observer_release_source_image, - - NULL, NULL, /* acquire, release dest */ - NULL, /* clone similar */ - NULL, /* composite */ - NULL, /* fill rectangles */ - NULL, /* composite trapezoids */ - NULL, /* create span renderer */ - NULL, /* check span renderer */ + _cairo_surface_observer_snapshot, _cairo_surface_observer_copy_page, _cairo_surface_observer_show_page, _cairo_surface_observer_get_extents, - NULL, /* old_show_glyphs */ _cairo_surface_observer_get_font_options, + _cairo_surface_observer_flush, _cairo_surface_observer_mark_dirty, - NULL, /* font_fini */ - NULL, /* glyph_fini */ _cairo_surface_observer_paint, _cairo_surface_observer_mask, _cairo_surface_observer_stroke, _cairo_surface_observer_fill, + NULL, /* fill-stroke */ _cairo_surface_observer_glyphs, - - _cairo_surface_observer_snapshot, }; /** @@ -1385,6 +1396,150 @@ cairo_surface_create_observer (cairo_surface_t *target, return surface; } +static cairo_status_t +_cairo_surface_observer_add_callback (cairo_list_t *head, + cairo_surface_observer_callback_t func, + void *data) +{ + struct callback_list *cb; + + cb = malloc (sizeof (*cb)); + if (unlikely (cb == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + cairo_list_add (&cb->link, head); + cb->func = func; + cb->data = data; + + return CAIRO_STATUS_SUCCESS; +} + +cairo_status_t +cairo_surface_observer_add_paint_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data) +{ + cairo_surface_observer_t *surface; + + if (unlikely (CAIRO_REFERENCE_COUNT_IS_INVALID (&abstract_surface->ref_count))) + return abstract_surface->status; + + if (! _cairo_surface_is_observer (abstract_surface)) + return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); + + surface = (cairo_surface_observer_t *)abstract_surface; + return _cairo_surface_observer_add_callback (&surface->paint_callbacks, + func, data); +} + +cairo_status_t +cairo_surface_observer_add_mask_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data) +{ + cairo_surface_observer_t *surface; + + if (unlikely (CAIRO_REFERENCE_COUNT_IS_INVALID (&abstract_surface->ref_count))) + return abstract_surface->status; + + if (! _cairo_surface_is_observer (abstract_surface)) + return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); + + surface = (cairo_surface_observer_t *)abstract_surface; + return _cairo_surface_observer_add_callback (&surface->mask_callbacks, + func, data); +} + +cairo_status_t +cairo_surface_observer_add_fill_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data) +{ + cairo_surface_observer_t *surface; + + if (unlikely (CAIRO_REFERENCE_COUNT_IS_INVALID (&abstract_surface->ref_count))) + return abstract_surface->status; + + if (! _cairo_surface_is_observer (abstract_surface)) + return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); + + surface = (cairo_surface_observer_t *)abstract_surface; + return _cairo_surface_observer_add_callback (&surface->fill_callbacks, + func, data); +} + +cairo_status_t +cairo_surface_observer_add_stroke_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data) +{ + cairo_surface_observer_t *surface; + + if (unlikely (CAIRO_REFERENCE_COUNT_IS_INVALID (&abstract_surface->ref_count))) + return abstract_surface->status; + + if (! _cairo_surface_is_observer (abstract_surface)) + return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); + + surface = (cairo_surface_observer_t *)abstract_surface; + return _cairo_surface_observer_add_callback (&surface->stroke_callbacks, + func, data); +} + +cairo_status_t +cairo_surface_observer_add_glyphs_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data) +{ + cairo_surface_observer_t *surface; + + if (unlikely (CAIRO_REFERENCE_COUNT_IS_INVALID (&abstract_surface->ref_count))) + return abstract_surface->status; + + if (! _cairo_surface_is_observer (abstract_surface)) + return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); + + surface = (cairo_surface_observer_t *)abstract_surface; + return _cairo_surface_observer_add_callback (&surface->glyphs_callbacks, + func, data); +} + +cairo_status_t +cairo_surface_observer_add_flush_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data) +{ + cairo_surface_observer_t *surface; + + if (unlikely (CAIRO_REFERENCE_COUNT_IS_INVALID (&abstract_surface->ref_count))) + return abstract_surface->status; + + if (! _cairo_surface_is_observer (abstract_surface)) + return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); + + surface = (cairo_surface_observer_t *)abstract_surface; + return _cairo_surface_observer_add_callback (&surface->flush_callbacks, + func, data); +} + +cairo_status_t +cairo_surface_observer_add_finish_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data) +{ + cairo_surface_observer_t *surface; + + if (unlikely (CAIRO_REFERENCE_COUNT_IS_INVALID (&abstract_surface->ref_count))) + return abstract_surface->status; + + if (! _cairo_surface_is_observer (abstract_surface)) + return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); + + surface = (cairo_surface_observer_t *)abstract_surface; + return _cairo_surface_observer_add_callback (&surface->finish_callbacks, + func, data); +} + static void print_extents (cairo_output_stream_t *stream, const struct extents *e) { diff --git a/src/cairo-surface-private.h b/src/cairo-surface-private.h index 31ddb8c7..0bebfde7 100644 --- a/src/cairo-surface-private.h +++ b/src/cairo-surface-private.h @@ -61,6 +61,7 @@ struct _cairo_surface { cairo_reference_count_t ref_count; cairo_status_t status; unsigned int unique_id; + unsigned int serial; unsigned finished : 1; unsigned is_clear : 1; diff --git a/src/cairo-surface-snapshot-private.h b/src/cairo-surface-snapshot-private.h index 0b1c8d34..b7a4d05f 100644 --- a/src/cairo-surface-snapshot-private.h +++ b/src/cairo-surface-snapshot-private.h @@ -36,9 +36,8 @@ #ifndef CAIRO_SURFACE_SNAPSHOT_PRIVATE_H #define CAIRO_SURFACE_SNAPSHOT_PRIVATE_H -#include "cairoint.h" /* for cairo_surface_backend_t */ - #include "cairo-surface-private.h" +#include "cairo-surface-backend-private.h" struct _cairo_surface_snapshot { cairo_surface_t base; diff --git a/src/cairo-surface-snapshot.c b/src/cairo-surface-snapshot.c index 16153e21..4bc40e7e 100644 --- a/src/cairo-surface-snapshot.c +++ b/src/cairo-surface-snapshot.c @@ -109,18 +109,14 @@ static const cairo_surface_backend_t _cairo_surface_snapshot_backend = { _cairo_surface_snapshot_acquire_source_image, _cairo_surface_snapshot_release_source_image, - NULL, NULL, /* acquire, release dest */ - NULL, /* clone similar */ - NULL, /* composite */ - NULL, /* fill rectangles */ - NULL, /* composite trapezoids */ - NULL, /* create span renderer */ - NULL, /* check span renderer */ + NULL, /* snapshot */ + NULL, /* copy_page */ NULL, /* show_page */ + _cairo_surface_snapshot_get_extents, - NULL, /* old-show-glyphs */ NULL, /* get-font-options */ + _cairo_surface_snapshot_flush, }; @@ -141,8 +137,10 @@ _cairo_surface_snapshot_copy_on_write (cairo_surface_t *surface) if (snapshot->target->backend->snapshot != NULL) { clone = snapshot->target->backend->snapshot (snapshot->target); - if (clone != NULL) + if (clone != NULL) { + assert (clone->status || ! _cairo_surface_is_snapshot (clone)); goto done; + } } /* XXX copy to a similar surface, leave acquisition till later? @@ -160,7 +158,6 @@ _cairo_surface_snapshot_copy_on_write (cairo_surface_t *surface) done: status = _cairo_surface_set_error (surface, clone->status); - assert (! _cairo_surface_is_snapshot (clone)); snapshot->target = snapshot->clone = clone; snapshot->base.type = clone->type; } diff --git a/src/cairo-surface-subsurface-private.h b/src/cairo-surface-subsurface-private.h index ada09a17..6a43c8fa 100644 --- a/src/cairo-surface-subsurface-private.h +++ b/src/cairo-surface-subsurface-private.h @@ -36,9 +36,8 @@ #ifndef CAIRO_SURFACE_SUBSURFACE_PRIVATE_H #define CAIRO_SURFACE_SUBSURFACE_PRIVATE_H -#include "cairoint.h" /* for cairo_surface_backend_t */ - #include "cairo-surface-private.h" +#include "cairo-surface-backend-private.h" struct _cairo_surface_subsurface { cairo_surface_t base; @@ -54,6 +53,25 @@ _cairo_surface_subsurface_get_target (cairo_surface_t *surface) return ((cairo_surface_subsurface_t *) surface)->target; } +static inline void +_cairo_surface_subsurface_offset (cairo_surface_t *surface, + int *x, int *y) +{ + cairo_surface_subsurface_t *ss = (cairo_surface_subsurface_t *) surface; + *x += ss->extents.x; + *y += ss->extents.y; +} + +static inline cairo_surface_t * +_cairo_surface_subsurface_get_target_with_offset (cairo_surface_t *surface, + int *x, int *y) +{ + cairo_surface_subsurface_t *ss = (cairo_surface_subsurface_t *) surface; + *x += ss->extents.x; + *y += ss->extents.y; + return ss->target; +} + static inline cairo_bool_t _cairo_surface_is_subsurface (cairo_surface_t *surface) { diff --git a/src/cairo-surface-subsurface.c b/src/cairo-surface-subsurface.c index 73be5f2d..48d10fb1 100644 --- a/src/cairo-surface-subsurface.c +++ b/src/cairo-surface-subsurface.c @@ -202,8 +202,7 @@ _cairo_surface_subsurface_glyphs (void *abstract_surface, cairo_glyph_t *glyphs, int num_glyphs, cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip, - int *remaining_glyphs) + const cairo_clip_t *clip) { cairo_surface_subsurface_t *surface = abstract_surface; cairo_rectangle_int_t rect = { 0, 0, surface->extents.width, surface->extents.height }; @@ -216,7 +215,6 @@ _cairo_surface_subsurface_glyphs (void *abstract_surface, op, source, scaled_font, glyphs, num_glyphs, target_clip); - *remaining_glyphs = 0; _cairo_clip_destroy (target_clip); return status; } @@ -489,30 +487,23 @@ static const cairo_surface_backend_t _cairo_surface_subsurface_backend = { _cairo_surface_subsurface_acquire_source_image, _cairo_surface_subsurface_release_source_image, - NULL, NULL, /* acquire, release dest */ - NULL, /* clone similar */ - NULL, /* composite */ - NULL, /* fill rectangles */ - NULL, /* composite trapezoids */ - NULL, /* create span renderer */ - NULL, /* check span renderer */ + _cairo_surface_subsurface_snapshot, + NULL, /* copy_page */ NULL, /* show_page */ + _cairo_surface_subsurface_get_extents, - NULL, /* old_show_glyphs */ _cairo_surface_subsurface_get_font_options, + _cairo_surface_subsurface_flush, _cairo_surface_subsurface_mark_dirty, - NULL, /* font_fini */ - NULL, /* glyph_fini */ _cairo_surface_subsurface_paint, _cairo_surface_subsurface_mask, _cairo_surface_subsurface_stroke, _cairo_surface_subsurface_fill, + NULL, /* fill/stroke */ _cairo_surface_subsurface_glyphs, - - _cairo_surface_subsurface_snapshot, }; /** diff --git a/src/cairo-surface-wrapper-private.h b/src/cairo-surface-wrapper-private.h index fbe5d80f..6529ebc1 100644 --- a/src/cairo-surface-wrapper-private.h +++ b/src/cairo-surface-wrapper-private.h @@ -41,6 +41,7 @@ #include "cairoint.h" #include "cairo-types-private.h" +#include "cairo-surface-backend-private.h" CAIRO_BEGIN_DECLS diff --git a/src/cairo-surface-wrapper.c b/src/cairo-surface-wrapper.c index 5e628690..d2d971de 100644 --- a/src/cairo-surface-wrapper.c +++ b/src/cairo-surface-wrapper.c @@ -446,7 +446,7 @@ _cairo_surface_wrapper_show_text_glyphs (cairo_surface_wrapper_t *wrapper, if (num_glyphs > ARRAY_LENGTH (stack_glyphs)) { dev_glyphs = _cairo_malloc_ab (num_glyphs, sizeof (cairo_glyph_t)); - if (dev_glyphs == NULL) { + if (unlikely (dev_glyphs == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto FINISH; } @@ -454,7 +454,9 @@ _cairo_surface_wrapper_show_text_glyphs (cairo_surface_wrapper_t *wrapper, for (i = 0; i < num_glyphs; i++) { dev_glyphs[i] = glyphs[i]; - cairo_matrix_transform_point (&m, &dev_glyphs[i].x, &dev_glyphs[i].y); + cairo_matrix_transform_point (&m, + &dev_glyphs[i].x, + &dev_glyphs[i].y); } status = cairo_matrix_invert (&m); diff --git a/src/cairo-surface.c b/src/cairo-surface.c index d15b94b7..84883801 100644 --- a/src/cairo-surface.c +++ b/src/cairo-surface.c @@ -38,7 +38,7 @@ #include "cairoint.h" -#include "cairo-surface-fallback-private.h" +#include "cairo-array-private.h" #include "cairo-clip-private.h" #include "cairo-device-private.h" #include "cairo-error-private.h" @@ -103,6 +103,7 @@ const cairo_surface_t name = { \ CAIRO_REFERENCE_COUNT_INVALID, /* ref_count */ \ status, /* status */ \ 0, /* unique id */ \ + 0, /* serial */ \ FALSE, /* finished */ \ TRUE, /* is_clear */ \ FALSE, /* has_font_options */ \ @@ -182,7 +183,7 @@ _cairo_surface_set_error (cairo_surface_t *surface, /* Don't overwrite an existing error. This preserves the first * error, which is the most significant. */ - _cairo_status_set_error (&surface->status, status); + _cairo_status_set_error (&surface->status, (cairo_status_t)status); return _cairo_error (status); } @@ -367,7 +368,6 @@ _cairo_surface_has_snapshot (cairo_surface_t *surface, cairo_list_foreach_entry (snapshot, cairo_surface_t, &surface->snapshots, snapshot) { - /* XXX is_similar? */ if (snapshot->backend == backend) return snapshot; } @@ -375,15 +375,6 @@ _cairo_surface_has_snapshot (cairo_surface_t *surface, return NULL; } -static cairo_bool_t -_cairo_surface_is_writable (cairo_surface_t *surface) -{ - return ! surface->finished && - surface->snapshot_of == NULL && - ! _cairo_surface_has_snapshots (surface) && - ! _cairo_surface_has_mime_data (surface); -} - static void _cairo_surface_begin_modification (cairo_surface_t *surface) { @@ -413,6 +404,7 @@ _cairo_surface_init (cairo_surface_t *surface, surface->unique_id = _cairo_surface_allocate_unique_id (); surface->finished = FALSE; surface->is_clear = FALSE; + surface->serial = 0; surface->owns_device = (device != NULL); _cairo_user_data_array_init (&surface->user_data); @@ -461,12 +453,15 @@ _cairo_surface_create_similar_scratch (cairo_surface_t *other, if (unlikely (other->status)) return _cairo_surface_create_in_error (other->status); - if (other->backend->create_similar == NULL) - return NULL; + surface = NULL; + if (other->backend->create_similar) + surface = other->backend->create_similar (other, content, width, height); + if (surface == NULL) + surface = cairo_surface_create_similar_image (other, + _cairo_format_from_content (content), + width, height); - surface = other->backend->create_similar (other, - content, width, height); - if (surface == NULL || surface->status) + if (unlikely (surface->status)) return surface; _cairo_surface_copy_similar_properties (surface, other); @@ -518,18 +513,16 @@ cairo_surface_create_similar (cairo_surface_t *other, return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE); if (unlikely (! CAIRO_CONTENT_VALID (content))) - return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_CONTENT)); + return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_CONTENT); surface = _cairo_surface_create_similar_solid (other, content, width, height, - CAIRO_COLOR_TRANSPARENT, - TRUE); + CAIRO_COLOR_TRANSPARENT); assert (surface->is_clear); return surface; } - /** * cairo_surface_create_similar_image: * @other: an existing surface used to select the preference of the new surface @@ -564,7 +557,7 @@ cairo_surface_create_similar_image (cairo_surface_t *other, { cairo_surface_t *image; - if (other->status) + if (unlikely (other->status)) return _cairo_surface_create_in_error (other->status); if (unlikely (other->finished)) return _cairo_surface_create_in_error (CAIRO_STATUS_SURFACE_FINISHED); @@ -572,7 +565,7 @@ cairo_surface_create_similar_image (cairo_surface_t *other, if (unlikely (width < 0 || height < 0)) return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE); if (unlikely (! CAIRO_FORMAT_VALID (format))) - return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_FORMAT)); + return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_FORMAT); image = NULL; if (other->backend->create_similar_image) @@ -580,8 +573,12 @@ cairo_surface_create_similar_image (cairo_surface_t *other, format, width, height); if (image == NULL) image = cairo_image_surface_create (format, width, height); + + assert (image->is_clear); + return image; } +slim_hidden_def (cairo_surface_create_similar_image); /** * cairo_surface_map_to_image: @@ -608,7 +605,7 @@ cairo_surface_create_similar_image (cairo_surface_t *other, **/ cairo_surface_t * cairo_surface_map_to_image (cairo_surface_t *surface, - const cairo_rectangle_t *extents) + const cairo_rectangle_int_t *extents) { cairo_rectangle_int_t rect; cairo_surface_t *image; @@ -621,32 +618,35 @@ cairo_surface_map_to_image (cairo_surface_t *surface, if (extents == NULL) { if (unlikely (! surface->backend->get_extents (surface, &rect))) return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE); + + extents = ▭ } else { cairo_rectangle_int_t surface_extents; - _cairo_rectangle_int_from_double (&rect, extents); /* If this surface is bounded, we can't map parts * that are outside of it. */ if (likely (surface->backend->get_extents (surface, &surface_extents))) { - if (unlikely (rect.x < surface_extents.x || - rect.y < surface_extents.y || - rect.x + rect.width > surface_extents.x + surface_extents.width || - rect.y + rect.height > surface_extents.y + surface_extents.height)) + if (unlikely (extents->x < surface_extents.x || + extents->y < surface_extents.y || + extents->x + extents->width > surface_extents.x + surface_extents.width || + extents->y + extents->height > surface_extents.y + surface_extents.height)) return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE); } } image = NULL; if (surface->backend->map_to_image) - image = surface->backend->map_to_image (surface, &rect); + image = surface->backend->map_to_image (surface, extents); if (image == NULL) { cairo_surface_pattern_t pattern; cairo_status_t status; - image = cairo_image_surface_create (_cairo_format_from_content (surface->content), - rect.width, rect.height); - cairo_surface_set_device_offset (image, -rect.y, -rect.y); + image = cairo_surface_create_similar_image (surface, + _cairo_format_from_content (surface->content), + extents->width, + extents->height); + cairo_surface_set_device_offset (image, -extents->y, -extents->y); _cairo_pattern_init_for_surface (&pattern, surface); pattern.base.filter = CAIRO_FILTER_NEAREST; @@ -711,6 +711,12 @@ cairo_surface_unmap_image (cairo_surface_t *surface, goto error; } + /* If the image is untouched just skip the update */ + if (image->serial == 0) { + status = CAIRO_STATUS_SUCCESS; + goto error; + } + status = CAIRO_INT_STATUS_UNSUPPORTED; if (surface->backend->unmap_image) status = surface->backend->unmap_image (surface, (cairo_image_surface_t *) image); @@ -731,9 +737,8 @@ cairo_surface_unmap_image (cairo_surface_t *surface, /* And we also have to clip the operation to the image's extents */ extents.x = image->device_transform_inverse.x0; extents.y = image->device_transform_inverse.y0; - extents.width = img->width; + extents.width = img->width; extents.height = img->height; - clip = _cairo_clip_intersect_rectangle (NULL, &extents); status = _cairo_surface_paint (surface, @@ -758,8 +763,7 @@ _cairo_surface_create_similar_solid (cairo_surface_t *other, cairo_content_t content, int width, int height, - const cairo_color_t *color, - cairo_bool_t allow_fallback) + const cairo_color_t *color) { cairo_status_t status; cairo_surface_t *surface; @@ -767,10 +771,7 @@ _cairo_surface_create_similar_solid (cairo_surface_t *other, surface = _cairo_surface_create_similar_scratch (other, content, width, height); - if (surface == NULL && allow_fallback) - surface = _cairo_image_surface_create_with_content (content, - width, height); - if (surface == NULL || surface->status) + if (unlikely (surface->status)) return surface; _cairo_pattern_init_solid (&pattern, color); @@ -786,51 +787,6 @@ _cairo_surface_create_similar_solid (cairo_surface_t *other, return surface; } -cairo_surface_t * -_cairo_surface_create_solid_pattern_surface (cairo_surface_t *other, - const cairo_solid_pattern_t *solid_pattern) -{ - if (other->backend->create_solid_pattern_surface != NULL) { - cairo_surface_t *surface; - - surface = other->backend->create_solid_pattern_surface (other, - solid_pattern); - if (surface) - return surface; - } - - return _cairo_surface_create_similar_solid (other, - _cairo_color_get_content (&solid_pattern->color), - 1, 1, - &solid_pattern->color, - FALSE); -} - -cairo_int_status_t -_cairo_surface_repaint_solid_pattern_surface (cairo_surface_t *other, - cairo_surface_t *solid_surface, - const cairo_solid_pattern_t *solid_pattern) -{ - /* Solid pattern surface for these backends are special and not trivial - * to repaint. Skip repainting. - * - * This does not work optimally with things like analysis surface that - * are proxies. But returning UNSUPPORTED is *safe* as it only - * disables some caching. - */ - if (other->backend->create_solid_pattern_surface != NULL && - ! other->backend->can_repaint_solid_pattern_surface (solid_surface, - solid_pattern)) - { - return CAIRO_INT_STATUS_UNSUPPORTED; - } - - return _cairo_surface_paint (solid_surface, - CAIRO_OPERATOR_SOURCE, - &solid_pattern->base, - NULL); -} - /** * cairo_surface_reference: * @surface: a #cairo_surface_t @@ -967,7 +923,7 @@ cairo_surface_finish (cairo_surface_t *surface) if (surface->backend->finish) { status = surface->backend->finish (surface); if (unlikely (status)) - status = _cairo_surface_set_error (surface, status); + _cairo_surface_set_error (surface, status); } assert (surface->snapshot_of == NULL); @@ -1012,8 +968,7 @@ void * cairo_surface_get_user_data (cairo_surface_t *surface, const cairo_user_data_key_t *key) { - return _cairo_user_data_array_get_data (&surface->user_data, - key); + return _cairo_user_data_array_get_data (&surface->user_data, key); } /** @@ -1192,7 +1147,7 @@ cairo_surface_set_mime_data (cairo_surface_t *surface, if (unlikely (surface->status)) return surface->status; - if (surface->finished) + if (unlikely (surface->finished)) return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); status = _cairo_intern_string (&mime_type, -1); @@ -1279,16 +1234,13 @@ void _cairo_surface_set_font_options (cairo_surface_t *surface, cairo_font_options_t *options) { - cairo_status_t status; - if (surface->status) return; assert (surface->snapshot_of == NULL); if (surface->finished) { - status = _cairo_surface_set_error (surface, - _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); + _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); return; } @@ -1366,7 +1318,7 @@ cairo_surface_flush (cairo_surface_t *surface) if (surface->backend->flush) { status = surface->backend->flush (surface); if (unlikely (status)) - status = _cairo_surface_set_error (surface, status); + _cairo_surface_set_error (surface, status); } } slim_hidden_def (cairo_surface_flush); @@ -1411,13 +1363,13 @@ cairo_surface_mark_dirty_rectangle (cairo_surface_t *surface, { cairo_status_t status; - if (surface->status) + if (unlikely (surface->status)) return; assert (surface->snapshot_of == NULL); - if (surface->finished) { - status = _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); + if (unlikely (surface->finished)) { + _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); return; } @@ -1428,6 +1380,7 @@ cairo_surface_mark_dirty_rectangle (cairo_surface_t *surface, assert (! _cairo_surface_has_mime_data (surface)); surface->is_clear = FALSE; + surface->serial++; if (surface->backend->mark_dirty_rectangle != NULL) { /* XXX: FRAGILE: We're ignoring the scaling component of @@ -1441,7 +1394,7 @@ cairo_surface_mark_dirty_rectangle (cairo_surface_t *surface, width, height); if (unlikely (status)) - status = _cairo_surface_set_error (surface, status); + _cairo_surface_set_error (surface, status); } } slim_hidden_def (cairo_surface_mark_dirty_rectangle); @@ -1470,13 +1423,13 @@ _cairo_surface_set_device_scale (cairo_surface_t *surface, { cairo_status_t status; - if (surface->status) + if (unlikely (surface->status)) return; assert (surface->snapshot_of == NULL); - if (surface->finished) { - status = _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); + if (unlikely (surface->finished)) { + _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); return; } @@ -1520,13 +1473,13 @@ cairo_surface_set_device_offset (cairo_surface_t *surface, { cairo_status_t status; - if (surface->status) + if (unlikely (surface->status)) return; assert (surface->snapshot_of == NULL); - if (surface->finished) { - status = _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); + if (unlikely (surface->finished)) { + _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); return; } @@ -1605,15 +1558,13 @@ cairo_surface_set_fallback_resolution (cairo_surface_t *surface, double x_pixels_per_inch, double y_pixels_per_inch) { - cairo_status_t status; - - if (surface->status) + if (unlikely (surface->status)) return; assert (surface->snapshot_of == NULL); - if (surface->finished) { - status = _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); + if (unlikely (surface->finished)) { + _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); return; } @@ -1621,7 +1572,7 @@ cairo_surface_set_fallback_resolution (cairo_surface_t *surface, /* XXX Could delay raising the error until we fallback, but throwing * the error here means that we can catch the real culprit. */ - status = _cairo_surface_set_error (surface, CAIRO_STATUS_INVALID_MATRIX); + _cairo_surface_set_error (surface, CAIRO_STATUS_INVALID_MATRIX); return; } @@ -1685,7 +1636,7 @@ _cairo_surface_acquire_source_image (cairo_surface_t *surface, { cairo_status_t status; - if (surface->status) + if (unlikely (surface->status)) return surface->status; assert (!surface->finished); @@ -1703,33 +1654,6 @@ _cairo_surface_acquire_source_image (cairo_surface_t *surface, return CAIRO_STATUS_SUCCESS; } -cairo_status_t -_cairo_surface_acquire_source_image_transformed (cairo_surface_t *surface, - cairo_matrix_t *device_transform, - cairo_image_surface_t **image_out, - void **image_extra) -{ - cairo_status_t status; - - if (surface->status) - return surface->status; - - assert (!surface->finished); - - if (surface->backend->acquire_source_image_transformed == NULL) - return _cairo_surface_acquire_source_image (surface, - image_out, image_extra); - - status = surface->backend->acquire_source_image_transformed (surface, device_transform, - image_out, image_extra); - if (unlikely (status)) - return _cairo_surface_set_error (surface, status); - - _cairo_debug_check_image_surface_is_defined (&(*image_out)->base); - - return CAIRO_STATUS_SUCCESS; -} - /** * _cairo_surface_release_source_image: * @surface: a #cairo_surface_t @@ -1748,469 +1672,6 @@ _cairo_surface_release_source_image (cairo_surface_t *surface, surface->backend->release_source_image (surface, image, image_extra); } -/** - * _cairo_surface_acquire_dest_image: - * @surface: a #cairo_surface_t - * @interest_rect: area of @surface for which fallback drawing is being done. - * A value of %NULL indicates that the entire surface is desired. - * XXXX I'd like to get rid of being able to pass %NULL here (nothing seems to) - * @image_out: location to store a pointer to an image surface that includes at least - * the intersection of @interest_rect with the visible area of @surface. - * This surface could be @surface itself, a surface held internal to @surface, - * or it could be a new surface with a copy of the relevant portion of @surface. - * If a new surface is created, it should have the same channels and depth - * as @surface so that copying to and from it is exact. - * @image_rect: location to store area of the original surface occupied - * by the surface stored in @image. - * @image_extra: location to store image specific backend data - * - * Retrieves a local image for a surface for implementing a fallback drawing - * operation. After calling this function, the implementation of the fallback - * drawing operation draws the primitive to the surface stored in @image_out - * then calls _cairo_surface_release_dest_image(), - * which, if a temporary surface was created, copies the bits back to the - * main surface and frees the temporary surface. - * - * Return value: %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY. - * %CAIRO_INT_STATUS_UNSUPPORTED can be returned but this will mean that - * the backend can't draw with fallbacks. It's possible for the routine - * to store %NULL in @local_out and return %CAIRO_STATUS_SUCCESS; - * that indicates that no part of @interest_rect is visible, so no drawing - * is necessary. _cairo_surface_release_dest_image() should not be called in that - * case. - **/ -cairo_status_t -_cairo_surface_acquire_dest_image (cairo_surface_t *surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t **image_out, - cairo_rectangle_int_t *image_rect, - void **image_extra) -{ - cairo_status_t status; - - if (surface->status) - return surface->status; - - assert (_cairo_surface_is_writable (surface)); - - if (surface->backend->acquire_dest_image == NULL) - return CAIRO_INT_STATUS_UNSUPPORTED; - - status = surface->backend->acquire_dest_image (surface, - interest_rect, - image_out, - image_rect, - image_extra); - if (unlikely (status)) - return _cairo_surface_set_error (surface, status); - - _cairo_debug_check_image_surface_is_defined (&(*image_out)->base); - - return CAIRO_STATUS_SUCCESS; -} - -/** - * _cairo_surface_release_dest_image: - * @surface: a #cairo_surface_t - * @interest_rect: same as passed to the matching _cairo_surface_acquire_dest_image() - * @image: same as returned from the matching _cairo_surface_acquire_dest_image() - * @image_rect: same as returned from the matching _cairo_surface_acquire_dest_image() - * @image_extra: same as return from the matching _cairo_surface_acquire_dest_image() - * - * Finishes the operation started with _cairo_surface_acquire_dest_image(), by, if - * necessary, copying the image from @image back to @surface and freeing any - * resources that were allocated. - **/ -void -_cairo_surface_release_dest_image (cairo_surface_t *surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t *image, - cairo_rectangle_int_t *image_rect, - void *image_extra) -{ - assert (_cairo_surface_is_writable (surface)); - - if (surface->backend->release_dest_image) - surface->backend->release_dest_image (surface, interest_rect, - image, image_rect, image_extra); -} - -static cairo_status_t -_cairo_recording_surface_clone_similar (cairo_surface_t *surface, - cairo_surface_t *src, - int src_x, - int src_y, - int width, - int height, - int *clone_offset_x, - int *clone_offset_y, - cairo_surface_t **clone_out) -{ - cairo_recording_surface_t *recorder = (cairo_recording_surface_t *) src; - cairo_surface_t *similar; - cairo_status_t status; - - similar = _cairo_surface_has_snapshot (src, surface->backend); - if (similar != NULL) { - *clone_out = cairo_surface_reference (similar); - *clone_offset_x = 0; - *clone_offset_y = 0; - return CAIRO_STATUS_SUCCESS; - } - - if (recorder->unbounded || - width*height*8 < recorder->extents.width*recorder->extents.height) - { - similar = _cairo_surface_create_similar_solid (surface, - src->content, - width, height, - CAIRO_COLOR_TRANSPARENT, - FALSE); - if (similar == NULL) - return CAIRO_INT_STATUS_UNSUPPORTED; - if (unlikely (similar->status)) - return similar->status; - - cairo_surface_set_device_offset (similar, -src_x, -src_y); - - status = _cairo_recording_surface_replay (src, similar); - if (unlikely (status)) { - cairo_surface_destroy (similar); - return status; - } - } else { - similar = _cairo_surface_create_similar_scratch (surface, - src->content, - recorder->extents.width, - recorder->extents.height); - if (similar == NULL) - return CAIRO_INT_STATUS_UNSUPPORTED; - if (unlikely (similar->status)) - return similar->status; - - status = _cairo_recording_surface_replay (src, similar); - if (unlikely (status)) { - cairo_surface_destroy (similar); - return status; - } - - _cairo_surface_attach_snapshot (src, similar, NULL); - - src_x = src_y = 0; - } - - *clone_out = similar; - *clone_offset_x = src_x; - *clone_offset_y = src_y; - return CAIRO_STATUS_SUCCESS; -} - -/** - * _cairo_surface_clone_similar: - * @surface: a #cairo_surface_t - * @src: the source image - * @content: target content mask - * @src_x: extent for the rectangle in src we actually care about - * @src_y: extent for the rectangle in src we actually care about - * @width: extent for the rectangle in src we actually care about - * @height: extent for the rectangle in src we actually care about - * @clone_out: location to store a surface compatible with @surface - * and with contents identical to @src. The caller must call - * cairo_surface_destroy() on the result. - * - * Creates a surface with contents identical to @src but that - * can be used efficiently with @surface. If @surface and @src are - * already compatible then it may return a new reference to @src. - * - * Return value: %CAIRO_STATUS_SUCCESS if a surface was created and stored - * in @clone_out. Otherwise %CAIRO_INT_STATUS_UNSUPPORTED or another - * error like %CAIRO_STATUS_NO_MEMORY. - **/ -cairo_status_t -_cairo_surface_clone_similar (cairo_surface_t *surface, - cairo_surface_t *src, - int src_x, - int src_y, - int width, - int height, - int *clone_offset_x, - int *clone_offset_y, - cairo_surface_t **clone_out) -{ - cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED; - cairo_image_surface_t *image; - void *image_extra; - - if (unlikely (surface->status)) - return surface->status; - - if (unlikely (surface->finished)) - return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED); - -#if CAIRO_HAS_TEE_SURFACE - - if (src->type == CAIRO_SURFACE_TYPE_TEE) { - cairo_surface_t *match; - - match = _cairo_tee_surface_find_match (src, - surface->backend, - src->content); - if (match != NULL) - src = match; - } - -#endif - - if (surface->backend->clone_similar != NULL) { - status = surface->backend->clone_similar (surface, src, - src_x, src_y, - width, height, - clone_offset_x, - clone_offset_y, - clone_out); - if (status == CAIRO_INT_STATUS_UNSUPPORTED) { - if (_cairo_surface_is_image (src)) - return CAIRO_INT_STATUS_UNSUPPORTED; - - /* First check to see if we can replay to a similar surface */ - if (_cairo_surface_is_recording (src)) { - return _cairo_recording_surface_clone_similar (surface, src, - src_x, src_y, - width, height, - clone_offset_x, - clone_offset_y, - clone_out); - } - - /* If we failed, try again with an image surface */ - status = _cairo_surface_acquire_source_image (src, &image, &image_extra); - if (status == CAIRO_INT_STATUS_SUCCESS) { - status = - surface->backend->clone_similar (surface, &image->base, - src_x, src_y, - width, height, - clone_offset_x, - clone_offset_y, - clone_out); - - _cairo_surface_release_source_image (src, image, image_extra); - } - } - } - - /* If we're still unsupported, hit our fallback path to get a clone */ - if (status == CAIRO_INT_STATUS_UNSUPPORTED) { - status = - _cairo_surface_fallback_clone_similar (surface, src, - src_x, src_y, - width, height, - clone_offset_x, - clone_offset_y, - clone_out); - } - - if (unlikely (status)) - return status; - - /* Update the clone's device_transform (which the underlying surface - * backend knows nothing about) */ - if (*clone_out != src) { - (*clone_out)->device_transform = src->device_transform; - (*clone_out)->device_transform_inverse = src->device_transform_inverse; - } - - return CAIRO_STATUS_SUCCESS; -} - -/** - * _cairo_surface_is_similar - * @surface_a: a #cairo_surface_t - * @surface_b: a #cairo_surface_t - * @content: a #cairo_content_t - * - * Find out whether the given surfaces share the same backend, - * and if so, whether they can be considered similar. - * - * The definition of "similar" depends on the backend. In - * general, it means that the surface is equivalent to one - * that would have been generated by a call to cairo_surface_create_similar(). - * - * Return value: %TRUE if the surfaces are similar. - **/ -cairo_bool_t -_cairo_surface_is_similar (cairo_surface_t *surface_a, - cairo_surface_t *surface_b) -{ - if (surface_a->backend != surface_b->backend) - return FALSE; - - if (surface_a->backend->is_similar != NULL) - return surface_a->backend->is_similar (surface_a, surface_b); - - return TRUE; -} - -cairo_status_t -_cairo_surface_composite (cairo_operator_t op, - const cairo_pattern_t *src, - const cairo_pattern_t *mask, - cairo_surface_t *dst, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region) -{ - cairo_int_status_t status; - - if (unlikely (dst->status)) - return dst->status; - - assert (_cairo_surface_is_writable (dst)); - - if (mask) { - /* These operators aren't interpreted the same way by the backends; - * they are implemented in terms of other operators in cairo-gstate.c - */ - assert (op != CAIRO_OPERATOR_SOURCE && op != CAIRO_OPERATOR_CLEAR); - } - - if (dst->backend->composite) { - status = dst->backend->composite (op, - src, mask, dst, - src_x, src_y, - mask_x, mask_y, - dst_x, dst_y, - width, height, - clip_region); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return _cairo_surface_set_error (dst, status); - } - - return _cairo_surface_set_error (dst, - _cairo_surface_fallback_composite (op, - src, mask, dst, - src_x, src_y, - mask_x, mask_y, - dst_x, dst_y, - width, height, - clip_region)); -} - -/** - * _cairo_surface_fill_region: - * @surface: a #cairo_surface_t - * @op: the operator to apply to the region - * @color: the source color - * @region: the region to modify, in backend coordinates - * - * Applies an operator to a set of rectangles specified as a - * #cairo_region_t using a solid color as the source. - * See _cairo_surface_fill_rectangles() for full details. - * - * Return value: %CAIRO_STATUS_SUCCESS or the error that occurred - **/ -cairo_status_t -_cairo_surface_fill_region (cairo_surface_t *surface, - cairo_operator_t op, - const cairo_color_t *color, - cairo_region_t *region) -{ - int num_rects; - cairo_rectangle_int_t stack_rects[CAIRO_STACK_ARRAY_LENGTH (cairo_rectangle_int_t)]; - cairo_rectangle_int_t *rects = stack_rects; - cairo_status_t status; - int i; - - if (surface->status) - return surface->status; - - assert (_cairo_surface_is_writable (surface)); - - num_rects = cairo_region_num_rectangles (region); - if (num_rects == 0) - return CAIRO_STATUS_SUCCESS; - - /* catch a common reduction of _cairo_clip_combine_with_surface() */ - if (op == CAIRO_OPERATOR_IN && - surface->content == CAIRO_CONTENT_ALPHA && - CAIRO_COLOR_IS_OPAQUE (color)) - { - return CAIRO_STATUS_SUCCESS; - } - - if (num_rects > ARRAY_LENGTH (stack_rects)) { - rects = _cairo_malloc_ab (num_rects, - sizeof (cairo_rectangle_int_t)); - if (rects == NULL) { - return _cairo_surface_set_error (surface, - _cairo_error (CAIRO_STATUS_NO_MEMORY)); - } - } - - for (i = 0; i < num_rects; i++) - cairo_region_get_rectangle (region, i, &rects[i]); - - status = _cairo_surface_fill_rectangles (surface, - op, color, rects, num_rects); - - if (rects != stack_rects) - free (rects); - - return _cairo_surface_set_error (surface, status); -} - -/** - * _cairo_surface_fill_rectangles: - * @surface: a #cairo_surface_t - * @op: the operator to apply to the region - * @color: the source color - * @rects: the rectangles to modify, in backend coordinates - * @num_rects: the number of rectangles in @rects - * - * Applies an operator to a set of rectangles using a solid color - * as the source. Note that even if the operator is an unbounded operator - * such as %CAIRO_OPERATOR_IN, only the given set of rectangles - * is affected. This differs from _cairo_surface_composite_trapezoids() - * where the entire destination rectangle is cleared. - * - * Return value: %CAIRO_STATUS_SUCCESS or the error that occurred - **/ -cairo_status_t -_cairo_surface_fill_rectangles (cairo_surface_t *surface, - cairo_operator_t op, - const cairo_color_t *color, - cairo_rectangle_int_t *rects, - int num_rects) -{ - cairo_int_status_t status; - - if (surface->status) - return surface->status; - - assert (_cairo_surface_is_writable (surface)); - - if (num_rects == 0) - return CAIRO_STATUS_SUCCESS; - - if (surface->backend->fill_rectangles) { - status = surface->backend->fill_rectangles (surface, - op, color, - rects, num_rects); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return _cairo_surface_set_error (surface, status); - } - - return _cairo_surface_set_error (surface, - _cairo_surface_fallback_fill_rectangles (surface, - op, color, - rects, num_rects)); -} - static cairo_status_t _pattern_has_error (const cairo_pattern_t *pattern) { @@ -2248,6 +1709,9 @@ nothing_to_do (cairo_surface_t *surface, if (op == CAIRO_OPERATOR_CLEAR && surface->is_clear) return TRUE; + if (op == CAIRO_OPERATOR_ATOP && (surface->content & CAIRO_CONTENT_COLOR) ==0) + return TRUE; + return FALSE; } @@ -2265,26 +1729,20 @@ _cairo_surface_paint (cairo_surface_t *surface, if (_cairo_clip_is_all_clipped (clip)) return CAIRO_STATUS_SUCCESS; - if (nothing_to_do (surface, op, source)) - return CAIRO_STATUS_SUCCESS; - status = _pattern_has_error (source); if (unlikely (status)) return status; - _cairo_surface_begin_modification (surface); - - if (surface->backend->paint != NULL) { - status = surface->backend->paint (surface, op, source, clip); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - goto FINISH; - } + if (nothing_to_do (surface, op, source)) + return CAIRO_STATUS_SUCCESS; - status = _cairo_surface_fallback_paint (surface, op, source, clip); + _cairo_surface_begin_modification (surface); - FINISH: - if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) + status = surface->backend->paint (surface, op, source, clip); + if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) { surface->is_clear = op == CAIRO_OPERATOR_CLEAR && clip == NULL; + surface->serial++; + } return _cairo_surface_set_error (surface, status); } @@ -2304,9 +1762,6 @@ _cairo_surface_mask (cairo_surface_t *surface, if (_cairo_clip_is_all_clipped (clip)) return CAIRO_STATUS_SUCCESS; - if (nothing_to_do (surface, op, source)) - return CAIRO_STATUS_SUCCESS; - /* If the mask is blank, this is just an expensive no-op */ if (_cairo_pattern_is_clear (mask) && _cairo_operator_bounded_by_mask (op)) @@ -2322,19 +1777,16 @@ _cairo_surface_mask (cairo_surface_t *surface, if (unlikely (status)) return status; - _cairo_surface_begin_modification (surface); - - if (surface->backend->mask != NULL) { - status = surface->backend->mask (surface, op, source, mask, clip); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - goto FINISH; - } + if (nothing_to_do (surface, op, source)) + return CAIRO_STATUS_SUCCESS; - status = _cairo_surface_fallback_mask (surface, op, source, mask, clip); + _cairo_surface_begin_modification (surface); - FINISH: - if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) + status = surface->backend->mask (surface, op, source, mask, clip); + if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) { surface->is_clear = FALSE; + surface->serial++; + } return _cairo_surface_set_error (surface, status); } @@ -2413,23 +1865,25 @@ _cairo_surface_fill_stroke (cairo_surface_t *surface, goto FINISH; FINISH: - if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) + if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) { surface->is_clear = FALSE; + surface->serial++; + } return _cairo_surface_set_error (surface, status); } cairo_status_t -_cairo_surface_stroke (cairo_surface_t *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_path_fixed_t *path, +_cairo_surface_stroke (cairo_surface_t *surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_path_fixed_t *path, const cairo_stroke_style_t *stroke_style, const cairo_matrix_t *ctm, const cairo_matrix_t *ctm_inverse, - double tolerance, - cairo_antialias_t antialias, - const cairo_clip_t *clip) + double tolerance, + cairo_antialias_t antialias, + const cairo_clip_t *clip) { cairo_int_status_t status; @@ -2439,48 +1893,37 @@ _cairo_surface_stroke (cairo_surface_t *surface, if (_cairo_clip_is_all_clipped (clip)) return CAIRO_STATUS_SUCCESS; - if (nothing_to_do (surface, op, source)) - return CAIRO_STATUS_SUCCESS; - status = _pattern_has_error (source); if (unlikely (status)) return status; - _cairo_surface_begin_modification (surface); - - if (surface->backend->stroke != NULL) { - status = surface->backend->stroke (surface, op, source, - path, stroke_style, - ctm, ctm_inverse, - tolerance, antialias, - clip); - - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - goto FINISH; - } + if (nothing_to_do (surface, op, source)) + return CAIRO_STATUS_SUCCESS; - status = _cairo_surface_fallback_stroke (surface, op, source, - path, stroke_style, - ctm, ctm_inverse, - tolerance, antialias, - clip); + _cairo_surface_begin_modification (surface); - FINISH: - if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) + status = surface->backend->stroke (surface, op, source, + path, stroke_style, + ctm, ctm_inverse, + tolerance, antialias, + clip); + if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) { surface->is_clear = FALSE; + surface->serial++; + } return _cairo_surface_set_error (surface, status); } cairo_status_t -_cairo_surface_fill (cairo_surface_t *surface, - cairo_operator_t op, - const cairo_pattern_t *source, +_cairo_surface_fill (cairo_surface_t *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_fill_rule_t fill_rule, + double tolerance, + cairo_antialias_t antialias, + const cairo_clip_t *clip) { cairo_int_status_t status; @@ -2490,129 +1933,25 @@ _cairo_surface_fill (cairo_surface_t *surface, if (_cairo_clip_is_all_clipped (clip)) return CAIRO_STATUS_SUCCESS; - if (nothing_to_do (surface, op, source)) - return CAIRO_STATUS_SUCCESS; - status = _pattern_has_error (source); if (unlikely (status)) return status; - _cairo_surface_begin_modification (surface); - - if (surface->backend->fill != NULL) { - status = surface->backend->fill (surface, op, source, - path, fill_rule, - tolerance, antialias, - clip); - - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - goto FINISH; - } + if (nothing_to_do (surface, op, source)) + return CAIRO_STATUS_SUCCESS; - status = _cairo_surface_fallback_fill (surface, op, source, - path, fill_rule, - tolerance, antialias, - clip); + _cairo_surface_begin_modification (surface); - FINISH: - if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) + status = surface->backend->fill (surface, op, source, + path, fill_rule, + tolerance, antialias, + clip); + if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) { surface->is_clear = FALSE; - - return _cairo_surface_set_error (surface, status); -} - -cairo_status_t -_cairo_surface_composite_trapezoids (cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_surface_t *dst, - cairo_antialias_t antialias, - int src_x, - int src_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_trapezoid_t *traps, - int num_traps, - cairo_region_t *clip_region) -{ - cairo_int_status_t status; - - if (dst->status) - return dst->status; - - assert (_cairo_surface_is_writable (dst)); - - /* These operators aren't interpreted the same way by the backends; - * they are implemented in terms of other operators in cairo-gstate.c - */ - assert (op != CAIRO_OPERATOR_SOURCE && op != CAIRO_OPERATOR_CLEAR); - - if (dst->backend->composite_trapezoids) { - status = dst->backend->composite_trapezoids (op, - pattern, dst, - antialias, - src_x, src_y, - dst_x, dst_y, - width, height, - traps, num_traps, - clip_region); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return _cairo_surface_set_error (dst, status); - } - - return _cairo_surface_set_error (dst, - _cairo_surface_fallback_composite_trapezoids (op, pattern, dst, - antialias, - src_x, src_y, - dst_x, dst_y, - width, height, - traps, num_traps, - clip_region)); -} - -cairo_span_renderer_t * -_cairo_surface_create_span_renderer (cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_surface_t *dst, - cairo_antialias_t antialias, - const cairo_composite_rectangles_t *rects, - cairo_region_t *clip_region) -{ - assert (dst->snapshot_of == NULL); - - if (unlikely (dst->status)) - return _cairo_span_renderer_create_in_error (dst->status); - - if (unlikely (dst->finished)) - return _cairo_span_renderer_create_in_error (CAIRO_STATUS_SURFACE_FINISHED); - - if (dst->backend->create_span_renderer) { - return dst->backend->create_span_renderer (op, pattern, dst, antialias, - rects, clip_region); + surface->serial++; } - ASSERT_NOT_REACHED; - return _cairo_span_renderer_create_in_error (CAIRO_INT_STATUS_UNSUPPORTED); -} -cairo_bool_t -_cairo_surface_check_span_renderer (cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_surface_t *dst, - cairo_antialias_t antialias) -{ - assert (dst->snapshot_of == NULL); - assert (dst->status == CAIRO_STATUS_SUCCESS); - assert (! dst->finished); - - /* XXX: Currently we have no mono span renderer */ - if (antialias == CAIRO_ANTIALIAS_NONE) - return FALSE; - - if (dst->backend->check_span_renderer != NULL) - return dst->backend->check_span_renderer (op, pattern, dst, antialias); - - return FALSE; + return _cairo_surface_set_error (surface, status); } /** @@ -2632,16 +1971,13 @@ _cairo_surface_check_span_renderer (cairo_operator_t op, void cairo_surface_copy_page (cairo_surface_t *surface) { - cairo_status_t status_ignored; - - if (surface->status) + if (unlikely (surface->status)) return; assert (surface->snapshot_of == NULL); - if (surface->finished) { - status_ignored = _cairo_surface_set_error (surface, - CAIRO_STATUS_SURFACE_FINISHED); + if (unlikely (surface->finished)) { + _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED); return; } @@ -2649,8 +1985,7 @@ cairo_surface_copy_page (cairo_surface_t *surface) if (surface->backend->copy_page == NULL) return; - status_ignored = _cairo_surface_set_error (surface, - surface->backend->copy_page (surface)); + _cairo_surface_set_error (surface, surface->backend->copy_page (surface)); } slim_hidden_def (cairo_surface_copy_page); @@ -2669,14 +2004,11 @@ slim_hidden_def (cairo_surface_copy_page); void cairo_surface_show_page (cairo_surface_t *surface) { - cairo_status_t status_ignored; - - if (surface->status) + if (unlikely (surface->status)) return; - if (surface->finished) { - status_ignored = _cairo_surface_set_error (surface, - CAIRO_STATUS_SURFACE_FINISHED); + if (unlikely (surface->finished)) { + _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED); return; } @@ -2686,8 +2018,7 @@ cairo_surface_show_page (cairo_surface_t *surface) if (surface->backend->show_page == NULL) return; - status_ignored = _cairo_surface_set_error (surface, - surface->backend->show_page (surface)); + _cairo_surface_set_error (surface, surface->backend->show_page (surface)); } slim_hidden_def (cairo_surface_show_page); @@ -2755,14 +2086,11 @@ _cairo_surface_get_extents (cairo_surface_t *surface, cairo_bool_t cairo_surface_has_show_text_glyphs (cairo_surface_t *surface) { - cairo_status_t status_ignored; - - if (surface->status) + if (unlikely (surface->status)) return FALSE; - if (surface->finished) { - status_ignored = _cairo_surface_set_error (surface, - CAIRO_STATUS_SURFACE_FINISHED); + if (unlikely (surface->finished)) { + _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED); return FALSE; } @@ -2814,13 +2142,13 @@ _cairo_surface_show_text_glyphs (cairo_surface_t *surface, if (_cairo_clip_is_all_clipped (clip)) return CAIRO_STATUS_SUCCESS; - if (op == CAIRO_OPERATOR_CLEAR && surface->is_clear) - return CAIRO_STATUS_SUCCESS; - status = _pattern_has_error (source); if (unlikely (status)) return status; + if (nothing_to_do (surface, op, source)) + return CAIRO_STATUS_SUCCESS; + _cairo_surface_begin_modification (surface); if (_cairo_surface_has_device_transform (surface) && @@ -2861,32 +2189,20 @@ _cairo_surface_show_text_glyphs (cairo_surface_t *surface, if (status == CAIRO_INT_STATUS_UNSUPPORTED && surface->backend->show_glyphs) { - int remaining_glyphs = num_glyphs; status = surface->backend->show_glyphs (surface, op, source, glyphs, num_glyphs, dev_scaled_font, - clip, - &remaining_glyphs); - glyphs += num_glyphs - remaining_glyphs; - num_glyphs = remaining_glyphs; - if (status == CAIRO_INT_STATUS_UNSUPPORTED && remaining_glyphs == 0) - status = CAIRO_INT_STATUS_SUCCESS; + clip); } } else { /* A mere show_glyphs call. Try show_glyphs backend method first */ if (surface->backend->show_glyphs != NULL) { - int remaining_glyphs = num_glyphs; status = surface->backend->show_glyphs (surface, op, source, glyphs, num_glyphs, dev_scaled_font, - clip, - &remaining_glyphs); - glyphs += num_glyphs - remaining_glyphs; - num_glyphs = remaining_glyphs; - if (status == CAIRO_INT_STATUS_UNSUPPORTED && remaining_glyphs == 0) - status = CAIRO_STATUS_SUCCESS; + clip); } else if (surface->backend->show_text_glyphs != NULL) { /* Intentionally only try show_text_glyphs method for show_glyphs * calls if backend does not have show_glyphs. If backend has @@ -2906,269 +2222,15 @@ _cairo_surface_show_text_glyphs (cairo_surface_t *surface, } } - if (status == CAIRO_INT_STATUS_UNSUPPORTED) { - status = _cairo_surface_fallback_show_glyphs (surface, op, - source, - glyphs, num_glyphs, - dev_scaled_font, - clip); - } - if (dev_scaled_font != scaled_font) cairo_scaled_font_destroy (dev_scaled_font); - if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) + if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) { surface->is_clear = FALSE; - - return _cairo_surface_set_error (surface, status); -} - -/* XXX: Previously, we had a function named _cairo_surface_show_glyphs - * with not-so-useful semantics. We've now got a - * _cairo_surface_show_text_glyphs with the proper semantics, and its - * fallback still uses this old function (which still needs to be - * cleaned up in terms of both semantics and naming). */ -cairo_status_t -_cairo_surface_old_show_glyphs (cairo_scaled_font_t *scaled_font, - cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_surface_t *dst, - int source_x, - int source_y, - int dest_x, - int dest_y, - unsigned int width, - unsigned int height, - cairo_glyph_t *glyphs, - int num_glyphs, - cairo_region_t *clip_region) -{ - if (unlikely (dst->status)) - return dst->status; - - assert (_cairo_surface_is_writable (dst)); - - if (dst->backend->old_show_glyphs == NULL) - return CAIRO_INT_STATUS_UNSUPPORTED; - - return _cairo_surface_set_error - (dst, dst->backend->old_show_glyphs (scaled_font, - op, pattern, dst, - source_x, source_y, - dest_x, dest_y, - width, height, - glyphs, num_glyphs, - clip_region)); -} - -static cairo_status_t -_cairo_surface_composite_fixup_unbounded_internal (cairo_surface_t *dst, - cairo_rectangle_int_t *src_rectangle, - cairo_rectangle_int_t *mask_rectangle, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region) -{ - cairo_rectangle_int_t dst_rectangle; - cairo_region_t clear_region; - cairo_status_t status; - - /* The area that was drawn is the area in the destination rectangle but - * not within the source or the mask. - */ - dst_rectangle.x = dst_x; - dst_rectangle.y = dst_y; - dst_rectangle.width = width; - dst_rectangle.height = height; - - _cairo_region_init_rectangle (&clear_region, &dst_rectangle); - - if (clip_region != NULL) { - status = cairo_region_intersect (&clear_region, clip_region); - if (unlikely (status)) - goto CLEANUP_REGIONS; - } - - if (src_rectangle != NULL) { - if (! _cairo_rectangle_intersect (&dst_rectangle, src_rectangle)) - goto EMPTY; - } - - if (mask_rectangle != NULL) { - if (! _cairo_rectangle_intersect (&dst_rectangle, mask_rectangle)) - goto EMPTY; - } - - /* Now compute the area that is in dst but not drawn */ - status = cairo_region_subtract_rectangle (&clear_region, &dst_rectangle); - if (unlikely (status) || cairo_region_is_empty (&clear_region)) - goto CLEANUP_REGIONS; - - EMPTY: - status = _cairo_surface_fill_region (dst, CAIRO_OPERATOR_CLEAR, - CAIRO_COLOR_TRANSPARENT, - &clear_region); - - CLEANUP_REGIONS: - _cairo_region_fini (&clear_region); - - return _cairo_surface_set_error (dst, status); -} - -/** - * _cairo_surface_composite_fixup_unbounded: - * @dst: the destination surface - * @src_attr: source surface attributes (from _cairo_pattern_acquire_surface()) - * @src_width: width of source surface - * @src_height: height of source surface - * @mask_attr: mask surface attributes or %NULL if no mask - * @mask_width: width of mask surface - * @mask_height: height of mask surface - * @src_x: @src_x from _cairo_surface_composite() - * @src_y: @src_y from _cairo_surface_composite() - * @mask_x: @mask_x from _cairo_surface_composite() - * @mask_y: @mask_y from _cairo_surface_composite() - * @dst_x: @dst_x from _cairo_surface_composite() - * @dst_y: @dst_y from _cairo_surface_composite() - * @width: @width from _cairo_surface_composite() - * @height: @height_x from _cairo_surface_composite() - * - * Eeek! Too many parameters! This is a helper function to take care of fixing - * up for bugs in libpixman and RENDER where, when asked to composite an - * untransformed surface with an unbounded operator (like CLEAR or SOURCE) - * only the region inside both the source and the mask is affected. - * This function clears the region that should have been drawn but was wasn't. - **/ -cairo_status_t -_cairo_surface_composite_fixup_unbounded (cairo_surface_t *dst, - cairo_surface_attributes_t *src_attr, - int src_width, - int src_height, - cairo_surface_attributes_t *mask_attr, - int mask_width, - int mask_height, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region) -{ - cairo_rectangle_int_t src_tmp, mask_tmp; - cairo_rectangle_int_t *src_rectangle = NULL; - cairo_rectangle_int_t *mask_rectangle = NULL; - - if (unlikely (dst->status)) - return dst->status; - - assert (_cairo_surface_is_writable (dst)); - - /* The RENDER/libpixman operators are clipped to the bounds of the untransformed, - * non-repeating sources and masks. Other sources and masks can be ignored. - */ - if (_cairo_matrix_is_integer_translation (&src_attr->matrix, NULL, NULL) && - src_attr->extend == CAIRO_EXTEND_NONE) - { - src_tmp.x = (dst_x - (src_x + src_attr->x_offset)); - src_tmp.y = (dst_y - (src_y + src_attr->y_offset)); - src_tmp.width = src_width; - src_tmp.height = src_height; - - src_rectangle = &src_tmp; - } - - if (mask_attr && - _cairo_matrix_is_integer_translation (&mask_attr->matrix, NULL, NULL) && - mask_attr->extend == CAIRO_EXTEND_NONE) - { - mask_tmp.x = (dst_x - (mask_x + mask_attr->x_offset)); - mask_tmp.y = (dst_y - (mask_y + mask_attr->y_offset)); - mask_tmp.width = mask_width; - mask_tmp.height = mask_height; - - mask_rectangle = &mask_tmp; + surface->serial++; } - return _cairo_surface_composite_fixup_unbounded_internal (dst, src_rectangle, mask_rectangle, - dst_x, dst_y, width, height, - clip_region); -} - -/** - * _cairo_surface_composite_shape_fixup_unbounded: - * @dst: the destination surface - * @src_attr: source surface attributes (from _cairo_pattern_acquire_surface()) - * @src_width: width of source surface - * @src_height: height of source surface - * @mask_width: width of mask surface - * @mask_height: height of mask surface - * @src_x: @src_x from _cairo_surface_composite() - * @src_y: @src_y from _cairo_surface_composite() - * @mask_x: @mask_x from _cairo_surface_composite() - * @mask_y: @mask_y from _cairo_surface_composite() - * @dst_x: @dst_x from _cairo_surface_composite() - * @dst_y: @dst_y from _cairo_surface_composite() - * @width: @width from _cairo_surface_composite() - * @height: @height_x from _cairo_surface_composite() - * - * Like _cairo_surface_composite_fixup_unbounded(), but instead of - * handling the case where we have a source pattern and a mask - * pattern, handle the case where we are compositing a source pattern - * using a mask we create ourselves, as in - * _cairo_surface_composite_glyphs() or _cairo_surface_composite_trapezoids() - **/ -cairo_status_t -_cairo_surface_composite_shape_fixup_unbounded (cairo_surface_t *dst, - cairo_surface_attributes_t *src_attr, - int src_width, - int src_height, - int mask_width, - int mask_height, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region) -{ - cairo_rectangle_int_t src_tmp, *src= NULL; - cairo_rectangle_int_t mask; - - if (dst->status) - return dst->status; - - assert (_cairo_surface_is_writable (dst)); - - /* The RENDER/libpixman operators are clipped to the bounds of the untransformed, - * non-repeating sources and masks. Other sources and masks can be ignored. - */ - if (_cairo_matrix_is_integer_translation (&src_attr->matrix, NULL, NULL) && - src_attr->extend == CAIRO_EXTEND_NONE) - { - src_tmp.x = (dst_x - (src_x + src_attr->x_offset)); - src_tmp.y = (dst_y - (src_y + src_attr->y_offset)); - src_tmp.width = src_width; - src_tmp.height = src_height; - - src = &src_tmp; - } - - mask.x = dst_x - mask_x; - mask.y = dst_y - mask_y; - mask.width = mask_width; - mask.height = mask_height; - - return _cairo_surface_composite_fixup_unbounded_internal (dst, src, &mask, - dst_x, dst_y, width, height, - clip_region); + return _cairo_surface_set_error (surface, status); } /** diff --git a/src/cairo-svg-surface.c b/src/cairo-svg-surface.c index 2cf91eab..6f607d3c 100644 --- a/src/cairo-svg-surface.c +++ b/src/cairo-svg-surface.c @@ -41,7 +41,10 @@ #define _BSD_SOURCE /* for snprintf() */ #include "cairoint.h" + #include "cairo-svg.h" + +#include "cairo-array-private.h" #include "cairo-analysis-surface-private.h" #include "cairo-default-context-private.h" #include "cairo-error-private.h" @@ -2474,8 +2477,7 @@ _cairo_svg_surface_show_glyphs (void *abstract_surface, cairo_glyph_t *glyphs, int num_glyphs, cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip, - int *remaining_glyphs) + const cairo_clip_t *clip) { cairo_svg_surface_t *surface = abstract_surface; cairo_svg_document_t *document = surface->document; @@ -2587,31 +2589,23 @@ static const cairo_surface_backend_t cairo_svg_surface_backend = { NULL, /* acquire_source_image */ NULL, /* release_source_image */ - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* _cairo_svg_surface_composite, */ - NULL, /* _cairo_svg_surface_fill_rectangles, */ - NULL, /* _cairo_svg_surface_composite_trapezoids,*/ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + NULL, /* snapshot */ + _cairo_svg_surface_copy_page, _cairo_svg_surface_show_page, + _cairo_svg_surface_get_extents, - NULL, /* _cairo_svg_surface_old_show_glyphs, */ _cairo_svg_surface_get_font_options, + NULL, /* flush */ NULL, /* mark dirty rectangle */ - NULL, /* scaled font fini */ - NULL, /* scaled glyph fini */ + _cairo_svg_surface_paint, _cairo_svg_surface_mask, _cairo_svg_surface_stroke, _cairo_svg_surface_fill, + _cairo_svg_surface_fill_stroke, _cairo_svg_surface_show_glyphs, - NULL, /* snapshot */ - NULL, /* is_similar */ - _cairo_svg_surface_fill_stroke }; static cairo_status_t diff --git a/src/cairo-time-private.h b/src/cairo-time-private.h index f7c48f38..06dc912b 100644 --- a/src/cairo-time-private.h +++ b/src/cairo-time-private.h @@ -33,15 +33,16 @@ #include "cairo-compiler-private.h" #include "cairo-wideint-private.h" -typedef cairo_uint64_t cairo_time_t; +/* Make the base type signed for easier arithmetic */ +typedef cairo_int64_t cairo_time_t; -#define _cairo_time_add _cairo_uint64_add -#define _cairo_time_sub _cairo_uint64_sub -#define _cairo_time_gt _cairo_uint64_gt -#define _cairo_time_lt _cairo_uint64_lt +#define _cairo_time_add _cairo_int64_add +#define _cairo_time_sub _cairo_int64_sub +#define _cairo_time_gt _cairo_int64_gt +#define _cairo_time_lt _cairo_int64_lt -#define _cairo_time_to_double _cairo_uint64_to_double -#define _cairo_time_from_double _cairo_double_to_uint64 +#define _cairo_time_to_double _cairo_int64_to_double +#define _cairo_time_from_double _cairo_double_to_int64 cairo_private int _cairo_time_cmp (const void *a, @@ -75,7 +76,7 @@ _cairo_time_to_ns (cairo_time_t t) static cairo_always_inline cairo_time_t _cairo_time_max (cairo_time_t a, cairo_time_t b) { - if (_cairo_uint64_gt (a, b)) + if (_cairo_int64_gt (a, b)) return a; else return b; @@ -84,7 +85,7 @@ _cairo_time_max (cairo_time_t a, cairo_time_t b) static cairo_always_inline cairo_time_t _cairo_time_min (cairo_time_t a, cairo_time_t b) { - if (_cairo_uint64_lt (a, b)) + if (_cairo_int64_lt (a, b)) return a; else return b; diff --git a/src/cairo-time.c b/src/cairo-time.c index 32749f5f..9a594e8e 100644 --- a/src/cairo-time.c +++ b/src/cairo-time.c @@ -34,7 +34,7 @@ #include "cairo-time-private.h" -#if HAVE_CLOCKGETTIME +#if HAVE_CLOCK_GETTIME #if defined(CLOCK_MONOTONIC_RAW) #define CAIRO_CLOCK CLOCK_MONOTONIC_RAW #elif defined(CLOCK_MONOTONIC) @@ -79,12 +79,12 @@ cairo_time_t _cairo_time_get (void) { QWORD t; - cairo_uint64_t r; + cairo_int64_t r; DosTmrQueryTime (&t); - r = _cairo_uint64_lsl (_cairo_uint32_to_uint64 (t.ulHi), 32); - r = _cairo_uint64_add (r, _cairo_uint32_to_uint64 (t.ulLo)); + r = _cairo_int64_lsl (_cairo_int32_to_int64 (t.ulHi), 32); + r = _cairo_int64_add (r, _cairo_int32_to_int64 (t.ulLo)); return r; } @@ -130,9 +130,9 @@ _cairo_time_get (void) clock_gettime (CAIRO_CLOCK, &t); - r = _cairo_double_to_uint64 (_cairo_time_1s ()); - r = _cairo_uint64_mul (r, _cairo_uint32_to_uint64 (t.tv_sec)); - r = _cairo_uint64_add (r, _cairo_uint32_to_uint64 (t.tv_nsec)); + r = _cairo_double_to_int64 (_cairo_time_1s ()); + r = _cairo_int64_mul (r, _cairo_int32_to_int64 (t.tv_sec)); + r = _cairo_int64_add (r, _cairo_int32_to_int64 (t.tv_nsec)); return r; } @@ -154,9 +154,9 @@ _cairo_time_get (void) gettimeofday (&t, NULL); - r = _cairo_double_to_uint64 (_cairo_time_1s ()); - r = _cairo_uint64_mul (r, _cairo_uint32_to_uint64 (t.tv_sec)); - r = _cairo_uint64_add (r, _cairo_uint32_to_uint64 (t.tv_usec)); + r = _cairo_double_to_int64 (_cairo_time_1s ()); + r = _cairo_int64_mul (r, _cairo_int32_to_int64 (t.tv_sec)); + r = _cairo_int64_add (r, _cairo_int32_to_int64 (t.tv_usec)); return r; } @@ -167,17 +167,8 @@ int _cairo_time_cmp (const void *a, const void *b) { - const cairo_time_t *ta, *tb; - - ta = a; - tb = b; - - if (_cairo_time_gt (*ta, *tb)) - return 1; - else if (_cairo_time_lt (*ta, *tb)) - return -1; - else - return 0; + const cairo_time_t *ta = a, *tb = b; + return _cairo_int64_cmp (*ta, *tb); } static double @@ -205,11 +196,11 @@ _cairo_time_s_per_tick (void) double _cairo_time_to_s (cairo_time_t t) { - return _cairo_uint64_to_double (t) * _cairo_time_s_per_tick (); + return _cairo_int64_to_double (t) * _cairo_time_s_per_tick (); } cairo_time_t _cairo_time_from_s (double t) { - return _cairo_double_to_uint64 (t * _cairo_time_ticks_per_sec ()); + return _cairo_double_to_int64 (t * _cairo_time_ticks_per_sec ()); } diff --git a/src/cairo-tor-scan-converter.c b/src/cairo-tor-scan-converter.c index d571f6e6..b001bbd6 100644 --- a/src/cairo-tor-scan-converter.c +++ b/src/cairo-tor-scan-converter.c @@ -115,8 +115,10 @@ typedef cairo_status_t glitter_status_t; /* The input coordinate scale and the rasterisation grid scales. */ #define GLITTER_INPUT_BITS CAIRO_FIXED_FRAC_BITS -#define GRID_X_BITS CAIRO_FIXED_FRAC_BITS -#define GRID_Y 15 +//#define GRID_X_BITS CAIRO_FIXED_FRAC_BITS +//#define GRID_Y 15 +#define GRID_X_BITS 2 +#define GRID_Y_BITS 2 /* Set glitter up to use a cairo span renderer to do the coverage * blitting. */ @@ -163,15 +165,6 @@ glitter_scan_converter_reset( int xmin, int ymin, int xmax, int ymax); -/* Add a new polygon edge from pixel (x1,y1) to (x2,y2) to the scan - * converter. The coordinates represent pixel positions scaled by - * 2**GLITTER_PIXEL_BITS. If this function fails then the scan - * converter should be reset or destroyed. Dir must be +1 or -1, - * with the latter reversing the orientation of the edge. */ -I void -glitter_scan_converter_add_edge (glitter_scan_converter_t *converter, - const cairo_edge_t *edge); - /* Render the polygon in the scan converter to the given A8 format * image raster. Only the pixels accessible as pixels[y*stride+x] for * x,y inside the clip box are written to, where xmin <= x < xmax, @@ -348,10 +341,7 @@ struct edge { grid_scaled_y_t dy; }; -/* Number of subsample rows per y-bucket. Must be GRID_Y. */ -#define EDGE_Y_BUCKET_HEIGHT GRID_Y - -#define EDGE_Y_BUCKET_INDEX(y, ymin) (((y) - (ymin))/EDGE_Y_BUCKET_HEIGHT) +#define EDGE_Y_BUCKET_INDEX(y, ymin) (((y) - (ymin))/GRID_Y) /* A collection of sorted and vertically clipped edges of the polygon. * Edges are moved from the polygon to an active list while scan @@ -707,16 +697,14 @@ cell_list_find (struct cell_list *cells, int x) { struct cell *tail = cells->cursor; - assert (x >= tail->x); - if (tail->x == x) return tail; while (1) { UNROLL3({ - if (tail->next->x > x) - break; - tail = tail->next; + if (tail->next->x > x) + break; + tail = tail->next; }); } @@ -738,15 +726,12 @@ cell_list_find_pair(struct cell_list *cells, int x1, int x2) { struct cell_pair pair; - assert (x2 > x1); - assert (x1 >= cells->cursor->x); - pair.cell1 = cells->cursor; while (1) { UNROLL3({ - if (pair.cell1->next->x > x1) - break; - pair.cell1 = pair.cell1->next; + if (pair.cell1->next->x > x1) + break; + pair.cell1 = pair.cell1->next; }); } if (pair.cell1->x != x1) @@ -755,9 +740,9 @@ cell_list_find_pair(struct cell_list *cells, int x1, int x2) pair.cell2 = pair.cell1; while (1) { UNROLL3({ - if (pair.cell2->next->x > x2) - break; - pair.cell2 = pair.cell2->next; + if (pair.cell2->next->x > x2) + break; + pair.cell2 = pair.cell2->next; }); } if (pair.cell2->x != x2) @@ -954,12 +939,11 @@ polygon_reset (struct polygon *polygon, grid_scaled_y_t ymax) { unsigned h = ymax - ymin; - unsigned num_buckets = EDGE_Y_BUCKET_INDEX(ymax + EDGE_Y_BUCKET_HEIGHT-1, - ymin); + unsigned num_buckets = EDGE_Y_BUCKET_INDEX(ymax + GRID_Y-1, ymin); pool_reset(polygon->edge_pool.base); - if (unlikely (h > 0x7FFFFFFFU - EDGE_Y_BUCKET_HEIGHT)) + if (unlikely (h > 0x7FFFFFFFU - GRID_Y)) goto bail_no_mem; /* even if you could, you wouldn't want to. */ if (polygon->y_buckets != polygon->y_buckets_embedded) @@ -978,16 +962,15 @@ polygon_reset (struct polygon *polygon, polygon->ymax = ymax; return GLITTER_STATUS_SUCCESS; - bail_no_mem: +bail_no_mem: polygon->ymin = 0; polygon->ymax = 0; return GLITTER_STATUS_NO_MEMORY; } static void -_polygon_insert_edge_into_its_y_bucket( - struct polygon *polygon, - struct edge *e) +_polygon_insert_edge_into_its_y_bucket(struct polygon *polygon, + struct edge *e) { unsigned ix = EDGE_Y_BUCKET_INDEX(e->ytop, polygon->ymin); struct edge **ptail = &polygon->y_buckets[ix]; @@ -1191,7 +1174,7 @@ sort_edges (struct edge *list, return remaining; } -static struct edge * + static struct edge * merge_unsorted_edges (struct edge *head, struct edge *unsorted) { sort_edges (unsorted, UINT_MAX, &unsorted); @@ -1283,47 +1266,6 @@ polygon_fill_buckets (struct active_list *active, active->min_height = min_height; } -/* Advance the edges on the active list by one subsample row by - * updating their x positions. Drop edges from the list that end. */ -inline static void -active_list_substep_edges(struct active_list *active) -{ - grid_scaled_x_t prev_x = INT_MIN; - struct edge *edge = active->head.next; - - while (edge != &active->tail) { - struct edge *next = edge->next; - - if (--edge->height_left) { - edge->x.quo += edge->dxdy.quo; - edge->x.rem += edge->dxdy.rem; - if (edge->x.rem >= 0) { - ++edge->x.quo; - edge->x.rem -= edge->dy; - } - - if (edge->x.quo < prev_x) { - struct edge *pos = edge->prev; - pos->next = next; - next->prev = pos; - do { - pos = pos->prev; - } while (edge->x.quo < pos->x.quo); - pos->next->prev = edge; - edge->next = pos->next; - edge->prev = pos; - pos->next = edge; - } else - prev_x = edge->x.quo; - } else { - edge->prev->next = next; - next->prev = edge->prev; - } - - edge = next; - } -} - inline static void sub_row (struct active_list *active, struct cell_list *coverages, @@ -1481,9 +1423,9 @@ int_to_grid_scaled(int i, int scale) I glitter_status_t glitter_scan_converter_reset( - glitter_scan_converter_t *converter, - int xmin, int ymin, - int xmax, int ymax) + glitter_scan_converter_t *converter, + int xmin, int ymin, + int xmax, int ymax) { glitter_status_t status; @@ -1536,11 +1478,16 @@ glitter_scan_converter_reset( #endif #define INPUT_TO_GRID_general(in, out, grid_scale) do { \ - long long tmp__ = (long long)(grid_scale) * (in); \ - tmp__ >>= GLITTER_INPUT_BITS; \ - (out) = tmp__; \ + long long tmp__ = (long long)(grid_scale) * (in); \ + tmp__ >>= GLITTER_INPUT_BITS; \ + (out) = tmp__; \ } while (0) +/* Add a new polygon edge from pixel (x1,y1) to (x2,y2) to the scan + * converter. The coordinates represent pixel positions scaled by + * 2**GLITTER_PIXEL_BITS. If this function fails then the scan + * converter should be reset or destroyed. Dir must be +1 or -1, + * with the latter reversing the orientation of the edge. */ I void glitter_scan_converter_add_edge (glitter_scan_converter_t *converter, const cairo_edge_t *edge) @@ -1566,18 +1513,6 @@ glitter_scan_converter_add_edge (glitter_scan_converter_t *converter, polygon_add_edge (converter->polygon, &e); } -#ifndef GLITTER_BLIT_COVERAGES_BEGIN -# define GLITTER_BLIT_COVERAGES_BEGIN -#endif - -#ifndef GLITTER_BLIT_COVERAGES_END -# define GLITTER_BLIT_COVERAGES_END -#endif - -#ifndef GLITTER_BLIT_COVERAGES_EMPTY -# define GLITTER_BLIT_COVERAGES_EMPTY(y0, y1, xmin, xmax) -#endif - static void step_edges (struct active_list *active, int count) { @@ -1594,11 +1529,11 @@ step_edges (struct active_list *active, int count) } static glitter_status_t -blit (struct cell_list *cells, - cairo_span_renderer_t *renderer, - cairo_half_open_span_t *spans, - int y, int height, - int xmin, int xmax) +blit_a8 (struct cell_list *cells, + cairo_span_renderer_t *renderer, + cairo_half_open_span_t *spans, + int y, int height, + int xmin, int xmax) { struct cell *cell = cells->head.next; int prev_x = xmin, last_x = -1; @@ -1661,10 +1596,80 @@ blit (struct cell_list *cells, return renderer->render_rows (renderer, y, height, spans, num_spans); } +#define GRID_AREA_TO_A1(A) ((GRID_AREA_TO_ALPHA (A) > 127) ? 255 : 0) +static glitter_status_t +blit_a1 (struct cell_list *cells, + cairo_span_renderer_t *renderer, + cairo_half_open_span_t *spans, + int y, int height, + int xmin, int xmax) +{ + struct cell *cell = cells->head.next; + int prev_x = xmin, last_x = -1; + int16_t cover = 0; + uint8_t coverage, last_cover = 0; + unsigned num_spans; + + if (cell == &cells->tail) + return CAIRO_STATUS_SUCCESS; + + /* Skip cells to the left of the clip region. */ + while (cell->x < xmin) { + cover += cell->covered_height; + cell = cell->next; + } + cover *= GRID_X*2; + + /* Form the spans from the coverages and areas. */ + num_spans = 0; + for (; cell->x < xmax; cell = cell->next) { + int x = cell->x; + int16_t area; + + coverage = GRID_AREA_TO_A1 (cover); + if (x > prev_x && coverage != last_cover) { + last_x = spans[num_spans].x = prev_x; + last_cover = spans[num_spans].coverage = coverage; + ++num_spans; + } + + cover += cell->covered_height*GRID_X*2; + area = cover - cell->uncovered_area; + + coverage = GRID_AREA_TO_A1 (area); + if (coverage != last_cover) { + last_x = spans[num_spans].x = x; + last_cover = spans[num_spans].coverage = coverage; + ++num_spans; + } + + prev_x = x+1; + } + + coverage = GRID_AREA_TO_A1 (cover); + if (prev_x <= xmax && coverage != last_cover) { + last_x = spans[num_spans].x = prev_x; + last_cover = spans[num_spans].coverage = coverage; + ++num_spans; + } + + if (last_x < xmax && last_cover) { + spans[num_spans].x = xmax; + spans[num_spans].coverage = 0; + ++num_spans; + } + if (num_spans == 1) + return CAIRO_STATUS_SUCCESS; + + /* Dump them into the renderer. */ + return renderer->render_rows (renderer, y, height, spans, num_spans); +} + I void glitter_scan_converter_render(glitter_scan_converter_t *converter, unsigned int winding_mask, + int antialias, cairo_span_renderer_t *renderer) { int i, j; @@ -1682,9 +1687,6 @@ glitter_scan_converter_render(glitter_scan_converter_t *converter, if (xmin_i >= xmax_i) return; - /* Let the coverage blitter initialise itself. */ - GLITTER_BLIT_COVERAGES_BEGIN; - /* Render each pixel row. */ for (i = 0; i < h; i = j) { int do_full_row = 0; @@ -1693,13 +1695,12 @@ glitter_scan_converter_render(glitter_scan_converter_t *converter, /* Determine if we can ignore this row or use the full pixel * stepper. */ - if (GRID_Y == EDGE_Y_BUCKET_HEIGHT && ! polygon->y_buckets[i]) { + if (! polygon->y_buckets[i]) { if (active->head.next == &active->tail) { active->min_height = INT_MAX; active->is_vertical = 1; for (; j < h && ! polygon->y_buckets[j]; j++) ; - GLITTER_BLIT_COVERAGES_EMPTY (i+ymin_i, j-i, xmin_i, xmax_i); continue; } @@ -1740,15 +1741,16 @@ glitter_scan_converter_render(glitter_scan_converter_t *converter, } } - blit (coverages, renderer, converter->spans, - i+ymin_i, j-i, xmin_i, xmax_i); + if (antialias) + blit_a8 (coverages, renderer, converter->spans, + i+ymin_i, j-i, xmin_i, xmax_i); + else + blit_a1 (coverages, renderer, converter->spans, + i+ymin_i, j-i, xmin_i, xmax_i); cell_list_reset (coverages); active->min_height -= GRID_Y; } - - /* Clean up the coverage blitter. */ - GLITTER_BLIT_COVERAGES_END; } struct _cairo_tor_scan_converter { @@ -1756,6 +1758,7 @@ struct _cairo_tor_scan_converter { glitter_scan_converter_t converter[1]; cairo_fill_rule_t fill_rule; + cairo_antialias_t antialias; jmp_buf jmp; }; @@ -1773,36 +1776,21 @@ _cairo_tor_scan_converter_destroy (void *converter) free(self); } -static cairo_status_t -_cairo_tor_scan_converter_add_edge (void *converter, - const cairo_point_t *p1, - const cairo_point_t *p2, - int top, int bottom, - int dir) -{ - cairo_tor_scan_converter_t *self = converter; - cairo_edge_t edge; - - edge.line.p1 = *p1; - edge.line.p2 = *p2; - edge.top = top; - edge.bottom = bottom; - edge.dir = dir; - - glitter_scan_converter_add_edge (self->converter, &edge); - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t +cairo_status_t _cairo_tor_scan_converter_add_polygon (void *converter, const cairo_polygon_t *polygon) { cairo_tor_scan_converter_t *self = converter; int i; +#if 0 + FILE *file = fopen ("polygon.txt", "w"); + _cairo_debug_print_polygon (file, polygon); + fclose (file); +#endif + for (i = 0; i < polygon->num_edges; i++) - glitter_scan_converter_add_edge (self->converter, - &polygon->edges[i]); + glitter_scan_converter_add_edge (self->converter, &polygon->edges[i]); return CAIRO_STATUS_SUCCESS; } @@ -1819,6 +1807,7 @@ _cairo_tor_scan_converter_generate (void *converter, glitter_scan_converter_render (self->converter, self->fill_rule == CAIRO_FILL_RULE_WINDING ? ~0 : 1, + self->antialias != CAIRO_ANTIALIAS_NONE, renderer); return CAIRO_STATUS_SUCCESS; } @@ -1828,20 +1817,19 @@ _cairo_tor_scan_converter_create (int xmin, int ymin, int xmax, int ymax, - cairo_fill_rule_t fill_rule) + cairo_fill_rule_t fill_rule, + cairo_antialias_t antialias) { cairo_tor_scan_converter_t *self; cairo_status_t status; - self = calloc (1, sizeof(struct _cairo_tor_scan_converter)); + self = malloc (sizeof(struct _cairo_tor_scan_converter)); if (unlikely (self == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto bail_nomem; } self->base.destroy = _cairo_tor_scan_converter_destroy; - self->base.add_edge = _cairo_tor_scan_converter_add_edge; - self->base.add_polygon = _cairo_tor_scan_converter_add_polygon; self->base.generate = _cairo_tor_scan_converter_generate; _glitter_scan_converter_init (self->converter, &self->jmp); @@ -1851,6 +1839,7 @@ _cairo_tor_scan_converter_create (int xmin, goto bail; self->fill_rule = fill_rule; + self->antialias = antialias; return &self->base; diff --git a/src/cairo-tor22-scan-converter.c b/src/cairo-tor22-scan-converter.c new file mode 100644 index 00000000..2f930306 --- /dev/null +++ b/src/cairo-tor22-scan-converter.c @@ -0,0 +1,1707 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* glitter-paths - polygon scan converter + * + * Copyright (c) 2008 M Joonas Pihlaja + * Copyright (c) 2007 David Turner + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + */ +/* This is the Glitter paths scan converter incorporated into cairo. + * The source is from commit 734c53237a867a773640bd5b64816249fa1730f8 + * of + * + * http://gitweb.freedesktop.org/?p=users/joonas/glitter-paths + */ +/* Glitter-paths is a stand alone polygon rasteriser derived from + * David Turner's reimplementation of Tor Anderssons's 15x17 + * supersampling rasteriser from the Apparition graphics library. The + * main new feature here is cheaply choosing per-scan line between + * doing fully analytical coverage computation for an entire row at a + * time vs. using a supersampling approach. + * + * David Turner's code can be found at + * + * http://david.freetype.org/rasterizer-shootout/raster-comparison-20070813.tar.bz2 + * + * In particular this file incorporates large parts of ftgrays_tor10.h + * from raster-comparison-20070813.tar.bz2 + */ +/* Overview + * + * A scan converter's basic purpose to take polygon edges and convert + * them into an RLE compressed A8 mask. This one works in two phases: + * gathering edges and generating spans. + * + * 1) As the user feeds the scan converter edges they are vertically + * clipped and bucketted into a _polygon_ data structure. The edges + * are also snapped from the user's coordinates to the subpixel grid + * coordinates used during scan conversion. + * + * user + * | + * | edges + * V + * polygon buckets + * + * 2) Generating spans works by performing a vertical sweep of pixel + * rows from top to bottom and maintaining an _active_list_ of edges + * that intersect the row. From the active list the fill rule + * determines which edges are the left and right edges of the start of + * each span, and their contribution is then accumulated into a pixel + * coverage list (_cell_list_) as coverage deltas. Once the coverage + * deltas of all edges are known we can form spans of constant pixel + * coverage by summing the deltas during a traversal of the cell list. + * At the end of a pixel row the cell list is sent to a coverage + * blitter for rendering to some target surface. + * + * The pixel coverages are computed by either supersampling the row + * and box filtering a mono rasterisation, or by computing the exact + * coverages of edges in the active list. The supersampling method is + * used whenever some edge starts or stops within the row or there are + * edge intersections in the row. + * + * polygon bucket for \ + * current pixel row | + * | | + * | activate new edges | Repeat GRID_Y times if we + * V \ are supersampling this row, + * active list / or just once if we're computing + * | | analytical coverage. + * | coverage deltas | + * V | + * pixel coverage list / + * | + * V + * coverage blitter + */ +#include "cairoint.h" +#include "cairo-spans-private.h" +#include "cairo-error-private.h" + +#include <stdlib.h> +#include <string.h> +#include <limits.h> +#include <setjmp.h> + +/*------------------------------------------------------------------------- + * cairo specific config + */ +#define I static + +/* Prefer cairo's status type. */ +#define GLITTER_HAVE_STATUS_T 1 +#define GLITTER_STATUS_SUCCESS CAIRO_STATUS_SUCCESS +#define GLITTER_STATUS_NO_MEMORY CAIRO_STATUS_NO_MEMORY +typedef cairo_status_t glitter_status_t; + +/* The input coordinate scale and the rasterisation grid scales. */ +#define GLITTER_INPUT_BITS CAIRO_FIXED_FRAC_BITS +//#define GRID_X_BITS CAIRO_FIXED_FRAC_BITS +//#define GRID_Y 15 +#define GRID_X_BITS 2 +#define GRID_Y_BITS 2 + +/* Set glitter up to use a cairo span renderer to do the coverage + * blitting. */ +struct pool; +struct cell_list; + +/*------------------------------------------------------------------------- + * glitter-paths.h + */ + +/* "Input scaled" numbers are fixed precision reals with multiplier + * 2**GLITTER_INPUT_BITS. Input coordinates are given to glitter as + * pixel scaled numbers. These get converted to the internal grid + * scaled numbers as soon as possible. Internal overflow is possible + * if GRID_X/Y inside glitter-paths.c is larger than + * 1<<GLITTER_INPUT_BITS. */ +#ifndef GLITTER_INPUT_BITS +# define GLITTER_INPUT_BITS 8 +#endif +#define GLITTER_INPUT_SCALE (1<<GLITTER_INPUT_BITS) +typedef int glitter_input_scaled_t; + +#if !GLITTER_HAVE_STATUS_T +typedef enum { + GLITTER_STATUS_SUCCESS = 0, + GLITTER_STATUS_NO_MEMORY +} glitter_status_t; +#endif + +#ifndef I +# define I /*static*/ +#endif + +/* Opaque type for scan converting. */ +typedef struct glitter_scan_converter glitter_scan_converter_t; + +/* Reset a scan converter to accept polygon edges and set the clip box + * in pixels. Allocates O(ymax-ymin) bytes of memory. The clip box + * is set to integer pixel coordinates xmin <= x < xmax, ymin <= y < + * ymax. */ +I glitter_status_t +glitter_scan_converter_reset( + glitter_scan_converter_t *converter, + int xmin, int ymin, + int xmax, int ymax); + +/* Render the polygon in the scan converter to the given A8 format + * image raster. Only the pixels accessible as pixels[y*stride+x] for + * x,y inside the clip box are written to, where xmin <= x < xmax, + * ymin <= y < ymax. The image is assumed to be clear on input. + * + * If nonzero_fill is true then the interior of the polygon is + * computed with the non-zero fill rule. Otherwise the even-odd fill + * rule is used. + * + * The scan converter must be reset or destroyed after this call. */ + +/*------------------------------------------------------------------------- + * glitter-paths.c: Implementation internal types + */ +#include <stdlib.h> +#include <string.h> +#include <limits.h> + +/* All polygon coordinates are snapped onto a subsample grid. "Grid + * scaled" numbers are fixed precision reals with multiplier GRID_X or + * GRID_Y. */ +typedef int grid_scaled_t; +typedef int grid_scaled_x_t; +typedef int grid_scaled_y_t; + +/* Default x/y scale factors. + * You can either define GRID_X/Y_BITS to get a power-of-two scale + * or define GRID_X/Y separately. */ +#if !defined(GRID_X) && !defined(GRID_X_BITS) +# define GRID_X_BITS 8 +#endif +#if !defined(GRID_Y) && !defined(GRID_Y_BITS) +# define GRID_Y 15 +#endif + +/* Use GRID_X/Y_BITS to define GRID_X/Y if they're available. */ +#ifdef GRID_X_BITS +# define GRID_X (1 << GRID_X_BITS) +#endif +#ifdef GRID_Y_BITS +# define GRID_Y (1 << GRID_Y_BITS) +#endif + +/* The GRID_X_TO_INT_FRAC macro splits a grid scaled coordinate into + * integer and fractional parts. The integer part is floored. */ +#if defined(GRID_X_TO_INT_FRAC) + /* do nothing */ +#elif defined(GRID_X_BITS) +# define GRID_X_TO_INT_FRAC(x, i, f) \ + _GRID_TO_INT_FRAC_shift(x, i, f, GRID_X_BITS) +#else +# define GRID_X_TO_INT_FRAC(x, i, f) \ + _GRID_TO_INT_FRAC_general(x, i, f, GRID_X) +#endif + +#define _GRID_TO_INT_FRAC_general(t, i, f, m) do { \ + (i) = (t) / (m); \ + (f) = (t) % (m); \ + if ((f) < 0) { \ + --(i); \ + (f) += (m); \ + } \ +} while (0) + +#define _GRID_TO_INT_FRAC_shift(t, i, f, b) do { \ + (f) = (t) & ((1 << (b)) - 1); \ + (i) = (t) >> (b); \ +} while (0) + +/* A grid area is a real in [0,1] scaled by 2*GRID_X*GRID_Y. We want + * to be able to represent exactly areas of subpixel trapezoids whose + * vertices are given in grid scaled coordinates. The scale factor + * comes from needing to accurately represent the area 0.5*dx*dy of a + * triangle with base dx and height dy in grid scaled numbers. */ +#define GRID_XY (2*GRID_X*GRID_Y) /* Unit area on the grid. */ + +/* GRID_AREA_TO_ALPHA(area): map [0,GRID_XY] to [0,255]. */ +#if GRID_XY == 510 +# define GRID_AREA_TO_ALPHA(c) (((c)+1) >> 1) +#elif GRID_XY == 255 +# define GRID_AREA_TO_ALPHA(c) (c) +#elif GRID_XY == 64 +# define GRID_AREA_TO_ALPHA(c) (((c) << 2) | -(((c) & 0x40) >> 6)) +#elif GRID_XY == 128 +# define GRID_AREA_TO_ALPHA(c) ((((c) << 1) | -((c) >> 7)) & 255) +#elif GRID_XY == 256 +# define GRID_AREA_TO_ALPHA(c) (((c) | -((c) >> 8)) & 255) +#elif GRID_XY == 15 +# define GRID_AREA_TO_ALPHA(c) (((c) << 4) + (c)) +#elif GRID_XY == 2*256*15 +# define GRID_AREA_TO_ALPHA(c) (((c) + ((c)<<4) + 256) >> 9) +#else +# define GRID_AREA_TO_ALPHA(c) (((c)*255 + GRID_XY/2) / GRID_XY) +#endif + +#define UNROLL3(x) x x x + +struct quorem { + int32_t quo; + int32_t rem; +}; + +/* Header for a chunk of memory in a memory pool. */ +struct _pool_chunk { + /* # bytes used in this chunk. */ + size_t size; + + /* # bytes total in this chunk */ + size_t capacity; + + /* Pointer to the previous chunk or %NULL if this is the sentinel + * chunk in the pool header. */ + struct _pool_chunk *prev_chunk; + + /* Actual data starts here. Well aligned for pointers. */ +}; + +/* A memory pool. This is supposed to be embedded on the stack or + * within some other structure. It may optionally be followed by an + * embedded array from which requests are fulfilled until + * malloc needs to be called to allocate a first real chunk. */ +struct pool { + /* Chunk we're allocating from. */ + struct _pool_chunk *current; + + jmp_buf *jmp; + + /* Free list of previously allocated chunks. All have >= default + * capacity. */ + struct _pool_chunk *first_free; + + /* The default capacity of a chunk. */ + size_t default_capacity; + + /* Header for the sentinel chunk. Directly following the pool + * struct should be some space for embedded elements from which + * the sentinel chunk allocates from. */ + struct _pool_chunk sentinel[1]; +}; + +/* A polygon edge. */ +struct edge { + /* Next in y-bucket or active list. */ + struct edge *next, *prev; + + /* Number of subsample rows remaining to scan convert of this + * edge. */ + grid_scaled_y_t height_left; + + /* Original sign of the edge: +1 for downwards, -1 for upwards + * edges. */ + int dir; + int vertical; + + /* Current x coordinate while the edge is on the active + * list. Initialised to the x coordinate of the top of the + * edge. The quotient is in grid_scaled_x_t units and the + * remainder is mod dy in grid_scaled_y_t units.*/ + struct quorem x; + + /* Advance of the current x when moving down a subsample line. */ + struct quorem dxdy; + + /* The clipped y of the top of the edge. */ + grid_scaled_y_t ytop; + + /* y2-y1 after orienting the edge downwards. */ + grid_scaled_y_t dy; +}; + +#define EDGE_Y_BUCKET_INDEX(y, ymin) (((y) - (ymin))/GRID_Y) + +/* A collection of sorted and vertically clipped edges of the polygon. + * Edges are moved from the polygon to an active list while scan + * converting. */ +struct polygon { + /* The vertical clip extents. */ + grid_scaled_y_t ymin, ymax; + + /* Array of edges all starting in the same bucket. An edge is put + * into bucket EDGE_BUCKET_INDEX(edge->ytop, polygon->ymin) when + * it is added to the polygon. */ + struct edge **y_buckets; + struct edge *y_buckets_embedded[64]; + + struct { + struct pool base[1]; + struct edge embedded[32]; + } edge_pool; +}; + +/* A cell records the effect on pixel coverage of polygon edges + * passing through a pixel. It contains two accumulators of pixel + * coverage. + * + * Consider the effects of a polygon edge on the coverage of a pixel + * it intersects and that of the following one. The coverage of the + * following pixel is the height of the edge multiplied by the width + * of the pixel, and the coverage of the pixel itself is the area of + * the trapezoid formed by the edge and the right side of the pixel. + * + * +-----------------------+-----------------------+ + * | | | + * | | | + * |_______________________|_______________________| + * | \...................|.......................|\ + * | \..................|.......................| | + * | \.................|.......................| | + * | \....covered.....|.......................| | + * | \....area.......|.......................| } covered height + * | \..............|.......................| | + * |uncovered\.............|.......................| | + * | area \............|.......................| | + * |___________\...........|.......................|/ + * | | | + * | | | + * | | | + * +-----------------------+-----------------------+ + * + * Since the coverage of the following pixel will always be a multiple + * of the width of the pixel, we can store the height of the covered + * area instead. The coverage of the pixel itself is the total + * coverage minus the area of the uncovered area to the left of the + * edge. As it's faster to compute the uncovered area we only store + * that and subtract it from the total coverage later when forming + * spans to blit. + * + * The heights and areas are signed, with left edges of the polygon + * having positive sign and right edges having negative sign. When + * two edges intersect they swap their left/rightness so their + * contribution above and below the intersection point must be + * computed separately. */ +struct cell { + struct cell *next; + int x; + int16_t uncovered_area; + int16_t covered_height; +}; + +/* A cell list represents the scan line sparsely as cells ordered by + * ascending x. It is geared towards scanning the cells in order + * using an internal cursor. */ +struct cell_list { + /* Sentinel nodes */ + struct cell head, tail; + + /* Cursor state for iterating through the cell list. */ + struct cell *cursor, *rewind; + + /* Cells in the cell list are owned by the cell list and are + * allocated from this pool. */ + struct { + struct pool base[1]; + struct cell embedded[32]; + } cell_pool; +}; + +struct cell_pair { + struct cell *cell1; + struct cell *cell2; +}; + +/* The active list contains edges in the current scan line ordered by + * the x-coordinate of the intercept of the edge and the scan line. */ +struct active_list { + /* Leftmost edge on the current scan line. */ + struct edge head, tail; + + /* A lower bound on the height of the active edges is used to + * estimate how soon some active edge ends. We can't advance the + * scan conversion by a full pixel row if an edge ends somewhere + * within it. */ + grid_scaled_y_t min_height; + int is_vertical; +}; + +struct glitter_scan_converter { + struct polygon polygon[1]; + struct active_list active[1]; + struct cell_list coverages[1]; + + cairo_half_open_span_t *spans; + cairo_half_open_span_t spans_embedded[64]; + + /* Clip box. */ + grid_scaled_x_t xmin, xmax; + grid_scaled_y_t ymin, ymax; +}; + +/* Compute the floored division a/b. Assumes / and % perform symmetric + * division. */ +inline static struct quorem +floored_divrem(int a, int b) +{ + struct quorem qr; + qr.quo = a/b; + qr.rem = a%b; + if ((a^b)<0 && qr.rem) { + qr.quo -= 1; + qr.rem += b; + } + return qr; +} + +/* Compute the floored division (x*a)/b. Assumes / and % perform symmetric + * division. */ +static struct quorem +floored_muldivrem(int x, int a, int b) +{ + struct quorem qr; + long long xa = (long long)x*a; + qr.quo = xa/b; + qr.rem = xa%b; + if ((xa>=0) != (b>=0) && qr.rem) { + qr.quo -= 1; + qr.rem += b; + } + return qr; +} + +static struct _pool_chunk * +_pool_chunk_init( + struct _pool_chunk *p, + struct _pool_chunk *prev_chunk, + size_t capacity) +{ + p->prev_chunk = prev_chunk; + p->size = 0; + p->capacity = capacity; + return p; +} + +static struct _pool_chunk * +_pool_chunk_create(struct pool *pool, size_t size) +{ + struct _pool_chunk *p; + + p = malloc(size + sizeof(struct _pool_chunk)); + if (unlikely (NULL == p)) + longjmp (*pool->jmp, _cairo_error (CAIRO_STATUS_NO_MEMORY)); + + return _pool_chunk_init(p, pool->current, size); +} + +static void +pool_init(struct pool *pool, + jmp_buf *jmp, + size_t default_capacity, + size_t embedded_capacity) +{ + pool->jmp = jmp; + pool->current = pool->sentinel; + pool->first_free = NULL; + pool->default_capacity = default_capacity; + _pool_chunk_init(pool->sentinel, NULL, embedded_capacity); +} + +static void +pool_fini(struct pool *pool) +{ + struct _pool_chunk *p = pool->current; + do { + while (NULL != p) { + struct _pool_chunk *prev = p->prev_chunk; + if (p != pool->sentinel) + free(p); + p = prev; + } + p = pool->first_free; + pool->first_free = NULL; + } while (NULL != p); +} + +/* Satisfy an allocation by first allocating a new large enough chunk + * and adding it to the head of the pool's chunk list. This function + * is called as a fallback if pool_alloc() couldn't do a quick + * allocation from the current chunk in the pool. */ +static void * +_pool_alloc_from_new_chunk( + struct pool *pool, + size_t size) +{ + struct _pool_chunk *chunk; + void *obj; + size_t capacity; + + /* If the allocation is smaller than the default chunk size then + * try getting a chunk off the free list. Force alloc of a new + * chunk for large requests. */ + capacity = size; + chunk = NULL; + if (size < pool->default_capacity) { + capacity = pool->default_capacity; + chunk = pool->first_free; + if (chunk) { + pool->first_free = chunk->prev_chunk; + _pool_chunk_init(chunk, pool->current, chunk->capacity); + } + } + + if (NULL == chunk) + chunk = _pool_chunk_create (pool, capacity); + pool->current = chunk; + + obj = ((unsigned char*)chunk + sizeof(*chunk) + chunk->size); + chunk->size += size; + return obj; +} + +/* Allocate size bytes from the pool. The first allocated address + * returned from a pool is aligned to sizeof(void*). Subsequent + * addresses will maintain alignment as long as multiples of void* are + * allocated. Returns the address of a new memory area or %NULL on + * allocation failures. The pool retains ownership of the returned + * memory. */ +inline static void * +pool_alloc (struct pool *pool, size_t size) +{ + struct _pool_chunk *chunk = pool->current; + + if (size <= chunk->capacity - chunk->size) { + void *obj = ((unsigned char*)chunk + sizeof(*chunk) + chunk->size); + chunk->size += size; + return obj; + } else { + return _pool_alloc_from_new_chunk(pool, size); + } +} + +/* Relinquish all pool_alloced memory back to the pool. */ +static void +pool_reset (struct pool *pool) +{ + /* Transfer all used chunks to the chunk free list. */ + struct _pool_chunk *chunk = pool->current; + if (chunk != pool->sentinel) { + while (chunk->prev_chunk != pool->sentinel) { + chunk = chunk->prev_chunk; + } + chunk->prev_chunk = pool->first_free; + pool->first_free = pool->current; + } + /* Reset the sentinel as the current chunk. */ + pool->current = pool->sentinel; + pool->sentinel->size = 0; +} + +/* Rewinds the cell list's cursor to the beginning. After rewinding + * we're good to cell_list_find() the cell any x coordinate. */ +inline static void +cell_list_rewind (struct cell_list *cells) +{ + cells->cursor = &cells->head; +} + +inline static void +cell_list_maybe_rewind (struct cell_list *cells, int x) +{ + if (x < cells->cursor->x) { + cells->cursor = cells->rewind; + if (x < cells->cursor->x) + cells->cursor = &cells->head; + } +} + +inline static void +cell_list_set_rewind (struct cell_list *cells) +{ + cells->rewind = cells->cursor; +} + +static void +cell_list_init(struct cell_list *cells, jmp_buf *jmp) +{ + pool_init(cells->cell_pool.base, jmp, + 256*sizeof(struct cell), + sizeof(cells->cell_pool.embedded)); + cells->tail.next = NULL; + cells->tail.x = INT_MAX; + cells->head.x = INT_MIN; + cells->head.next = &cells->tail; + cell_list_rewind (cells); +} + +static void +cell_list_fini(struct cell_list *cells) +{ + pool_fini (cells->cell_pool.base); +} + +/* Empty the cell list. This is called at the start of every pixel + * row. */ +inline static void +cell_list_reset (struct cell_list *cells) +{ + cell_list_rewind (cells); + cells->head.next = &cells->tail; + pool_reset (cells->cell_pool.base); +} + +inline static struct cell * +cell_list_alloc (struct cell_list *cells, + struct cell *tail, + int x) +{ + struct cell *cell; + + cell = pool_alloc (cells->cell_pool.base, sizeof (struct cell)); + cell->next = tail->next; + tail->next = cell; + cell->x = x; + *(uint32_t *)&cell->uncovered_area = 0; + + return cell; +} + +/* Find a cell at the given x-coordinate. Returns %NULL if a new cell + * needed to be allocated but couldn't be. Cells must be found with + * non-decreasing x-coordinate until the cell list is rewound using + * cell_list_rewind(). Ownership of the returned cell is retained by + * the cell list. */ +inline static struct cell * +cell_list_find (struct cell_list *cells, int x) +{ + struct cell *tail = cells->cursor; + + if (tail->x == x) + return tail; + + while (1) { + UNROLL3({ + if (tail->next->x > x) + break; + tail = tail->next; + }); + } + + if (tail->x != x) + tail = cell_list_alloc (cells, tail, x); + return cells->cursor = tail; + +} + +/* Find two cells at x1 and x2. This is exactly equivalent + * to + * + * pair.cell1 = cell_list_find(cells, x1); + * pair.cell2 = cell_list_find(cells, x2); + * + * except with less function call overhead. */ +inline static struct cell_pair +cell_list_find_pair(struct cell_list *cells, int x1, int x2) +{ + struct cell_pair pair; + + pair.cell1 = cells->cursor; + while (1) { + UNROLL3({ + if (pair.cell1->next->x > x1) + break; + pair.cell1 = pair.cell1->next; + }); + } + if (pair.cell1->x != x1) + pair.cell1 = cell_list_alloc (cells, pair.cell1, x1); + + pair.cell2 = pair.cell1; + while (1) { + UNROLL3({ + if (pair.cell2->next->x > x2) + break; + pair.cell2 = pair.cell2->next; + }); + } + if (pair.cell2->x != x2) + pair.cell2 = cell_list_alloc (cells, pair.cell2, x2); + + cells->cursor = pair.cell2; + return pair; +} + +/* Add a subpixel span covering [x1, x2) to the coverage cells. */ +inline static void +cell_list_add_subspan(struct cell_list *cells, + grid_scaled_x_t x1, + grid_scaled_x_t x2) +{ + int ix1, fx1; + int ix2, fx2; + + if (x1 == x2) + return; + + GRID_X_TO_INT_FRAC(x1, ix1, fx1); + GRID_X_TO_INT_FRAC(x2, ix2, fx2); + + if (ix1 != ix2) { + struct cell_pair p; + p = cell_list_find_pair(cells, ix1, ix2); + p.cell1->uncovered_area += 2*fx1; + ++p.cell1->covered_height; + p.cell2->uncovered_area -= 2*fx2; + --p.cell2->covered_height; + } else { + struct cell *cell = cell_list_find(cells, ix1); + cell->uncovered_area += 2*(fx1-fx2); + } +} + +/* Adds the analytical coverage of an edge crossing the current pixel + * row to the coverage cells and advances the edge's x position to the + * following row. + * + * This function is only called when we know that during this pixel row: + * + * 1) The relative order of all edges on the active list doesn't + * change. In particular, no edges intersect within this row to pixel + * precision. + * + * 2) No new edges start in this row. + * + * 3) No existing edges end mid-row. + * + * This function depends on being called with all edges from the + * active list in the order they appear on the list (i.e. with + * non-decreasing x-coordinate.) */ +static void +cell_list_render_edge(struct cell_list *cells, + struct edge *edge, + int sign) +{ + grid_scaled_x_t fx; + struct cell *cell; + int ix; + + GRID_X_TO_INT_FRAC(edge->x.quo, ix, fx); + + /* We always know that ix1 is >= the cell list cursor in this + * case due to the no-intersections precondition. */ + cell = cell_list_find(cells, ix); + cell->covered_height += sign*GRID_Y; + cell->uncovered_area += sign*2*fx*GRID_Y; +} + +static void +polygon_init (struct polygon *polygon, jmp_buf *jmp) +{ + polygon->ymin = polygon->ymax = 0; + polygon->y_buckets = polygon->y_buckets_embedded; + pool_init (polygon->edge_pool.base, jmp, + 8192 - sizeof (struct _pool_chunk), + sizeof (polygon->edge_pool.embedded)); +} + +static void +polygon_fini (struct polygon *polygon) +{ + if (polygon->y_buckets != polygon->y_buckets_embedded) + free (polygon->y_buckets); + + pool_fini (polygon->edge_pool.base); +} + +/* Empties the polygon of all edges. The polygon is then prepared to + * receive new edges and clip them to the vertical range + * [ymin,ymax). */ +static glitter_status_t +polygon_reset (struct polygon *polygon, + grid_scaled_y_t ymin, + grid_scaled_y_t ymax) +{ + unsigned h = ymax - ymin; + unsigned num_buckets = EDGE_Y_BUCKET_INDEX(ymax + GRID_Y-1, ymin); + + pool_reset(polygon->edge_pool.base); + + if (unlikely (h > 0x7FFFFFFFU - GRID_Y)) + goto bail_no_mem; /* even if you could, you wouldn't want to. */ + + if (polygon->y_buckets != polygon->y_buckets_embedded) + free (polygon->y_buckets); + + polygon->y_buckets = polygon->y_buckets_embedded; + if (num_buckets > ARRAY_LENGTH (polygon->y_buckets_embedded)) { + polygon->y_buckets = _cairo_malloc_ab (num_buckets, + sizeof (struct edge *)); + if (unlikely (NULL == polygon->y_buckets)) + goto bail_no_mem; + } + memset (polygon->y_buckets, 0, num_buckets * sizeof (struct edge *)); + + polygon->ymin = ymin; + polygon->ymax = ymax; + return GLITTER_STATUS_SUCCESS; + +bail_no_mem: + polygon->ymin = 0; + polygon->ymax = 0; + return GLITTER_STATUS_NO_MEMORY; +} + +static void +_polygon_insert_edge_into_its_y_bucket(struct polygon *polygon, + struct edge *e) +{ + unsigned ix = EDGE_Y_BUCKET_INDEX(e->ytop, polygon->ymin); + struct edge **ptail = &polygon->y_buckets[ix]; + e->next = *ptail; + *ptail = e; +} + +inline static void +polygon_add_edge (struct polygon *polygon, + const cairo_edge_t *edge) +{ + struct edge *e; + grid_scaled_x_t dx; + grid_scaled_y_t dy; + grid_scaled_y_t ytop, ybot; + grid_scaled_y_t ymin = polygon->ymin; + grid_scaled_y_t ymax = polygon->ymax; + + if (unlikely (edge->top >= ymax || edge->bottom <= ymin)) + return; + + e = pool_alloc (polygon->edge_pool.base, sizeof (struct edge)); + + dx = edge->line.p2.x - edge->line.p1.x; + dy = edge->line.p2.y - edge->line.p1.y; + e->dy = dy; + e->dir = edge->dir; + + ytop = edge->top >= ymin ? edge->top : ymin; + ybot = edge->bottom <= ymax ? edge->bottom : ymax; + e->ytop = ytop; + e->height_left = ybot - ytop; + + if (dx == 0) { + e->vertical = TRUE; + e->x.quo = edge->line.p1.x; + e->x.rem = 0; + e->dxdy.quo = 0; + e->dxdy.rem = 0; + } else { + e->vertical = FALSE; + e->dxdy = floored_divrem (dx, dy); + if (ytop == edge->line.p1.y) { + e->x.quo = edge->line.p1.x; + e->x.rem = 0; + } else { + e->x = floored_muldivrem (ytop - edge->line.p1.y, dx, dy); + e->x.quo += edge->line.p1.x; + } + } + + _polygon_insert_edge_into_its_y_bucket (polygon, e); + + e->x.rem -= dy; /* Bias the remainder for faster + * edge advancement. */ +} + +static void +active_list_reset (struct active_list *active) +{ + active->head.vertical = 1; + active->head.height_left = INT_MAX; + active->head.x.quo = INT_MIN; + active->head.prev = NULL; + active->head.next = &active->tail; + active->tail.prev = &active->head; + active->tail.next = NULL; + active->tail.x.quo = INT_MAX; + active->tail.height_left = INT_MAX; + active->tail.vertical = 1; + active->min_height = 0; + active->is_vertical = 1; +} + +static void +active_list_init(struct active_list *active) +{ + active_list_reset(active); +} + +/* + * Merge two sorted edge lists. + * Input: + * - head_a: The head of the first list. + * - head_b: The head of the second list; head_b cannot be NULL. + * Output: + * Returns the head of the merged list. + * + * Implementation notes: + * To make it fast (in particular, to reduce to an insertion sort whenever + * one of the two input lists only has a single element) we iterate through + * a list until its head becomes greater than the head of the other list, + * then we switch their roles. As soon as one of the two lists is empty, we + * just attach the other one to the current list and exit. + * Writes to memory are only needed to "switch" lists (as it also requires + * attaching to the output list the list which we will be iterating next) and + * to attach the last non-empty list. + */ +static struct edge * +merge_sorted_edges (struct edge *head_a, struct edge *head_b) +{ + struct edge *head, **next, *prev; + int32_t x; + + prev = head_a->prev; + next = &head; + if (head_a->x.quo <= head_b->x.quo) { + head = head_a; + } else { + head = head_b; + head_b->prev = prev; + goto start_with_b; + } + + do { + x = head_b->x.quo; + while (head_a != NULL && head_a->x.quo <= x) { + prev = head_a; + next = &head_a->next; + head_a = head_a->next; + } + + head_b->prev = prev; + *next = head_b; + if (head_a == NULL) + return head; + +start_with_b: + x = head_a->x.quo; + while (head_b != NULL && head_b->x.quo <= x) { + prev = head_b; + next = &head_b->next; + head_b = head_b->next; + } + + head_a->prev = prev; + *next = head_a; + if (head_b == NULL) + return head; + } while (1); +} + +/* + * Sort (part of) a list. + * Input: + * - list: The list to be sorted; list cannot be NULL. + * - limit: Recursion limit. + * Output: + * - head_out: The head of the sorted list containing the first 2^(level+1) elements of the + * input list; if the input list has fewer elements, head_out be a sorted list + * containing all the elements of the input list. + * Returns the head of the list of unprocessed elements (NULL if the sorted list contains + * all the elements of the input list). + * + * Implementation notes: + * Special case single element list, unroll/inline the sorting of the first two elements. + * Some tail recursion is used since we iterate on the bottom-up solution of the problem + * (we start with a small sorted list and keep merging other lists of the same size to it). + */ +static struct edge * +sort_edges (struct edge *list, + unsigned int level, + struct edge **head_out) +{ + struct edge *head_other, *remaining; + unsigned int i; + + head_other = list->next; + + if (head_other == NULL) { + *head_out = list; + return NULL; + } + + remaining = head_other->next; + if (list->x.quo <= head_other->x.quo) { + *head_out = list; + head_other->next = NULL; + } else { + *head_out = head_other; + head_other->prev = list->prev; + head_other->next = list; + list->prev = head_other; + list->next = NULL; + } + + for (i = 0; i < level && remaining; i++) { + remaining = sort_edges (remaining, i, &head_other); + *head_out = merge_sorted_edges (*head_out, head_other); + } + + return remaining; +} + +static struct edge * +merge_unsorted_edges (struct edge *head, struct edge *unsorted) +{ + sort_edges (unsorted, UINT_MAX, &unsorted); + return merge_sorted_edges (head, unsorted); +} + +/* Test if the edges on the active list can be safely advanced by a + * full row without intersections or any edges ending. */ +inline static int +can_do_full_row (struct active_list *active) +{ + const struct edge *e; + + /* Recomputes the minimum height of all edges on the active + * list if we have been dropping edges. */ + if (active->min_height <= 0) { + int min_height = INT_MAX; + int is_vertical = 1; + + e = active->head.next; + while (NULL != e) { + if (e->height_left < min_height) + min_height = e->height_left; + is_vertical &= e->vertical; + e = e->next; + } + + active->is_vertical = is_vertical; + active->min_height = min_height; + } + + if (active->min_height < GRID_Y) + return 0; + + return active->is_vertical; +} + +/* Merges edges on the given subpixel row from the polygon to the + * active_list. */ +inline static void +active_list_merge_edges_from_bucket(struct active_list *active, + struct edge *edges) +{ + active->head.next = merge_unsorted_edges (active->head.next, edges); +} + +inline static void +polygon_fill_buckets (struct active_list *active, + struct edge *edge, + int y, + struct edge **buckets) +{ + grid_scaled_y_t min_height = active->min_height; + int is_vertical = active->is_vertical; + + while (edge) { + struct edge *next = edge->next; + int suby = edge->ytop - y; + if (buckets[suby]) + buckets[suby]->prev = edge; + edge->next = buckets[suby]; + edge->prev = NULL; + buckets[suby] = edge; + if (edge->height_left < min_height) + min_height = edge->height_left; + is_vertical &= edge->vertical; + edge = next; + } + + active->is_vertical = is_vertical; + active->min_height = min_height; +} + +inline static void +sub_row (struct active_list *active, + struct cell_list *coverages, + unsigned int mask) +{ + struct edge *edge = active->head.next; + int xstart = INT_MIN, prev_x = INT_MIN; + int winding = 0; + + cell_list_rewind (coverages); + + while (&active->tail != edge) { + struct edge *next = edge->next; + int xend = edge->x.quo; + + if (--edge->height_left) { + edge->x.quo += edge->dxdy.quo; + edge->x.rem += edge->dxdy.rem; + if (edge->x.rem >= 0) { + ++edge->x.quo; + edge->x.rem -= edge->dy; + } + + if (edge->x.quo < prev_x) { + struct edge *pos = edge->prev; + pos->next = next; + next->prev = pos; + do { + pos = pos->prev; + } while (edge->x.quo < pos->x.quo); + pos->next->prev = edge; + edge->next = pos->next; + edge->prev = pos; + pos->next = edge; + } else + prev_x = edge->x.quo; + } else { + edge->prev->next = next; + next->prev = edge->prev; + } + + winding += edge->dir; + if ((winding & mask) == 0) { + if (next->x.quo != xend) { + cell_list_add_subspan (coverages, xstart, xend); + xstart = INT_MIN; + } + } else if (xstart == INT_MIN) + xstart = xend; + + edge = next; + } +} + +inline static void dec (struct edge *e, int h) +{ + e->height_left -= h; + if (e->height_left == 0) { + e->prev->next = e->next; + e->next->prev = e->prev; + } +} + +static void +full_row (struct active_list *active, + struct cell_list *coverages, + unsigned int mask) +{ + struct edge *left = active->head.next; + + while (&active->tail != left) { + struct edge *right; + int winding; + + dec (left, GRID_Y); + + winding = left->dir; + right = left->next; + do { + dec (right, GRID_Y); + + winding += right->dir; + if ((winding & mask) == 0 && right->next->x.quo != right->x.quo) + break; + + right = right->next; + } while (1); + + cell_list_set_rewind (coverages); + cell_list_render_edge (coverages, left, +1); + cell_list_render_edge (coverages, right, -1); + + left = right->next; + } +} + +static void +_glitter_scan_converter_init(glitter_scan_converter_t *converter, jmp_buf *jmp) +{ + polygon_init(converter->polygon, jmp); + active_list_init(converter->active); + cell_list_init(converter->coverages, jmp); + converter->xmin=0; + converter->ymin=0; + converter->xmax=0; + converter->ymax=0; +} + +static void +_glitter_scan_converter_fini(glitter_scan_converter_t *self) +{ + if (self->spans != self->spans_embedded) + free (self->spans); + + polygon_fini(self->polygon); + cell_list_fini(self->coverages); + + self->xmin=0; + self->ymin=0; + self->xmax=0; + self->ymax=0; +} + +static grid_scaled_t +int_to_grid_scaled(int i, int scale) +{ + /* Clamp to max/min representable scaled number. */ + if (i >= 0) { + if (i >= INT_MAX/scale) + i = INT_MAX/scale; + } + else { + if (i <= INT_MIN/scale) + i = INT_MIN/scale; + } + return i*scale; +} + +#define int_to_grid_scaled_x(x) int_to_grid_scaled((x), GRID_X) +#define int_to_grid_scaled_y(x) int_to_grid_scaled((x), GRID_Y) + +I glitter_status_t +glitter_scan_converter_reset( + glitter_scan_converter_t *converter, + int xmin, int ymin, + int xmax, int ymax) +{ + glitter_status_t status; + + converter->xmin = 0; converter->xmax = 0; + converter->ymin = 0; converter->ymax = 0; + + if (xmax - xmin > ARRAY_LENGTH(converter->spans_embedded)) { + converter->spans = _cairo_malloc_ab (xmax - xmin, + sizeof (cairo_half_open_span_t)); + if (unlikely (converter->spans == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } else + converter->spans = converter->spans_embedded; + + xmin = int_to_grid_scaled_x(xmin); + ymin = int_to_grid_scaled_y(ymin); + xmax = int_to_grid_scaled_x(xmax); + ymax = int_to_grid_scaled_y(ymax); + + active_list_reset(converter->active); + cell_list_reset(converter->coverages); + status = polygon_reset(converter->polygon, ymin, ymax); + if (status) + return status; + + converter->xmin = xmin; + converter->xmax = xmax; + converter->ymin = ymin; + converter->ymax = ymax; + return GLITTER_STATUS_SUCCESS; +} + +/* INPUT_TO_GRID_X/Y (in_coord, out_grid_scaled, grid_scale) + * These macros convert an input coordinate in the client's + * device space to the rasterisation grid. + */ +/* Gah.. this bit of ugly defines INPUT_TO_GRID_X/Y so as to use + * shifts if possible, and something saneish if not. + */ +#if !defined(INPUT_TO_GRID_Y) && defined(GRID_Y_BITS) && GRID_Y_BITS <= GLITTER_INPUT_BITS +# define INPUT_TO_GRID_Y(in, out) (out) = (in) >> (GLITTER_INPUT_BITS - GRID_Y_BITS) +#else +# define INPUT_TO_GRID_Y(in, out) INPUT_TO_GRID_general(in, out, GRID_Y) +#endif + +#if !defined(INPUT_TO_GRID_X) && defined(GRID_X_BITS) && GRID_X_BITS <= GLITTER_INPUT_BITS +# define INPUT_TO_GRID_X(in, out) (out) = (in) >> (GLITTER_INPUT_BITS - GRID_X_BITS) +#else +# define INPUT_TO_GRID_X(in, out) INPUT_TO_GRID_general(in, out, GRID_X) +#endif + +#define INPUT_TO_GRID_general(in, out, grid_scale) do { \ + long long tmp__ = (long long)(grid_scale) * (in); \ + tmp__ >>= GLITTER_INPUT_BITS; \ + (out) = tmp__; \ +} while (0) + +/* Add a new polygon edge from pixel (x1,y1) to (x2,y2) to the scan + * converter. The coordinates represent pixel positions scaled by + * 2**GLITTER_PIXEL_BITS. If this function fails then the scan + * converter should be reset or destroyed. Dir must be +1 or -1, + * with the latter reversing the orientation of the edge. */ +I void +glitter_scan_converter_add_edge (glitter_scan_converter_t *converter, + const cairo_edge_t *edge) +{ + cairo_edge_t e; + + INPUT_TO_GRID_Y (edge->top, e.top); + INPUT_TO_GRID_Y (edge->bottom, e.bottom); + if (e.top >= e.bottom) + return; + + /* XXX: possible overflows if GRID_X/Y > 2**GLITTER_INPUT_BITS */ + INPUT_TO_GRID_Y (edge->line.p1.y, e.line.p1.y); + INPUT_TO_GRID_Y (edge->line.p2.y, e.line.p2.y); + if (e.line.p1.y == e.line.p2.y) + return; + + INPUT_TO_GRID_X (edge->line.p1.x, e.line.p1.x); + INPUT_TO_GRID_X (edge->line.p2.x, e.line.p2.x); + + e.dir = edge->dir; + + polygon_add_edge (converter->polygon, &e); +} + +static void +step_edges (struct active_list *active, int count) +{ + struct edge *edge; + + count *= GRID_Y; + for (edge = active->head.next; edge != &active->tail; edge = edge->next) { + edge->height_left -= count; + if (! edge->height_left) { + edge->prev->next = edge->next; + edge->next->prev = edge->prev; + } + } +} + +static glitter_status_t +blit_a8 (struct cell_list *cells, + cairo_span_renderer_t *renderer, + cairo_half_open_span_t *spans, + int y, int height, + int xmin, int xmax) +{ + struct cell *cell = cells->head.next; + int prev_x = xmin, last_x = -1; + int16_t cover = 0, last_cover = 0; + unsigned num_spans; + + if (cell == &cells->tail) + return CAIRO_STATUS_SUCCESS; + + /* Skip cells to the left of the clip region. */ + while (cell->x < xmin) { + cover += cell->covered_height; + cell = cell->next; + } + cover *= GRID_X*2; + + /* Form the spans from the coverages and areas. */ + num_spans = 0; + for (; cell->x < xmax; cell = cell->next) { + int x = cell->x; + int16_t area; + + if (x > prev_x && cover != last_cover) { + spans[num_spans].x = prev_x; + spans[num_spans].coverage = GRID_AREA_TO_ALPHA (cover); + last_cover = cover; + last_x = prev_x; + ++num_spans; + } + + cover += cell->covered_height*GRID_X*2; + area = cover - cell->uncovered_area; + + if (area != last_cover) { + spans[num_spans].x = x; + spans[num_spans].coverage = GRID_AREA_TO_ALPHA (area); + last_cover = area; + last_x = x; + ++num_spans; + } + + prev_x = x+1; + } + + if (prev_x <= xmax && cover != last_cover) { + spans[num_spans].x = prev_x; + spans[num_spans].coverage = GRID_AREA_TO_ALPHA (cover); + last_cover = cover; + last_x = prev_x; + ++num_spans; + } + + if (last_x < xmax && last_cover) { + spans[num_spans].x = xmax; + spans[num_spans].coverage = 0; + ++num_spans; + } + + /* Dump them into the renderer. */ + return renderer->render_rows (renderer, y, height, spans, num_spans); +} + +#define GRID_AREA_TO_A1(A) ((GRID_AREA_TO_ALPHA (A) > 127) ? 255 : 0) +static glitter_status_t +blit_a1 (struct cell_list *cells, + cairo_span_renderer_t *renderer, + cairo_half_open_span_t *spans, + int y, int height, + int xmin, int xmax) +{ + struct cell *cell = cells->head.next; + int prev_x = xmin, last_x = -1; + int16_t cover = 0; + uint8_t coverage, last_cover = 0; + unsigned num_spans; + + if (cell == &cells->tail) + return CAIRO_STATUS_SUCCESS; + + /* Skip cells to the left of the clip region. */ + while (cell->x < xmin) { + cover += cell->covered_height; + cell = cell->next; + } + cover *= GRID_X*2; + + /* Form the spans from the coverages and areas. */ + num_spans = 0; + for (; cell->x < xmax; cell = cell->next) { + int x = cell->x; + int16_t area; + + coverage = GRID_AREA_TO_A1 (cover); + if (x > prev_x && coverage != last_cover) { + last_x = spans[num_spans].x = prev_x; + last_cover = spans[num_spans].coverage = coverage; + ++num_spans; + } + + cover += cell->covered_height*GRID_X*2; + area = cover - cell->uncovered_area; + + coverage = GRID_AREA_TO_A1 (area); + if (coverage != last_cover) { + last_x = spans[num_spans].x = x; + last_cover = spans[num_spans].coverage = coverage; + ++num_spans; + } + + prev_x = x+1; + } + + coverage = GRID_AREA_TO_A1 (cover); + if (prev_x <= xmax && coverage != last_cover) { + last_x = spans[num_spans].x = prev_x; + last_cover = spans[num_spans].coverage = coverage; + ++num_spans; + } + + if (last_x < xmax && last_cover) { + spans[num_spans].x = xmax; + spans[num_spans].coverage = 0; + ++num_spans; + } + if (num_spans == 1) + return CAIRO_STATUS_SUCCESS; + + /* Dump them into the renderer. */ + return renderer->render_rows (renderer, y, height, spans, num_spans); +} + + +I void +glitter_scan_converter_render(glitter_scan_converter_t *converter, + unsigned int winding_mask, + int antialias, + cairo_span_renderer_t *renderer) +{ + int i, j; + int ymax_i = converter->ymax / GRID_Y; + int ymin_i = converter->ymin / GRID_Y; + int xmin_i, xmax_i; + int h = ymax_i - ymin_i; + struct polygon *polygon = converter->polygon; + struct cell_list *coverages = converter->coverages; + struct active_list *active = converter->active; + struct edge *buckets[GRID_Y] = { 0 }; + + xmin_i = converter->xmin / GRID_X; + xmax_i = converter->xmax / GRID_X; + if (xmin_i >= xmax_i) + return; + + /* Render each pixel row. */ + for (i = 0; i < h; i = j) { + int do_full_row = 0; + + j = i + 1; + + /* Determine if we can ignore this row or use the full pixel + * stepper. */ + if (! polygon->y_buckets[i]) { + if (active->head.next == &active->tail) { + active->min_height = INT_MAX; + active->is_vertical = 1; + for (; j < h && ! polygon->y_buckets[j]; j++) + ; + continue; + } + + do_full_row = can_do_full_row (active); + } + + if (do_full_row) { + /* Step by a full pixel row's worth. */ + full_row (active, coverages, winding_mask); + + if (active->is_vertical) { + while (j < h && + polygon->y_buckets[j] == NULL && + active->min_height >= 2*GRID_Y) + { + active->min_height -= GRID_Y; + j++; + } + if (j != i + 1) + step_edges (active, j - (i + 1)); + } + } else { + int sub; + + polygon_fill_buckets (active, + polygon->y_buckets[i], + (i+ymin_i)*GRID_Y, + buckets); + + /* Subsample this row. */ + for (sub = 0; sub < GRID_Y; sub++) { + if (buckets[sub]) { + active_list_merge_edges_from_bucket (active, buckets[sub]); + buckets[sub] = NULL; + } + + sub_row (active, coverages, winding_mask); + } + } + + if (antialias) + blit_a8 (coverages, renderer, converter->spans, + i+ymin_i, j-i, xmin_i, xmax_i); + else + blit_a1 (coverages, renderer, converter->spans, + i+ymin_i, j-i, xmin_i, xmax_i); + cell_list_reset (coverages); + + active->min_height -= GRID_Y; + } +} + +struct _cairo_tor22_scan_converter { + cairo_scan_converter_t base; + + glitter_scan_converter_t converter[1]; + cairo_fill_rule_t fill_rule; + cairo_antialias_t antialias; + + jmp_buf jmp; +}; + +typedef struct _cairo_tor22_scan_converter cairo_tor22_scan_converter_t; + +static void +_cairo_tor22_scan_converter_destroy (void *converter) +{ + cairo_tor22_scan_converter_t *self = converter; + if (self == NULL) { + return; + } + _glitter_scan_converter_fini (self->converter); + free(self); +} + +cairo_status_t +_cairo_tor22_scan_converter_add_polygon (void *converter, + const cairo_polygon_t *polygon) +{ + cairo_tor22_scan_converter_t *self = converter; + int i; + +#if 0 + FILE *file = fopen ("polygon.txt", "w"); + _cairo_debug_print_polygon (file, polygon); + fclose (file); +#endif + + for (i = 0; i < polygon->num_edges; i++) + glitter_scan_converter_add_edge (self->converter, &polygon->edges[i]); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +_cairo_tor22_scan_converter_generate (void *converter, + cairo_span_renderer_t *renderer) +{ + cairo_tor22_scan_converter_t *self = converter; + cairo_status_t status; + + if ((status = setjmp (self->jmp))) + return _cairo_scan_converter_set_error (self, _cairo_error (status)); + + glitter_scan_converter_render (self->converter, + self->fill_rule == CAIRO_FILL_RULE_WINDING ? ~0 : 1, + self->antialias != CAIRO_ANTIALIAS_NONE, + renderer); + return CAIRO_STATUS_SUCCESS; +} + +cairo_scan_converter_t * +_cairo_tor22_scan_converter_create (int xmin, + int ymin, + int xmax, + int ymax, + cairo_fill_rule_t fill_rule, + cairo_antialias_t antialias) +{ + cairo_tor22_scan_converter_t *self; + cairo_status_t status; + + self = malloc (sizeof(struct _cairo_tor22_scan_converter)); + if (unlikely (self == NULL)) { + status = _cairo_error (CAIRO_STATUS_NO_MEMORY); + goto bail_nomem; + } + + self->base.destroy = _cairo_tor22_scan_converter_destroy; + self->base.generate = _cairo_tor22_scan_converter_generate; + + _glitter_scan_converter_init (self->converter, &self->jmp); + status = glitter_scan_converter_reset (self->converter, + xmin, ymin, xmax, ymax); + if (unlikely (status)) + goto bail; + + self->fill_rule = fill_rule; + self->antialias = antialias; + + return &self->base; + + bail: + self->base.destroy(&self->base); + bail_nomem: + return _cairo_scan_converter_create_in_error (status); +} diff --git a/src/cairo-traps-compositor.c b/src/cairo-traps-compositor.c new file mode 100644 index 00000000..92c8665a --- /dev/null +++ b/src/cairo-traps-compositor.c @@ -0,0 +1,2032 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Joonas Pihlaja <jpihlaja@cc.helsinki.fi> + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#include "cairoint.h" + +#include "cairo-box-private.h" +#include "cairo-boxes-private.h" +#include "cairo-clip-private.h" +#include "cairo-composite-rectangles-private.h" +#include "cairo-compositor-private.h" +#include "cairo-error-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-pattern-private.h" +#include "cairo-paginated-private.h" +#include "cairo-recording-surface-private.h" +#include "cairo-surface-subsurface-private.h" +#include "cairo-surface-snapshot-private.h" +#include "cairo-surface-observer-private.h" +#include "cairo-region-private.h" +#include "cairo-spans-private.h" +#include "cairo-traps-private.h" +#include "cairo-tristrip-private.h" + +typedef cairo_int_status_t +(*draw_func_t) (const cairo_traps_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip); + +static void do_unaligned_row(void (*blt)(void *closure, + int16_t x, int16_t y, + int16_t w, int16_t h, + uint16_t coverage), + void *closure, + const cairo_box_t *b, + int tx, int y, int h, + uint16_t coverage) +{ + int x1 = _cairo_fixed_integer_part (b->p1.x) - tx; + int x2 = _cairo_fixed_integer_part (b->p2.x) - tx; + if (x2 > x1) { + if (! _cairo_fixed_is_integer (b->p1.x)) { + blt(closure, x1, y, 1, h, + coverage * (256 - _cairo_fixed_fractional_part (b->p1.x))); + x1++; + } + + if (x2 > x1) + blt(closure, x1, y, x2-x1, h, (coverage << 8) - (coverage >> 8)); + + if (! _cairo_fixed_is_integer (b->p2.x)) + blt(closure, x2, y, 1, h, + coverage * _cairo_fixed_fractional_part (b->p2.x)); + } else + blt(closure, x1, y, 1, h, + coverage * (b->p2.x - b->p1.x)); +} + +static void do_unaligned_box(void (*blt)(void *closure, + int16_t x, int16_t y, + int16_t w, int16_t h, + uint16_t coverage), + void *closure, + const cairo_box_t *b, int tx, int ty) +{ + int y1 = _cairo_fixed_integer_part (b->p1.y) - ty; + int y2 = _cairo_fixed_integer_part (b->p2.y) - ty; + if (y2 > y1) { + if (! _cairo_fixed_is_integer (b->p1.y)) { + do_unaligned_row(blt, closure, b, tx, y1, 1, + 256 - _cairo_fixed_fractional_part (b->p1.y)); + y1++; + } + + if (y2 > y1) + do_unaligned_row(blt, closure, b, tx, y1, y2-y1, 256); + + if (! _cairo_fixed_is_integer (b->p2.y)) + do_unaligned_row(blt, closure, b, tx, y2, 1, + _cairo_fixed_fractional_part (b->p2.y)); + } else + do_unaligned_row(blt, closure, b, tx, y1, 1, + b->p2.y - b->p1.y); +} + +struct blt_in { + const cairo_traps_compositor_t *compositor; + cairo_surface_t *dst; + cairo_boxes_t boxes; +}; + +static void blt_in(void *closure, + int16_t x, int16_t y, + int16_t w, int16_t h, + uint16_t coverage) +{ + struct blt_in *info = closure; + cairo_color_t color; + + if (CAIRO_ALPHA_SHORT_IS_OPAQUE (coverage)) + return; + + _cairo_box_from_integers (&info->boxes.chunks.base[0], x, y, w, h); + + _cairo_color_init_rgba (&color, 0, 0, 0, coverage / (double) 0xffff); + info->compositor->fill_boxes (info->dst, + CAIRO_OPERATOR_IN, &color, + &info->boxes); +} + +static cairo_int_status_t +combine_clip_as_traps (const cairo_traps_compositor_t *compositor, + cairo_surface_t *mask, + const cairo_clip_t *clip, + const cairo_rectangle_int_t *extents) +{ + cairo_polygon_t polygon; + cairo_fill_rule_t fill_rule; + cairo_antialias_t antialias; + cairo_traps_t traps; + cairo_surface_t *src; + int src_x, src_y; + cairo_int_status_t status; + + status = _cairo_clip_get_polygon (clip, &polygon, + &fill_rule, &antialias); + if (status) + return status; + + _cairo_traps_init (&traps); + status = _cairo_bentley_ottmann_tessellate_polygon (&traps, + &polygon, + fill_rule); + _cairo_polygon_fini (&polygon); + if (unlikely (status)) + return status; + + src = compositor->pattern_to_surface (mask, NULL, FALSE, + extents, NULL, + &src_x, &src_y); + if (unlikely (src->status)) { + _cairo_traps_fini (&traps); + return src->status; + } + + status = compositor->composite_traps (mask, CAIRO_OPERATOR_IN, src, + src_x, src_y, + extents->x, extents->y, + extents, + antialias, &traps); + + cairo_surface_destroy (src); + _cairo_traps_fini (&traps); + + return status; +} + +static cairo_surface_t * +traps_get_clip_surface (const cairo_traps_compositor_t *compositor, + cairo_surface_t *target, + const cairo_clip_t *clip, + const cairo_rectangle_int_t *extents) +{ + cairo_surface_t *surface; + cairo_int_status_t status; + + surface = _cairo_surface_create_similar_solid (target, + CAIRO_CONTENT_ALPHA, + extents->width, + extents->height, + CAIRO_COLOR_WHITE); + if (unlikely (surface->status)) + return surface; + + status = compositor->acquire (surface); + if (unlikely (status)) { + cairo_surface_destroy (surface); + return _cairo_surface_create_in_error (status); + } + + status = combine_clip_as_traps (compositor, surface, clip, extents); + if (status == CAIRO_INT_STATUS_UNSUPPORTED) { + status = _cairo_clip_combine_with_surface (clip, surface, + extents->x, extents->y); + } + compositor->release (surface); + + return surface; +} + +static cairo_surface_t * +create_composite_mask (const cairo_traps_compositor_t *compositor, + cairo_surface_t *dst, + void *draw_closure, + draw_func_t draw_func, + draw_func_t mask_func, + const cairo_composite_rectangles_t *extents) +{ + cairo_surface_t *surface, *src; + cairo_int_status_t status; + struct blt_in info; + int src_x, src_y; + int i; + + surface = _cairo_surface_create_similar_solid (dst, + CAIRO_CONTENT_ALPHA, + extents->bounded.width, + extents->bounded.height, + CAIRO_COLOR_TRANSPARENT); + if (unlikely (surface->status)) + return surface; + + src = compositor->pattern_to_surface (surface, + &_cairo_pattern_white.base, + FALSE, + &extents->bounded, + &extents->bounded, + &src_x, &src_y); + if (unlikely (src->status)) + return src; + + status = compositor->acquire (surface); + if (unlikely (status)) { + cairo_surface_destroy (src); + cairo_surface_destroy (surface); + return _cairo_surface_create_in_error (status); + } + + if (mask_func) { + status = mask_func (compositor, surface, draw_closure, + CAIRO_OPERATOR_SOURCE, src, src_x, src_y, + extents->bounded.x, extents->bounded.y, + &extents->bounded, extents->clip); + if (likely (status != CAIRO_INT_STATUS_UNSUPPORTED)) { + cairo_surface_destroy (src); + goto out; + } + } + + /* Is it worth setting the clip region here? */ + status = draw_func (compositor, surface, draw_closure, + CAIRO_OPERATOR_ADD, src, src_x, src_y, + extents->bounded.x, extents->bounded.y, + &extents->bounded, NULL); + cairo_surface_destroy (src); + if (unlikely (status)) + goto error; + + info.compositor = compositor; + info.dst = surface; + _cairo_boxes_init (&info.boxes); + info.boxes.num_boxes = 1; + for (i = 0; i < extents->clip->num_boxes; i++) { + cairo_box_t *b = &extents->clip->boxes[i]; + + if (! _cairo_fixed_is_integer (b->p1.x) || + ! _cairo_fixed_is_integer (b->p1.y) || + ! _cairo_fixed_is_integer (b->p2.x) || + ! _cairo_fixed_is_integer (b->p2.y)) + { + do_unaligned_box(blt_in, &info, b, + extents->bounded.x, + extents->bounded.y); + } + } + + if (extents->clip->path != NULL) { + status = combine_clip_as_traps (compositor, surface, + extents->clip, &extents->bounded); + if (status == CAIRO_INT_STATUS_UNSUPPORTED) { + status = _cairo_clip_combine_with_surface (extents->clip, surface, + extents->bounded.x, + extents->bounded.y); + } + if (unlikely (status)) + goto error; + } + +out: + compositor->release (surface); + surface->is_clear = FALSE; + return surface; + +error: + cairo_surface_destroy (surface); + surface = _cairo_surface_create_in_error (status); + compositor->release (surface); + return surface; +} + +/* Handles compositing with a clip surface when the operator allows + * us to combine the clip with the mask + */ +static cairo_status_t +clip_and_composite_with_mask (const cairo_traps_compositor_t *compositor, + const cairo_composite_rectangles_t*extents, + draw_func_t draw_func, + draw_func_t mask_func, + void *draw_closure, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, int src_y) +{ + cairo_surface_t *dst = extents->surface; + cairo_surface_t *mask; + + mask = create_composite_mask (compositor, dst, draw_closure, + draw_func, mask_func, + extents); + if (unlikely (mask->status)) + return mask->status; + + if (src != NULL || dst->content != CAIRO_CONTENT_ALPHA) { + compositor->composite (dst, op, src, mask, + extents->bounded.x + src_x, + extents->bounded.y + src_y, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + } else { + compositor->composite (dst, op, mask, NULL, + 0, 0, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + } + cairo_surface_destroy (mask); + + return CAIRO_STATUS_SUCCESS; +} + +/* Handles compositing with a clip surface when we have to do the operation + * in two pieces and combine them together. + */ +static cairo_status_t +clip_and_composite_combine (const cairo_traps_compositor_t *compositor, + const cairo_composite_rectangles_t*extents, + draw_func_t draw_func, + void *draw_closure, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, int src_y) +{ + cairo_surface_t *dst = extents->surface; + cairo_surface_t *tmp, *clip; + cairo_status_t status; + + tmp = _cairo_surface_create_similar_scratch (dst, dst->content, + extents->bounded.width, + extents->bounded.height); + if (unlikely (tmp->status)) + return tmp->status; + + status = compositor->acquire (tmp); + if (unlikely (status)) { + cairo_surface_destroy (tmp); + return status; + } + + compositor->composite (tmp, + dst->is_clear ? CAIRO_OPERATOR_CLEAR : CAIRO_OPERATOR_SOURCE, + dst, NULL, + extents->bounded.x, extents->bounded.y, + 0, 0, + 0, 0, + extents->bounded.width, extents->bounded.height); + + status = draw_func (compositor, tmp, draw_closure, op, + src, src_x, src_y, + extents->bounded.x, extents->bounded.y, + &extents->bounded, NULL); + + if (unlikely (status)) + goto cleanup; + + clip = traps_get_clip_surface (compositor, dst, extents->clip, + &extents->bounded); + if (unlikely ((status = clip->status))) + goto cleanup; + + if (dst->is_clear) { + compositor->composite (dst, CAIRO_OPERATOR_SOURCE, tmp, clip, + 0, 0, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + } else { + compositor->lerp (dst, tmp, clip, + 0, 0, + 0,0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + } + cairo_surface_destroy (clip); + +cleanup: + compositor->release (tmp); + cairo_surface_destroy (tmp); + + return status; +} + +/* Handles compositing for %CAIRO_OPERATOR_SOURCE, which is special; it's + * defined as (src IN mask IN clip) ADD (dst OUT (mask IN clip)) + */ +static cairo_status_t +clip_and_composite_source (const cairo_traps_compositor_t *compositor, + cairo_surface_t *dst, + draw_func_t draw_func, + draw_func_t mask_func, + void *draw_closure, + cairo_surface_t *src, + int src_x, + int src_y, + const cairo_composite_rectangles_t *extents) +{ + cairo_surface_t *mask; + + /* Create a surface that is mask IN clip */ + mask = create_composite_mask (compositor, dst, draw_closure, + draw_func, mask_func, + extents); + if (unlikely (mask->status)) + return mask->status; + + if (dst->is_clear) { + compositor->composite (dst, CAIRO_OPERATOR_SOURCE, src, mask, + extents->bounded.x + src_x, extents->bounded.y + src_y, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + } else { + compositor->lerp (dst, src, mask, + extents->bounded.x + src_x, extents->bounded.y + src_y, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + } + + cairo_surface_destroy (mask); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_bool_t +can_reduce_alpha_op (cairo_operator_t op) +{ + int iop = op; + switch (iop) { + case CAIRO_OPERATOR_OVER: + case CAIRO_OPERATOR_SOURCE: + case CAIRO_OPERATOR_ADD: + return TRUE; + default: + return FALSE; + } +} + +static cairo_bool_t +reduce_alpha_op (cairo_composite_rectangles_t *extents) +{ + cairo_surface_t *dst = extents->surface; + cairo_operator_t op = extents->op; + const cairo_pattern_t *pattern = &extents->source_pattern.base; + return dst->is_clear && + dst->content == CAIRO_CONTENT_ALPHA && + _cairo_pattern_is_opaque_solid (pattern) && + can_reduce_alpha_op (op); +} + +static cairo_status_t +fixup_unbounded_with_mask (const cairo_traps_compositor_t *compositor, + const cairo_composite_rectangles_t *extents) +{ + cairo_surface_t *dst = extents->surface; + cairo_clip_t *clip = extents->clip; + cairo_surface_t *mask; + + /* XXX can we avoid querying the clip surface again? */ + mask = traps_get_clip_surface (compositor, dst, clip, &extents->unbounded); + if (unlikely (mask->status)) + return mask->status; + + /* top */ + if (extents->bounded.y != extents->unbounded.y) { + int x = extents->unbounded.x; + int y = extents->unbounded.y; + int width = extents->unbounded.width; + int height = extents->bounded.y - y; + + compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL, + 0, 0, + 0, 0, + x, y, + width, height); + } + + /* left */ + if (extents->bounded.x != extents->unbounded.x) { + int x = extents->unbounded.x; + int y = extents->bounded.y; + int width = extents->bounded.x - x; + int height = extents->bounded.height; + + compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL, + 0, y - extents->unbounded.y, + 0, 0, + x, y, + width, height); + } + + /* right */ + if (extents->bounded.x + extents->bounded.width != extents->unbounded.x + extents->unbounded.width) { + int x = extents->bounded.x + extents->bounded.width; + int y = extents->bounded.y; + int width = extents->unbounded.x + extents->unbounded.width - x; + int height = extents->bounded.height; + + compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL, + x - extents->unbounded.x, y - extents->unbounded.y, + 0, 0, + x, y, + width, height); + } + + /* bottom */ + if (extents->bounded.y + extents->bounded.height != extents->unbounded.y + extents->unbounded.height) { + int x = extents->unbounded.x; + int y = extents->bounded.y + extents->bounded.height; + int width = extents->unbounded.width; + int height = extents->unbounded.y + extents->unbounded.height - y; + + compositor->composite (dst, CAIRO_OPERATOR_DEST_OUT, mask, NULL, + 0, y - extents->unbounded.y, + 0, 0, + x, y, + width, height); + } + + cairo_surface_destroy (mask); + + return CAIRO_STATUS_SUCCESS; +} + +static void +add_rect (cairo_boxes_t *boxes, int x1, int y1, int x2, int y2) +{ + cairo_box_t box; + cairo_int_status_t status; + + box.p1.x = _cairo_fixed_from_int (x1); + box.p1.y = _cairo_fixed_from_int (y1); + box.p2.x = _cairo_fixed_from_int (x2); + box.p2.y = _cairo_fixed_from_int (y2); + + status = _cairo_boxes_add (boxes, CAIRO_ANTIALIAS_DEFAULT, &box); + assert (status == CAIRO_INT_STATUS_SUCCESS); +} + +static cairo_status_t +fixup_unbounded (const cairo_traps_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_surface_t *dst = extents->surface; + cairo_boxes_t clear, tmp; + cairo_box_t box; + cairo_int_status_t status; + + if (extents->bounded.width == extents->unbounded.width && + extents->bounded.height == extents->unbounded.height) + { + return CAIRO_STATUS_SUCCESS; + } + + assert (extents->clip->path == NULL); + + /* subtract the drawn boxes from the unbounded area */ + _cairo_boxes_init (&clear); + + box.p1.x = _cairo_fixed_from_int (extents->unbounded.x + extents->unbounded.width); + box.p1.y = _cairo_fixed_from_int (extents->unbounded.y); + box.p2.x = _cairo_fixed_from_int (extents->unbounded.x); + box.p2.y = _cairo_fixed_from_int (extents->unbounded.y + extents->unbounded.height); + + if (boxes == NULL) { + if (extents->bounded.width == 0 || extents->bounded.height == 0) { + goto empty; + } else { + /* top */ + if (extents->bounded.y != extents->unbounded.y) { + add_rect (&clear, + extents->unbounded.x, extents->unbounded.y, + extents->unbounded.x + extents->unbounded.width, + extents->bounded.y); + } + /* left */ + if (extents->bounded.x != extents->unbounded.x) { + add_rect (&clear, + extents->unbounded.x, extents->bounded.y, + extents->bounded.x, + extents->bounded.y + extents->bounded.height); + } + /* right */ + if (extents->bounded.x + extents->bounded.width != extents->unbounded.x + extents->unbounded.width) { + add_rect (&clear, + extents->bounded.x + extents->bounded.width, + extents->bounded.y, + extents->unbounded.x + extents->unbounded.width, + extents->bounded.y + extents->bounded.height); + } + /* bottom */ + if (extents->bounded.y + extents->bounded.height != extents->unbounded.y + extents->unbounded.height) { + add_rect (&clear, + extents->unbounded.x, + extents->bounded.y + extents->bounded.height, + extents->unbounded.x + extents->unbounded.width, + extents->unbounded.y + extents->unbounded.height); + } + } + } else if (boxes->num_boxes) { + _cairo_boxes_init (&tmp); + + assert (boxes->is_pixel_aligned); + + status = _cairo_boxes_add (&tmp, CAIRO_ANTIALIAS_DEFAULT, &box); + assert (status == CAIRO_INT_STATUS_SUCCESS); + + tmp.chunks.next = &boxes->chunks; + tmp.num_boxes += boxes->num_boxes; + + status = _cairo_bentley_ottmann_tessellate_boxes (&tmp, + CAIRO_FILL_RULE_WINDING, + &clear); + tmp.chunks.next = NULL; + if (unlikely (status)) + goto error; + } else { +empty: + box.p1.x = _cairo_fixed_from_int (extents->unbounded.x); + box.p2.x = _cairo_fixed_from_int (extents->unbounded.x + extents->unbounded.width); + + status = _cairo_boxes_add (&clear, CAIRO_ANTIALIAS_DEFAULT, &box); + assert (status == CAIRO_INT_STATUS_SUCCESS); + } + + /* Now intersect with the clip boxes */ + if (extents->clip->num_boxes) { + _cairo_boxes_init_for_array (&tmp, + extents->clip->boxes, + extents->clip->num_boxes); + status = _cairo_boxes_intersect (&clear, &tmp, &clear); + if (unlikely (status)) + goto error; + } + + status = compositor->fill_boxes (dst, + CAIRO_OPERATOR_CLEAR, + CAIRO_COLOR_TRANSPARENT, + &clear); + +error: + _cairo_boxes_fini (&clear); + return status; +} + +enum { + NEED_CLIP_REGION = 0x1, + NEED_CLIP_SURFACE = 0x2, + FORCE_CLIP_REGION = 0x4, +}; + +static cairo_bool_t +need_bounded_clip (cairo_composite_rectangles_t *extents) +{ + unsigned int flags = 0; + + if (extents->unbounded.width < extents->destination.width || + extents->unbounded.height < extents->destination.height) + { + flags |= NEED_CLIP_REGION; + } + + if (! _cairo_clip_is_region (extents->clip)) + flags |= NEED_CLIP_SURFACE; + + return flags; +} + +static cairo_bool_t +need_unbounded_clip (cairo_composite_rectangles_t *extents) +{ + unsigned int flags = 0; + if (! extents->is_bounded) { + flags |= NEED_CLIP_REGION; + if (! _cairo_clip_is_region (extents->clip)) + flags |= NEED_CLIP_SURFACE; + } + if (extents->clip->path != NULL) + flags |= NEED_CLIP_SURFACE; + return flags; +} + +static cairo_status_t +clip_and_composite (const cairo_traps_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + draw_func_t draw_func, + draw_func_t mask_func, + void *draw_closure, + unsigned int need_clip) +{ + cairo_surface_t *dst = extents->surface; + cairo_operator_t op = extents->op; + cairo_pattern_t *source = &extents->source_pattern.base; + cairo_surface_t *src; + int src_x, src_y; + cairo_region_t *clip_region = NULL; + cairo_status_t status; + + if (reduce_alpha_op (extents)) { + op = CAIRO_OPERATOR_ADD; + source = NULL; + } + + if (op == CAIRO_OPERATOR_CLEAR) { + op = CAIRO_OPERATOR_DEST_OUT; + source = NULL; + } + + src = compositor->pattern_to_surface (dst, source, FALSE, + &extents->bounded, + &extents->source_sample_area, + &src_x, &src_y); + if (unlikely (src->status)) + return src->status; + + compositor->acquire (dst); + + if (need_clip & NEED_CLIP_REGION) { + const cairo_rectangle_int_t *limit; + + if ((need_clip & FORCE_CLIP_REGION) == 0) + limit = &extents->unbounded; + else + limit = &extents->destination; + + clip_region = _cairo_clip_get_region (extents->clip); + if (clip_region != NULL && + cairo_region_contains_rectangle (clip_region, + limit) == CAIRO_REGION_OVERLAP_IN) + clip_region = NULL; + + if (clip_region != NULL) { + status = compositor->set_clip_region (dst, clip_region); + if (unlikely (status)) { + compositor->release (dst); + return status; + } + } + } + + if (op == CAIRO_OPERATOR_SOURCE) { + status = clip_and_composite_source (compositor, dst, + draw_func, mask_func, draw_closure, + src, src_x, src_y, + extents); + } else { + if (need_clip & NEED_CLIP_SURFACE) { + if (extents->is_bounded) { + status = clip_and_composite_with_mask (compositor, extents, + draw_func, mask_func, + draw_closure, + op, src, src_x, src_y); + } else { + status = clip_and_composite_combine (compositor, extents, + draw_func, draw_closure, + op, src, src_x, src_y); + } + } else { + status = draw_func (compositor, + dst, draw_closure, + op, src, src_x, src_y, + 0, 0, + &extents->bounded, + extents->clip); + } + } + + if (status == CAIRO_STATUS_SUCCESS && ! extents->is_bounded) { + if (need_clip & NEED_CLIP_SURFACE) + status = fixup_unbounded_with_mask (compositor, extents); + else + status = fixup_unbounded (compositor, extents, NULL); + } + + if (clip_region) + compositor->set_clip_region (dst, NULL); + + cairo_surface_destroy (src); + compositor->release (dst); + + return status; +} + +/* meta-ops */ + +typedef struct { + cairo_traps_t traps; + cairo_antialias_t antialias; +} composite_traps_info_t; + +static cairo_int_status_t +composite_traps (const cairo_traps_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, int src_y, + int dst_x, int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip) +{ + composite_traps_info_t *info = closure; + + return compositor->composite_traps (dst, op, src, + src_x - dst_x, src_y - dst_y, + dst_x, dst_y, + extents, + info->antialias, &info->traps); +} + +typedef struct { + cairo_tristrip_t strip; + cairo_antialias_t antialias; +} composite_tristrip_info_t; + +static cairo_int_status_t +composite_tristrip (const cairo_traps_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, int src_y, + int dst_x, int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip) +{ + composite_tristrip_info_t *info = closure; + + return compositor->composite_tristrip (dst, op, src, + src_x - dst_x, src_y - dst_y, + dst_x, dst_y, + extents, + info->antialias, &info->strip); +} + +static cairo_bool_t +is_recording_pattern (const cairo_pattern_t *pattern) +{ + cairo_surface_t *surface; + + if (pattern->type != CAIRO_PATTERN_TYPE_SURFACE) + return FALSE; + + surface = ((const cairo_surface_pattern_t *) pattern)->surface; + if (_cairo_surface_is_paginated (surface)) + surface = _cairo_paginated_surface_get_recording (surface); + if (_cairo_surface_is_snapshot (surface)) + surface = _cairo_surface_snapshot_get_target (surface); + return _cairo_surface_is_recording (surface); +} + +static cairo_surface_t * +recording_pattern_get_surface (const cairo_pattern_t *pattern) +{ + cairo_surface_t *surface; + + surface = ((const cairo_surface_pattern_t *) pattern)->surface; + if (_cairo_surface_is_paginated (surface)) + surface = _cairo_paginated_surface_get_recording (surface); + if (_cairo_surface_is_snapshot (surface)) + surface = _cairo_surface_snapshot_get_target (surface); + return surface; +} + +static cairo_bool_t +recording_pattern_contains_sample (const cairo_pattern_t *pattern, + const cairo_rectangle_int_t *sample) +{ + cairo_recording_surface_t *surface; + + if (! is_recording_pattern (pattern)) + return FALSE; + + if (pattern->extend == CAIRO_EXTEND_NONE) + return TRUE; + + surface = (cairo_recording_surface_t *) recording_pattern_get_surface (pattern); + if (surface->unbounded) + return TRUE; + + if (sample->x >= surface->extents.x && + sample->y >= surface->extents.y && + sample->x + sample->width <= surface->extents.x + surface->extents.width && + sample->y + sample->height <= surface->extents.y + surface->extents.height) + { + return TRUE; + } + + return FALSE; +} + +static cairo_bool_t +op_reduces_to_source (cairo_composite_rectangles_t *extents) +{ + if (extents->op == CAIRO_OPERATOR_SOURCE) + return TRUE; + + if (extents->surface->is_clear) + return extents->op == CAIRO_OPERATOR_OVER || extents->op == CAIRO_OPERATOR_ADD; + + return FALSE; +} + +static cairo_status_t +composite_aligned_boxes (const cairo_traps_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_surface_t *dst = extents->surface; + cairo_operator_t op = extents->op; + cairo_bool_t need_clip_mask = extents->clip->path != NULL; + cairo_bool_t op_is_source; + cairo_status_t status; + + if (need_clip_mask && + (! extents->is_bounded || extents->op == CAIRO_OPERATOR_SOURCE)) + { + return CAIRO_INT_STATUS_UNSUPPORTED; + } + + op_is_source = op_reduces_to_source (extents); + + /* Are we just copying a recording surface? */ + if (! need_clip_mask && op_is_source && + recording_pattern_contains_sample (&extents->source_pattern.base, + &extents->source_sample_area)) + { + cairo_clip_t *recording_clip; + cairo_pattern_t *source = &extents->source_pattern.base; + + /* XXX could also do tiling repeat modes... */ + + /* first clear the area about to be overwritten */ + if (! dst->is_clear) { + status = compositor->acquire (dst); + if (unlikely (status)) + return status; + + status = compositor->fill_boxes (dst, + CAIRO_OPERATOR_CLEAR, + CAIRO_COLOR_TRANSPARENT, + boxes); + compositor->release (dst); + if (unlikely (status)) + return status; + } + + recording_clip = _cairo_clip_from_boxes (boxes); + status = _cairo_recording_surface_replay_with_clip (recording_pattern_get_surface (source), + &source->matrix, + dst, recording_clip); + _cairo_clip_destroy (recording_clip); + + return status; + } + + status = compositor->acquire (dst); + if (unlikely (status)) + return status; + + if (! need_clip_mask && + (op == CAIRO_OPERATOR_CLEAR || + extents->source_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID)) + { + const cairo_color_t *color; + + if (op == CAIRO_OPERATOR_CLEAR) { + color = CAIRO_COLOR_TRANSPARENT; + } else { + color = &((cairo_solid_pattern_t *) &extents->source_pattern)->color; + if (op_is_source) + op = CAIRO_OPERATOR_SOURCE; + } + + status = compositor->fill_boxes (dst, op, color, boxes); + } + else + { + cairo_surface_t *src, *mask = NULL; + cairo_pattern_t *source = &extents->source_pattern.base; + int src_x, src_y; + int mask_x = 0, mask_y = 0; + + if (need_clip_mask) { + mask = _cairo_clip_get_surface (extents->clip, dst, + &mask_x, &mask_y); + if (unlikely (mask->status)) + return mask->status; + + mask_x = -mask_x; + mask_y = -mask_y; + + if (op == CAIRO_OPERATOR_CLEAR) { + source = NULL; + op = CAIRO_OPERATOR_DEST_OUT; + } + } else if (op_is_source) + op = CAIRO_OPERATOR_SOURCE; + + src = compositor->pattern_to_surface (dst, source, FALSE, + &extents->bounded, + &extents->source_sample_area, + &src_x, &src_y); + if (likely (src->status == CAIRO_STATUS_SUCCESS)) { + status = compositor->composite_boxes (dst, op, src, mask, + src_x, src_y, + mask_x, mask_y, + 0, 0, + boxes, &extents->bounded); + cairo_surface_destroy (src); + } else + status = src->status; + + cairo_surface_destroy (mask); + } + + if (status == CAIRO_STATUS_SUCCESS && ! extents->is_bounded) + status = fixup_unbounded (compositor, extents, boxes); + + compositor->release (dst); + + return status; +} + +static cairo_status_t +upload_boxes (const cairo_traps_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_surface_t *dst = extents->surface; + const cairo_pattern_t *source = &extents->source_pattern.base; + const cairo_surface_pattern_t *pattern; + cairo_surface_t *src; + cairo_rectangle_int_t limit; + cairo_int_status_t status; + int tx, ty; + + pattern = (const cairo_surface_pattern_t *) source; + src = pattern->surface; + if (!(src->type == CAIRO_SURFACE_TYPE_IMAGE || src->type == dst->type)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + if (! _cairo_matrix_is_integer_translation (&source->matrix, &tx, &ty)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + if (_cairo_surface_is_snapshot (src)) + src = _cairo_surface_snapshot_get_target (src); + if (_cairo_surface_is_observer (src)) + src = _cairo_surface_observer_get_target (src); + if (_cairo_surface_is_subsurface (src)) { + _cairo_surface_subsurface_offset (src, &tx, &ty); + src = _cairo_surface_subsurface_get_target (src); + } + + /* Check that the data is entirely within the image */ + if (extents->bounded.x + tx < 0 || extents->bounded.y + ty < 0) + return CAIRO_INT_STATUS_UNSUPPORTED; + + _cairo_surface_get_extents (pattern->surface, &limit); + if (extents->bounded.x + extents->bounded.width + tx > limit.width || + extents->bounded.y + extents->bounded.height + ty > limit.height) + return CAIRO_INT_STATUS_UNSUPPORTED; + + if (pattern->surface->type == CAIRO_SURFACE_TYPE_IMAGE) + status = compositor->draw_image_boxes (dst, + (cairo_image_surface_t *)src, + boxes, tx, ty); + else + status = compositor->copy_boxes (dst, src, boxes, &extents->bounded, + tx, ty); + + return status; +} + +static cairo_int_status_t +trim_extents_to_traps (cairo_composite_rectangles_t *extents, + cairo_traps_t *traps) +{ + cairo_box_t box; + + _cairo_traps_extents (traps, &box); + return _cairo_composite_rectangles_intersect_mask_extents (extents, &box); +} + +static cairo_int_status_t +trim_extents_to_tristrip (cairo_composite_rectangles_t *extents, + cairo_tristrip_t *strip) +{ + cairo_box_t box; + + _cairo_tristrip_extents (strip, &box); + return _cairo_composite_rectangles_intersect_mask_extents (extents, &box); +} + +static cairo_int_status_t +trim_extents_to_boxes (cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_box_t box; + + _cairo_boxes_extents (boxes, &box); + return _cairo_composite_rectangles_intersect_mask_extents (extents, &box); +} + +static cairo_int_status_t +boxes_for_traps (cairo_boxes_t *boxes, + cairo_traps_t *traps, + cairo_antialias_t antialias) +{ + int i; + + /* first check that the traps are rectilinear */ + if (antialias == CAIRO_ANTIALIAS_NONE) { + for (i = 0; i < traps->num_traps; i++) { + const cairo_trapezoid_t *t = &traps->traps[i]; + if (_cairo_fixed_integer_round_down (t->left.p1.x) != + _cairo_fixed_integer_round_down (t->left.p2.x) || + _cairo_fixed_integer_round_down (t->right.p1.x) != + _cairo_fixed_integer_round_down (t->right.p2.x)) + { + return CAIRO_INT_STATUS_UNSUPPORTED; + } + } + } else { + for (i = 0; i < traps->num_traps; i++) { + const cairo_trapezoid_t *t = &traps->traps[i]; + if (t->left.p1.x != t->left.p2.x || t->right.p1.x != t->right.p2.x) + return CAIRO_INT_STATUS_UNSUPPORTED; + } + } + + _cairo_boxes_init (boxes); + + boxes->num_boxes = traps->num_traps; + boxes->chunks.base = (cairo_box_t *) traps->traps; + boxes->chunks.count = traps->num_traps; + boxes->chunks.size = traps->num_traps; + + if (antialias != CAIRO_ANTIALIAS_NONE) { + for (i = 0; i < traps->num_traps; i++) { + /* Note the traps and boxes alias so we need to take the local copies first. */ + cairo_fixed_t x1 = traps->traps[i].left.p1.x; + cairo_fixed_t x2 = traps->traps[i].right.p1.x; + cairo_fixed_t y1 = traps->traps[i].top; + cairo_fixed_t y2 = traps->traps[i].bottom; + + boxes->chunks.base[i].p1.x = x1; + boxes->chunks.base[i].p1.y = y1; + boxes->chunks.base[i].p2.x = x2; + boxes->chunks.base[i].p2.y = y2; + + if (boxes->is_pixel_aligned) { + boxes->is_pixel_aligned = + _cairo_fixed_is_integer (x1) && _cairo_fixed_is_integer (y1) && + _cairo_fixed_is_integer (x2) && _cairo_fixed_is_integer (y2); + } + } + } else { + boxes->is_pixel_aligned = TRUE; + + for (i = 0; i < traps->num_traps; i++) { + /* Note the traps and boxes alias so we need to take the local copies first. */ + cairo_fixed_t x1 = traps->traps[i].left.p1.x; + cairo_fixed_t x2 = traps->traps[i].right.p1.x; + cairo_fixed_t y1 = traps->traps[i].top; + cairo_fixed_t y2 = traps->traps[i].bottom; + + /* round down here to match Pixman's behavior when using traps. */ + boxes->chunks.base[i].p1.x = _cairo_fixed_round_down (x1); + boxes->chunks.base[i].p1.y = _cairo_fixed_round_down (y1); + boxes->chunks.base[i].p2.x = _cairo_fixed_round_down (x2); + boxes->chunks.base[i].p2.y = _cairo_fixed_round_down (y2); + } + } + + return CAIRO_INT_STATUS_SUCCESS; +} + +static cairo_status_t +clip_and_composite_boxes (const cairo_traps_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes); + +static cairo_status_t +clip_and_composite_polygon (const cairo_traps_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_polygon_t *polygon, + cairo_antialias_t antialias, + cairo_fill_rule_t fill_rule) +{ + composite_traps_info_t traps; + cairo_surface_t *dst = extents->surface; + cairo_bool_t clip_surface = ! _cairo_clip_is_region (extents->clip); + cairo_int_status_t status; + + if (polygon->num_edges == 0) { + status = CAIRO_INT_STATUS_SUCCESS; + + if (! extents->is_bounded) { + cairo_region_t *clip_region = _cairo_clip_get_region (extents->clip); + + if (clip_region && + cairo_region_contains_rectangle (clip_region, + &extents->unbounded) == CAIRO_REGION_OVERLAP_IN) + clip_region = NULL; + + if (clip_region != NULL) { + status = compositor->set_clip_region (dst, clip_region); + if (unlikely (status)) + return status; + } + + if (clip_surface) + status = fixup_unbounded_with_mask (compositor, extents); + else + status = fixup_unbounded (compositor, extents, NULL); + + if (clip_region != NULL) + compositor->set_clip_region (dst, NULL); + } + + return status; + } + + if (extents->clip->path != NULL && extents->is_bounded) { + cairo_polygon_t clipper; + cairo_fill_rule_t clipper_fill_rule; + cairo_antialias_t clipper_antialias; + + status = _cairo_clip_get_polygon (extents->clip, + &clipper, + &clipper_fill_rule, + &clipper_antialias); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + if (clipper_antialias == antialias) { + status = _cairo_polygon_intersect (polygon, fill_rule, + &clipper, clipper_fill_rule); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + cairo_clip_t * clip = _cairo_clip_copy_region (extents->clip); + _cairo_clip_destroy (extents->clip); + extents->clip = clip; + + fill_rule = CAIRO_FILL_RULE_WINDING; + } + _cairo_polygon_fini (&clipper); + } + } + } + + _cairo_traps_init (&traps.traps); + + status = _cairo_bentley_ottmann_tessellate_polygon (&traps.traps, polygon, fill_rule); + if (unlikely (status)) + goto CLEANUP_TRAPS; + + status = trim_extents_to_traps (extents, &traps.traps); + if (unlikely (status)) + goto CLEANUP_TRAPS; + + /* Use a fast path if the trapezoids consist of a set of boxes. */ + status = CAIRO_INT_STATUS_UNSUPPORTED; + if (1) { + cairo_boxes_t boxes; + + status = boxes_for_traps (&boxes, &traps.traps, antialias); + if (status == CAIRO_INT_STATUS_SUCCESS) { + status = clip_and_composite_boxes (compositor, extents, &boxes); + /* XXX need to reconstruct the traps! */ + assert (status != CAIRO_INT_STATUS_UNSUPPORTED); + } + } + if (status == CAIRO_INT_STATUS_UNSUPPORTED) { + /* Otherwise render the trapezoids to a mask and composite in the usual + * fashion. + */ + unsigned int flags = 0; + + /* For unbounded operations, the X11 server will estimate the + * affected rectangle and apply the operation to that. However, + * there are cases where this is an overestimate (e.g. the + * clip-fill-{eo,nz}-unbounded test). + * + * The clip will trim that overestimate to our expectations. + */ + if (! extents->is_bounded) + flags |= FORCE_CLIP_REGION; + + traps.antialias = antialias; + status = clip_and_composite (compositor, extents, + composite_traps, NULL, &traps, + need_unbounded_clip (extents) | flags); + } + +CLEANUP_TRAPS: + _cairo_traps_fini (&traps.traps); + + return status; +} + +struct composite_opacity_info { + const cairo_traps_compositor_t *compositor; + uint8_t op; + cairo_surface_t *dst; + cairo_surface_t *src; + int src_x, src_y; + double opacity; +}; + +static void composite_opacity(void *closure, + int16_t x, int16_t y, + int16_t w, int16_t h, + uint16_t coverage) +{ + struct composite_opacity_info *info = closure; + const cairo_traps_compositor_t *compositor = info->compositor; + cairo_surface_t *mask; + int mask_x, mask_y; + cairo_color_t color; + cairo_solid_pattern_t solid; + + _cairo_color_init_rgba (&color, 0, 0, 0, info->opacity * coverage); + _cairo_pattern_init_solid (&solid, &color); + mask = compositor->pattern_to_surface (info->dst, &solid.base, TRUE, + &_cairo_unbounded_rectangle, + &_cairo_unbounded_rectangle, + &mask_x, &mask_y); + if (likely (mask->status == CAIRO_STATUS_SUCCESS)) { + if (info->src) { + compositor->composite (info->dst, info->op, info->src, mask, + x + info->src_x, y + info->src_y, + mask_x, mask_y, + x, y, + w, h); + } else { + compositor->composite (info->dst, info->op, mask, NULL, + mask_x, mask_y, + 0, 0, + x, y, + w, h); + } + } + + cairo_surface_destroy (mask); +} + + +static cairo_int_status_t +composite_opacity_boxes (const cairo_traps_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip) +{ + const cairo_solid_pattern_t *mask = closure; + struct composite_opacity_info info; + int i; + + info.compositor = compositor; + info.op = op; + info.dst = dst; + + info.src = src; + info.src_x = src_x; + info.src_y = src_y; + + info.opacity = mask->color.alpha / (double) 0xffff; + + /* XXX for lots of boxes create a clip region for the fully opaque areas */ + for (i = 0; i < clip->num_boxes; i++) + do_unaligned_box(composite_opacity, &info, + &clip->boxes[i], dst_x, dst_y); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_boxes (const cairo_traps_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip) +{ + const cairo_boxes_t *boxes = closure; + const struct _cairo_boxes_chunk *chunk; + struct composite_opacity_info info; + int i; + + info.compositor = compositor; + info.op = op; + info.dst = dst; + + info.src = src; + info.src_x = src_x; + info.src_y = src_y; + + info.opacity = 1. / (double) 0xffff; + + /* XXX for lots of boxes create a clip region for the fully opaque areas */ + for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) + do_unaligned_box(composite_opacity, &info, + &chunk->base[i], dst_x, dst_y); + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +clip_and_composite_boxes (const cairo_traps_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_int_status_t status; + + if (boxes->num_boxes == 0 && extents->is_bounded) + return CAIRO_STATUS_SUCCESS; + + status = trim_extents_to_boxes (extents, boxes); + if (unlikely (status)) + return status; + + if (boxes->is_pixel_aligned && extents->clip->path == NULL && + extents->source_pattern.base.type == CAIRO_PATTERN_TYPE_SURFACE && + (op_reduces_to_source (extents) || + (extents->op == CAIRO_OPERATOR_OVER && + (extents->source_pattern.surface.surface->content & CAIRO_CONTENT_ALPHA) == 0))) + { + status = upload_boxes (compositor, extents, boxes); + if (status != CAIRO_INT_STATUS_UNSUPPORTED) + return status; + } + + /* Can we reduce drawing through a clip-mask to simply drawing the clip? */ + if (extents->clip->path != NULL && extents->is_bounded) { + cairo_polygon_t polygon; + cairo_fill_rule_t fill_rule; + cairo_antialias_t antialias; + cairo_clip_t *clip; + + clip = _cairo_clip_copy (extents->clip); + clip = _cairo_clip_intersect_boxes (clip, boxes); + status = _cairo_clip_get_polygon (clip, &polygon, + &fill_rule, &antialias); + _cairo_clip_path_destroy (clip->path); + clip->path = NULL; + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + cairo_clip_t *saved_clip = extents->clip; + extents->clip = clip; + + status = clip_and_composite_polygon (compositor, extents, &polygon, + antialias, fill_rule); + + clip = extents->clip; + extents->clip = saved_clip; + + _cairo_polygon_fini (&polygon); + } + _cairo_clip_destroy (clip); + + if (status != CAIRO_INT_STATUS_UNSUPPORTED) + return status; + } + + /* Use a fast path if the boxes are pixel aligned (or nearly aligned!) */ + if (boxes->is_pixel_aligned) { + status = composite_aligned_boxes (compositor, extents, boxes); + if (status != CAIRO_INT_STATUS_UNSUPPORTED) + return status; + } + + return clip_and_composite (compositor, extents, + composite_boxes, composite_boxes, boxes, + need_unbounded_clip (extents)); +} + +static cairo_int_status_t +composite_traps_as_boxes (const cairo_traps_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + composite_traps_info_t *info) +{ + cairo_boxes_t boxes; + + if (! _cairo_traps_to_boxes (&info->traps, info->antialias, &boxes)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + return clip_and_composite_boxes (compositor, extents, &boxes); +} + +static cairo_int_status_t +clip_and_composite_traps (const cairo_traps_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + composite_traps_info_t *info) +{ + cairo_int_status_t status; + + status = trim_extents_to_traps (extents, &info->traps); + if (unlikely (status != CAIRO_INT_STATUS_SUCCESS)) + return status; + + status = composite_traps_as_boxes (compositor, extents, info); + if (status == CAIRO_INT_STATUS_UNSUPPORTED) { + unsigned int flags = 0; + + /* For unbounded operations, the X11 server will estimate the + * affected rectangle and apply the operation to that. However, + * there are cases where this is an overestimate (e.g. the + * clip-fill-{eo,nz}-unbounded test). + * + * The clip will trim that overestimate to our expectations. + */ + if (! extents->is_bounded) + flags |= FORCE_CLIP_REGION; + + status = clip_and_composite (compositor, extents, + composite_traps, NULL, info, + need_unbounded_clip (extents) | flags); + } + + return status; +} + +static cairo_int_status_t +clip_and_composite_tristrip (const cairo_traps_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + composite_tristrip_info_t *info) +{ + cairo_int_status_t status; + unsigned int flags = 0; + + status = trim_extents_to_tristrip (extents, &info->strip); + if (unlikely (status != CAIRO_INT_STATUS_SUCCESS)) + return status; + + if (! extents->is_bounded) + flags |= FORCE_CLIP_REGION; + + status = clip_and_composite (compositor, extents, + composite_tristrip, NULL, info, + need_unbounded_clip (extents) | flags); + + return status; +} + +struct composite_mask { + cairo_surface_t *mask; + int mask_x, mask_y; +}; + +static cairo_int_status_t +composite_mask (const cairo_traps_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip) +{ + struct composite_mask *data = closure; + + if (src != NULL) { + compositor->composite (dst, op, src, data->mask, + extents->x + src_x, extents->y + src_y, + extents->x + data->mask_x, extents->y + data->mask_y, + extents->x - dst_x, extents->y - dst_y, + extents->width, extents->height); + } else { + compositor->composite (dst, op, data->mask, NULL, + extents->x + data->mask_x, extents->y + data->mask_y, + 0, 0, + extents->x - dst_x, extents->y - dst_y, + extents->width, extents->height); + } + + return CAIRO_STATUS_SUCCESS; +} + +struct composite_box_info { + const cairo_traps_compositor_t *compositor; + cairo_surface_t *dst; + cairo_surface_t *src; + int src_x, src_y; + uint8_t op; +}; + +static void composite_box(void *closure, + int16_t x, int16_t y, + int16_t w, int16_t h, + uint16_t coverage) +{ + struct composite_box_info *info = closure; + const cairo_traps_compositor_t *compositor = info->compositor; + + if (! CAIRO_ALPHA_SHORT_IS_OPAQUE (coverage)) { + cairo_surface_t *mask; + cairo_color_t color; + cairo_solid_pattern_t solid; + int mask_x, mask_y; + + _cairo_color_init_rgba (&color, 0, 0, 0, coverage / (double)0xffff); + _cairo_pattern_init_solid (&solid, &color); + + mask = compositor->pattern_to_surface (info->dst, &solid.base, FALSE, + &_cairo_unbounded_rectangle, + &_cairo_unbounded_rectangle, + &mask_x, &mask_y); + + if (likely (mask->status == CAIRO_STATUS_SUCCESS)) { + compositor->composite (info->dst, info->op, info->src, mask, + x + info->src_x, y + info->src_y, + mask_x, mask_y, + x, y, + w, h); + } + + cairo_surface_destroy (mask); + } else { + compositor->composite (info->dst, info->op, info->src, NULL, + x + info->src_x, y + info->src_y, + 0, 0, + x, y, + w, h); + } +} + +static cairo_int_status_t +composite_mask_clip_boxes (const cairo_traps_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip) +{ + struct composite_mask *data = closure; + struct composite_box_info info; + int i; + + info.compositor = compositor; + info.op = CAIRO_OPERATOR_SOURCE; + info.dst = dst; + info.src = data->mask; + info.src_x = data->mask_x; + info.src_y = data->mask_y; + + info.src_x += dst_x; + info.src_y += dst_y; + + for (i = 0; i < clip->num_boxes; i++) + do_unaligned_box(composite_box, &info, &clip->boxes[i], dst_x, dst_y); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_mask_clip (const cairo_traps_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip) +{ + struct composite_mask *data = closure; + cairo_polygon_t polygon; + cairo_fill_rule_t fill_rule; + composite_traps_info_t info; + cairo_status_t status; + + status = _cairo_clip_get_polygon (clip, &polygon, + &fill_rule, &info.antialias); + if (unlikely (status)) + return status; + + _cairo_traps_init (&info.traps); + status = _cairo_bentley_ottmann_tessellate_polygon (&info.traps, + &polygon, + fill_rule); + _cairo_polygon_fini (&polygon); + if (unlikely (status)) + return status; + + status = composite_traps (compositor, dst, &info, + CAIRO_OPERATOR_SOURCE, + data->mask, + data->mask_x + dst_x, data->mask_y + dst_y, + dst_x, dst_y, + extents, NULL); + _cairo_traps_fini (&info.traps); + + return status; +} + +/* high-level compositor interface */ + +static cairo_int_status_t +_cairo_traps_compositor_paint (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents) +{ + cairo_traps_compositor_t *compositor = (cairo_traps_compositor_t*)_compositor; + cairo_boxes_t boxes; + cairo_int_status_t status; + + _cairo_clip_steal_boxes (extents->clip, &boxes); + status = clip_and_composite_boxes (compositor, extents, &boxes); + _cairo_clip_unsteal_boxes (extents->clip, &boxes); + + return status; +} + +static cairo_int_status_t +_cairo_traps_compositor_mask (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents) +{ + const cairo_traps_compositor_t *compositor = (cairo_traps_compositor_t*)_compositor; + cairo_int_status_t status; + + if (extents->mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID && + extents->clip->path == NULL) { + status = clip_and_composite (compositor, extents, + composite_opacity_boxes, + composite_opacity_boxes, + &extents->mask_pattern, + need_unbounded_clip (extents)); + } else { + struct composite_mask data; + + data.mask = compositor->pattern_to_surface (extents->surface, + &extents->mask_pattern.base, + TRUE, + &extents->bounded, + &extents->mask_sample_area, + &data.mask_x, + &data.mask_y); + + status = clip_and_composite (compositor, extents, + composite_mask, + extents->clip->path ? composite_mask_clip : composite_mask_clip_boxes, + &data, need_bounded_clip (extents)); + + cairo_surface_destroy (data.mask); + } + + return status; +} + +static cairo_int_status_t +_cairo_traps_compositor_stroke (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + 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_traps_compositor_t *compositor = (cairo_traps_compositor_t *)_compositor; + cairo_int_status_t status; + + status = CAIRO_INT_STATUS_UNSUPPORTED; + if (_cairo_path_fixed_stroke_is_rectilinear (path)) { + cairo_boxes_t boxes; + + _cairo_boxes_init_with_clip (&boxes, extents->clip); + status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path, + style, + ctm, + antialias, + &boxes); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = clip_and_composite_boxes (compositor, extents, &boxes); + _cairo_boxes_fini (&boxes); + } + + if (status == CAIRO_INT_STATUS_UNSUPPORTED && 0 && + _cairo_clip_is_region (extents->clip)) /* XXX */ + { + composite_tristrip_info_t info; + + info.antialias = antialias; + _cairo_tristrip_init_with_clip (&info.strip, extents->clip); + status = _cairo_path_fixed_stroke_to_tristrip (path, style, + ctm, ctm_inverse, + tolerance, + &info.strip); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = clip_and_composite_tristrip (compositor, extents, &info); + _cairo_tristrip_fini (&info.strip); + } + + if (status == CAIRO_INT_STATUS_UNSUPPORTED) { + composite_traps_info_t info; + + info.antialias = antialias; + _cairo_traps_init_with_clip (&info.traps, extents->clip); + status = _cairo_path_fixed_stroke_to_traps (path, style, + ctm, ctm_inverse, + tolerance, + &info.traps); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = clip_and_composite_traps (compositor, extents, &info); + _cairo_traps_fini (&info.traps); + } + + return status; +} + +static cairo_int_status_t +_cairo_traps_compositor_fill (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + cairo_antialias_t antialias) +{ + const cairo_traps_compositor_t *compositor = (cairo_traps_compositor_t *)_compositor; + cairo_int_status_t status; + + status = CAIRO_INT_STATUS_UNSUPPORTED; + if (_cairo_path_fixed_fill_is_rectilinear (path)) { + cairo_boxes_t boxes; + + _cairo_boxes_init_with_clip (&boxes, extents->clip); + status = _cairo_path_fixed_fill_rectilinear_to_boxes (path, + fill_rule, + antialias, + &boxes); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = clip_and_composite_boxes (compositor, extents, &boxes); + _cairo_boxes_fini (&boxes); + } + + if (status == CAIRO_INT_STATUS_UNSUPPORTED) { + cairo_polygon_t polygon; + +#if 0 + if (extents->mask.width > extents->unbounded.width || + extents->mask.height > extents->unbounded.height) + { + cairo_box_t limits; + _cairo_box_from_rectangle (&limits, &extents->unbounded); + _cairo_polygon_init (&polygon, &limits, 1); + } + else + { + _cairo_polygon_init (&polygon, NULL, 0); + } + + status = _cairo_path_fixed_fill_to_polygon (path, tolerance, &polygon); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + status = _cairo_polygon_intersect_with_boxes (&polygon, &fill_rule, + extents->clip->boxes, + extents->clip->num_boxes); + } +#else + _cairo_polygon_init_with_clip (&polygon, extents->clip); + status = _cairo_path_fixed_fill_to_polygon (path, tolerance, &polygon); +#endif + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + status = clip_and_composite_polygon (compositor, extents, &polygon, + antialias, fill_rule); + } + _cairo_polygon_fini (&polygon); + } + + return status; +} + +static cairo_int_status_t +composite_glyphs (const cairo_traps_compositor_t *compositor, + cairo_surface_t *dst, + void *closure, + cairo_operator_t op, + cairo_surface_t *src, + int src_x, int src_y, + int dst_x, int dst_y, + const cairo_rectangle_int_t *extents, + cairo_clip_t *clip) +{ + cairo_composite_glyphs_info_t *info = closure; + + if (op == CAIRO_OPERATOR_ADD && (dst->content & CAIRO_CONTENT_COLOR) == 0) + info->use_mask = 0; + + return compositor->composite_glyphs (dst, op, src, + src_x, src_y, + dst_x, dst_y, + info); +} + +static cairo_int_status_t +_cairo_traps_compositor_glyphs (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *scaled_font, + cairo_glyph_t *glyphs, + int num_glyphs, + cairo_bool_t overlap) +{ + const cairo_traps_compositor_t *compositor = (cairo_traps_compositor_t *)_compositor; + cairo_int_status_t status; + + _cairo_scaled_font_freeze_cache (scaled_font); + status = compositor->check_composite_glyphs (extents, + scaled_font, glyphs, + &num_glyphs); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + cairo_composite_glyphs_info_t info; + unsigned flags = 0; + + info.font = scaled_font; + info.glyphs = glyphs; + info.num_glyphs = num_glyphs; + info.use_mask = overlap || ! extents->is_bounded; + info.extents = extents->bounded; + + if (extents->mask.width > extents->bounded.width || + extents->mask.height > extents->bounded.height) + { + flags |= FORCE_CLIP_REGION; + } + + status = clip_and_composite (compositor, extents, + composite_glyphs, NULL, &info, + need_bounded_clip (extents) | + flags); + } + _cairo_scaled_font_thaw_cache (scaled_font); + + return status; +} + +void +_cairo_traps_compositor_init (cairo_traps_compositor_t *compositor, + const cairo_compositor_t *delegate) +{ + compositor->base.delegate = delegate; + + compositor->base.paint = _cairo_traps_compositor_paint; + compositor->base.mask = _cairo_traps_compositor_mask; + compositor->base.fill = _cairo_traps_compositor_fill; + compositor->base.stroke = _cairo_traps_compositor_stroke; + compositor->base.glyphs = _cairo_traps_compositor_glyphs; +} diff --git a/src/cairo-traps-private.h b/src/cairo-traps-private.h new file mode 100644 index 00000000..5b17719f --- /dev/null +++ b/src/cairo-traps-private.h @@ -0,0 +1,126 @@ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it either under the terms of the GNU Lesser General Public + * License version 2.1 as published by the Free Software Foundation + * (the "LGPL") or, at your option, under the terms of the Mozilla + * Public License Version 1.1 (the "MPL"). If you do not alter this + * notice, a recipient may use your version of this file under either + * the MPL or the LGPL. + * + * You should have received a copy of the LGPL along with this library + * in the file COPYING-LGPL-2.1; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA + * You should have received a copy of the MPL along with this library + * in the file COPYING-MPL-1.1 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + */ + +#ifndef CAIRO_TRAPS_PRIVATE_H +#define CAIRO_TRAPS_PRIVATE_H + +#include "cairo-compiler-private.h" +#include "cairo-error-private.h" +#include "cairo-types-private.h" + +CAIRO_BEGIN_DECLS + +struct _cairo_traps { + cairo_status_t status; + + const cairo_box_t *limits; + int num_limits; + + unsigned int maybe_region : 1; /* hint: 0 implies that it cannot be */ + unsigned int has_intersections : 1; + unsigned int is_rectilinear : 1; + unsigned int is_rectangular : 1; + + int num_traps; + int traps_size; + cairo_trapezoid_t *traps; + cairo_trapezoid_t traps_embedded[16]; +}; + +/* cairo-traps.c */ +cairo_private void +_cairo_traps_init (cairo_traps_t *traps); + +cairo_private void +_cairo_traps_init_with_clip (cairo_traps_t *traps, + const cairo_clip_t *clip); + +cairo_private void +_cairo_traps_limit (cairo_traps_t *traps, + const cairo_box_t *boxes, + int num_boxes); + +cairo_private cairo_status_t +_cairo_traps_init_boxes (cairo_traps_t *traps, + const cairo_boxes_t *boxes); + +cairo_private void +_cairo_traps_clear (cairo_traps_t *traps); + +cairo_private void +_cairo_traps_fini (cairo_traps_t *traps); + +#define _cairo_traps_status(T) (T)->status + +cairo_private void +_cairo_traps_translate (cairo_traps_t *traps, int x, int y); + +cairo_private cairo_status_t +_cairo_traps_tessellate_rectangle (cairo_traps_t *traps, + const cairo_point_t *top_left, + const cairo_point_t *bottom_right); + +cairo_private void +_cairo_traps_add_trap (cairo_traps_t *traps, + cairo_fixed_t top, cairo_fixed_t bottom, + cairo_line_t *left, cairo_line_t *right); + +cairo_private int +_cairo_traps_contain (const cairo_traps_t *traps, + double x, double y); + +cairo_private void +_cairo_traps_extents (const cairo_traps_t *traps, + cairo_box_t *extents); + +cairo_private cairo_int_status_t +_cairo_traps_extract_region (cairo_traps_t *traps, + cairo_antialias_t antialias, + cairo_region_t **region); + +cairo_private cairo_bool_t +_cairo_traps_to_boxes (cairo_traps_t *traps, + cairo_antialias_t antialias, + cairo_boxes_t *boxes); + +cairo_private cairo_status_t +_cairo_traps_path (const cairo_traps_t *traps, + cairo_path_fixed_t *path); + +CAIRO_END_DECLS + +#endif /* CAIRO_TRAPS_PRIVATE_H */ diff --git a/src/cairo-traps.c b/src/cairo-traps.c index 42e2eb55..a6e7f94e 100644 --- a/src/cairo-traps.c +++ b/src/cairo-traps.c @@ -43,6 +43,7 @@ #include "cairo-error-private.h" #include "cairo-region-private.h" #include "cairo-slope-private.h" +#include "cairo-traps-private.h" /* private functions */ @@ -608,6 +609,66 @@ _cairo_traps_extract_region (cairo_traps_t *traps, return status; } +cairo_bool_t +_cairo_traps_to_boxes (cairo_traps_t *traps, + cairo_antialias_t antialias, + cairo_boxes_t *boxes) +{ + int i; + + for (i = 0; i < traps->num_traps; i++) { + if (traps->traps[i].left.p1.x != traps->traps[i].left.p2.x || + traps->traps[i].right.p1.x != traps->traps[i].right.p2.x) + return FALSE; + } + + _cairo_boxes_init (boxes); + + boxes->num_boxes = traps->num_traps; + boxes->chunks.base = (cairo_box_t *) traps->traps; + boxes->chunks.count = traps->num_traps; + boxes->chunks.size = traps->num_traps; + + if (antialias != CAIRO_ANTIALIAS_NONE) { + for (i = 0; i < traps->num_traps; i++) { + /* Note the traps and boxes alias so we need to take the local copies first. */ + cairo_fixed_t x1 = traps->traps[i].left.p1.x; + cairo_fixed_t x2 = traps->traps[i].right.p1.x; + cairo_fixed_t y1 = traps->traps[i].top; + cairo_fixed_t y2 = traps->traps[i].bottom; + + boxes->chunks.base[i].p1.x = x1; + boxes->chunks.base[i].p1.y = y1; + boxes->chunks.base[i].p2.x = x2; + boxes->chunks.base[i].p2.y = y2; + + if (boxes->is_pixel_aligned) { + boxes->is_pixel_aligned = + _cairo_fixed_is_integer (x1) && _cairo_fixed_is_integer (y1) && + _cairo_fixed_is_integer (x2) && _cairo_fixed_is_integer (y2); + } + } + } else { + boxes->is_pixel_aligned = TRUE; + + for (i = 0; i < traps->num_traps; i++) { + /* Note the traps and boxes alias so we need to take the local copies first. */ + cairo_fixed_t x1 = traps->traps[i].left.p1.x; + cairo_fixed_t x2 = traps->traps[i].right.p1.x; + cairo_fixed_t y1 = traps->traps[i].top; + cairo_fixed_t y2 = traps->traps[i].bottom; + + /* round down here to match Pixman's behavior when using traps. */ + boxes->chunks.base[i].p1.x = _cairo_fixed_round_down (x1); + boxes->chunks.base[i].p1.y = _cairo_fixed_round_down (y1); + boxes->chunks.base[i].p2.x = _cairo_fixed_round_down (x2); + boxes->chunks.base[i].p2.y = _cairo_fixed_round_down (y2); + } + } + + return TRUE; +} + /* moves trap points such that they become the actual corners of the trapezoid */ static void _sanitize_trap (cairo_trapezoid_t *t) diff --git a/src/cairo-tristrip-private.h b/src/cairo-tristrip-private.h new file mode 100644 index 00000000..ccd28799 --- /dev/null +++ b/src/cairo-tristrip-private.h @@ -0,0 +1,94 @@ +/* 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#ifndef CAIRO_TRISTRIP_PRIVATE_H +#define CAIRO_TRISTRIP_PRIVATE_H + +#include "cairo-compiler-private.h" +#include "cairo-error-private.h" +#include "cairo-types-private.h" + +CAIRO_BEGIN_DECLS + +struct _cairo_tristrip { + cairo_status_t status; + + /* XXX clipping */ + + const cairo_box_t *limits; + int num_limits; + + int num_points; + int size_points; + cairo_point_t *points; + cairo_point_t points_embedded[64]; +}; + +cairo_private void +_cairo_tristrip_init (cairo_tristrip_t *strip); + +cairo_private void +_cairo_tristrip_limit (cairo_tristrip_t *strip, + const cairo_box_t *limits, + int num_limits); + +cairo_private void +_cairo_tristrip_init_with_clip (cairo_tristrip_t *strip, + const cairo_clip_t *clip); + +cairo_private void +_cairo_tristrip_translate (cairo_tristrip_t *strip, int x, int y); + +cairo_private void +_cairo_tristrip_move_to (cairo_tristrip_t *strip, + const cairo_point_t *point); + +cairo_private void +_cairo_tristrip_add_point (cairo_tristrip_t *strip, + const cairo_point_t *point); + +cairo_private void +_cairo_tristrip_extents (const cairo_tristrip_t *strip, + cairo_box_t *extents); + +cairo_private void +_cairo_tristrip_fini (cairo_tristrip_t *strip); + +#define _cairo_tristrip_status(T) ((T)->status) + +CAIRO_END_DECLS + +#endif /* CAIRO_TRISTRIP_PRIVATE_H */ diff --git a/src/cairo-tristrip.c b/src/cairo-tristrip.c new file mode 100644 index 00000000..bb4972f5 --- /dev/null +++ b/src/cairo-tristrip.c @@ -0,0 +1,185 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is Chris Wilson + * + * Contributor(s): + * Chris Wilson <chris@chris-wilsonc.co.uk> + */ + +#include "cairoint.h" + +#include "cairo-error-private.h" +#include "cairo-tristrip-private.h" + +void +_cairo_tristrip_init (cairo_tristrip_t *strip) +{ + VG (VALGRIND_MAKE_MEM_UNDEFINED (strip, sizeof (cairo_tristrip_t))); + + strip->status = CAIRO_STATUS_SUCCESS; + + strip->num_limits = 0; + strip->num_points = 0; + + strip->size_points = ARRAY_LENGTH (strip->points_embedded); + strip->points = strip->points_embedded; +} + +void +_cairo_tristrip_fini (cairo_tristrip_t *strip) +{ + if (strip->points != strip->points_embedded) + free (strip->points); + + VG (VALGRIND_MAKE_MEM_NOACCESS (strip, sizeof (cairo_tristrip_t))); +} + + +void +_cairo_tristrip_limit (cairo_tristrip_t *strip, + const cairo_box_t *limits, + int num_limits) +{ + strip->limits = limits; + strip->num_limits = num_limits; +} + +void +_cairo_tristrip_init_with_clip (cairo_tristrip_t *strip, + const cairo_clip_t *clip) +{ + _cairo_tristrip_init (strip); + if (clip) + _cairo_tristrip_limit (strip, clip->boxes, clip->num_boxes); +} + +/* make room for at least one more trap */ +static cairo_bool_t +_cairo_tristrip_grow (cairo_tristrip_t *strip) +{ + cairo_point_t *points; + int new_size = 4 * strip->size_points; + + if (CAIRO_INJECT_FAULT ()) { + strip->status = _cairo_error (CAIRO_STATUS_NO_MEMORY); + return FALSE; + } + + if (strip->points == strip->points_embedded) { + points = _cairo_malloc_ab (new_size, sizeof (cairo_point_t)); + if (points != NULL) + memcpy (points, strip->points, sizeof (strip->points_embedded)); + } else { + points = _cairo_realloc_ab (strip->points, + new_size, sizeof (cairo_trapezoid_t)); + } + + if (unlikely (points == NULL)) { + strip->status = _cairo_error (CAIRO_STATUS_NO_MEMORY); + return FALSE; + } + + strip->points = points; + strip->size_points = new_size; + return TRUE; +} + +void +_cairo_tristrip_add_point (cairo_tristrip_t *strip, + const cairo_point_t *p) +{ + if (unlikely (strip->num_points == strip->size_points)) { + if (unlikely (! _cairo_tristrip_grow (strip))) + return; + } + + strip->points[strip->num_points++] = *p; +} + +/* Insert degenerate triangles to advance to the given point. The + * next point inserted must also be @p. */ +void +_cairo_tristrip_move_to (cairo_tristrip_t *strip, + const cairo_point_t *p) +{ + if (strip->num_points == 0) + return; + + _cairo_tristrip_add_point (strip, &strip->points[strip->num_points-1]); + _cairo_tristrip_add_point (strip, p); +#if 0 + /* and one more for luck! (to preserve cw/ccw ordering) */ + _cairo_tristrip_add_point (strip, p); +#endif +} + +void +_cairo_tristrip_translate (cairo_tristrip_t *strip, int x, int y) +{ + cairo_fixed_t xoff, yoff; + cairo_point_t *p; + int i; + + xoff = _cairo_fixed_from_int (x); + yoff = _cairo_fixed_from_int (y); + + for (i = 0, p = strip->points; i < strip->num_points; i++, p++) { + p->x += xoff; + p->y += yoff; + } +} + +void +_cairo_tristrip_extents (const cairo_tristrip_t *strip, + cairo_box_t *extents) +{ + int i; + + if (strip->num_points == 0) { + extents->p1.x = extents->p1.y = 0; + extents->p2.x = extents->p2.y = 0; + return; + } + + extents->p2 = extents->p1 = strip->points[0]; + for (i = 1; i < strip->num_points; i++) { + const cairo_point_t *p = &strip->points[i]; + + if (p->x < extents->p1.x) + extents->p1.x = p->x; + else if (p->x > extents->p2.x) + extents->p2.x = p->x; + + if (p->y < extents->p1.y) + extents->p1.y = p->y; + else if (p->y > extents->p2.y) + extents->p2.y = p->y; + } +} diff --git a/src/cairo-truetype-subset.c b/src/cairo-truetype-subset.c index 88c4ee36..d0d6ab7f 100644 --- a/src/cairo-truetype-subset.c +++ b/src/cairo-truetype-subset.c @@ -42,6 +42,8 @@ #define _BSD_SOURCE /* for snprintf(), strdup() */ #include "cairoint.h" + +#include "cairo-array-private.h" #include "cairo-error-private.h" #if CAIRO_HAS_FONT_SUBSET diff --git a/src/cairo-type1-fallback.c b/src/cairo-type1-fallback.c index 5284cfed..4a657413 100644 --- a/src/cairo-type1-fallback.c +++ b/src/cairo-type1-fallback.c @@ -35,6 +35,8 @@ #define _BSD_SOURCE /* for snprintf(), strdup() */ #include "cairoint.h" + +#include "cairo-array-private.h" #include "cairo-error-private.h" #if CAIRO_HAS_FONT_SUBSET diff --git a/src/cairo-type1-subset.c b/src/cairo-type1-subset.c index a637e24f..efe3028a 100644 --- a/src/cairo-type1-subset.c +++ b/src/cairo-type1-subset.c @@ -41,6 +41,8 @@ #define _BSD_SOURCE /* for snprintf(), strdup() */ #include "cairoint.h" + +#include "cairo-array-private.h" #include "cairo-error-private.h" #if CAIRO_HAS_FONT_SUBSET diff --git a/src/cairo-type3-glyph-surface.c b/src/cairo-type3-glyph-surface.c index 07554154..ee2d0e34 100644 --- a/src/cairo-type3-glyph-surface.c +++ b/src/cairo-type3-glyph-surface.c @@ -287,8 +287,7 @@ _cairo_type3_glyph_surface_show_glyphs (void *abstract_surface, cairo_glyph_t *glyphs, int num_glyphs, cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip, - int *remaining_glyphs) + const cairo_clip_t *clip) { cairo_type3_glyph_surface_t *surface = abstract_surface; cairo_int_status_t status; @@ -325,38 +324,32 @@ static const cairo_surface_backend_t cairo_type3_glyph_surface_backend = { CAIRO_INTERNAL_SURFACE_TYPE_TYPE3_GLYPH, _cairo_type3_glyph_surface_finish, - _cairo_default_context_create, + _cairo_default_context_create, /* XXX usable through a context? */ - NULL, /* _cairo_type3_glyph_surface_create_similar */ - NULL, /* _cairo_type3_glyph_surface_create_similar_image */ - NULL, /* _cairo_type3_glyph_surface_create_map_to_image */ - NULL, /* _cairo_type3_glyph_surface_create_unmap_image */ + NULL, /* create similar */ + NULL, /* create similar image */ + NULL, /* map to image */ + NULL, /* unmap image */ NULL, /* acquire_source_image */ NULL, /* release_source_image */ - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ - NULL, /* cairo_type3_glyph_surface_copy_page */ - NULL, /* _cairo_type3_glyph_surface_show_page */ + NULL, /* snapshot */ + + NULL, /* copy page */ + NULL, /* show page */ + NULL, /* _cairo_type3_glyph_surface_get_extents */ - NULL, /* old_show_glyphs */ NULL, /* _cairo_type3_glyph_surface_get_font_options */ + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ + _cairo_type3_glyph_surface_paint, _cairo_type3_glyph_surface_mask, _cairo_type3_glyph_surface_stroke, _cairo_type3_glyph_surface_fill, + NULL, /* fill-stroke */ _cairo_type3_glyph_surface_show_glyphs, - NULL, /* snapshot */ }; static void diff --git a/src/cairo-types-private.h b/src/cairo-types-private.h index f18a20ea..2fdd0a19 100644 --- a/src/cairo-types-private.h +++ b/src/cairo-types-private.h @@ -80,7 +80,6 @@ typedef struct _cairo_output_stream cairo_output_stream_t; typedef struct _cairo_paginated_surface_backend cairo_paginated_surface_backend_t; typedef struct _cairo_path_fixed cairo_path_fixed_t; typedef struct _cairo_rectangle_int16 cairo_glyph_size_t; -typedef struct _cairo_scaled_font_backend cairo_scaled_font_backend_t; typedef struct _cairo_scaled_font_subsets cairo_scaled_font_subsets_t; typedef struct _cairo_solid_pattern cairo_solid_pattern_t; typedef struct _cairo_surface_attributes cairo_surface_attributes_t; @@ -89,11 +88,24 @@ typedef struct _cairo_surface_observer cairo_surface_observer_t; typedef struct _cairo_surface_snapshot cairo_surface_snapshot_t; typedef struct _cairo_surface_subsurface cairo_surface_subsurface_t; typedef struct _cairo_surface_wrapper cairo_surface_wrapper_t; +typedef struct _cairo_traps cairo_traps_t; +typedef struct _cairo_tristrip cairo_tristrip_t; typedef struct _cairo_unscaled_font_backend cairo_unscaled_font_backend_t; typedef struct _cairo_xlib_screen_info cairo_xlib_screen_info_t; typedef cairo_array_t cairo_user_data_array_t; +typedef struct _cairo_scaled_font_private cairo_scaled_font_private_t; +typedef struct _cairo_scaled_font_backend cairo_scaled_font_backend_t; +typedef struct _cairo_scaled_glyph cairo_scaled_glyph_t; +typedef struct _cairo_scaled_glyph_private cairo_scaled_glyph_private_t; + +typedef struct cairo_compositor cairo_compositor_t; +typedef struct cairo_fallback_compositor cairo_fallback_compositor_t; +typedef struct cairo_mask_compositor cairo_mask_compositor_t; +typedef struct cairo_traps_compositor cairo_traps_compositor_t; +typedef struct cairo_spans_compositor cairo_spans_compositor_t; + struct _cairo_observer { cairo_list_t link; void (*callback) (cairo_observer_t *self, void *arg); @@ -248,8 +260,6 @@ typedef enum _cairo_internal_device_type { } cairo_device_surface_type_t; #define CAIRO_HAS_TEST_PAGINATED_SURFACE 1 -#define CAIRO_HAS_TEST_NULL_SURFACE 1 -#define CAIRO_HAS_TEST_WRAPPING_SURFACE 1 typedef struct _cairo_slope { cairo_fixed_t dx; @@ -413,24 +423,6 @@ typedef struct _cairo_unscaled_font { cairo_reference_count_t ref_count; const cairo_unscaled_font_backend_t *backend; } cairo_unscaled_font_t; - -typedef struct _cairo_scaled_glyph { - cairo_hash_entry_t hash_entry; - - cairo_text_extents_t metrics; /* user-space metrics */ - cairo_text_extents_t fs_metrics; /* font-space metrics */ - cairo_box_t bbox; /* device-space bounds */ - int16_t x_advance; /* device-space rounded X advance */ - int16_t y_advance; /* device-space rounded Y advance */ - - unsigned int has_info; - cairo_image_surface_t *surface; /* device-space image */ - cairo_path_fixed_t *path; /* device-space outline */ - cairo_surface_t *recording_surface; /* device-space recording-surface */ - - void *surface_private; /* for the surface backend */ -} cairo_scaled_glyph_t; - CAIRO_END_DECLS #endif /* CAIRO_TYPES_PRIVATE_H */ diff --git a/src/cairo-wideint-private.h b/src/cairo-wideint-private.h index f6ae5bcf..24c506a7 100644 --- a/src/cairo-wideint-private.h +++ b/src/cairo-wideint-private.h @@ -56,6 +56,9 @@ _cairo_uint64_divrem (cairo_uint64_t num, cairo_uint64_t den); cairo_uint64_t I _cairo_double_to_uint64 (double i); double I _cairo_uint64_to_double (uint64_t i); +cairo_int64_t I _cairo_double_to_int64 (double i); +double I _cairo_int64_to_double (uint64_t i); + cairo_uint64_t I _cairo_uint32_to_uint64 (uint32_t i); #define _cairo_uint64_to_uint32(a) ((a).lo) cairo_uint64_t I _cairo_uint64_add (cairo_uint64_t a, cairo_uint64_t b); @@ -115,6 +118,9 @@ _cairo_uint64_divrem (cairo_uint64_t num, cairo_uint64_t den) static cairo_always_inline cairo_const cairo_uint64_t _cairo_double_to_uint64 (double i) { return i; } static cairo_always_inline cairo_const double _cairo_uint64_to_double (cairo_uint64_t i) { return i; } +static cairo_always_inline cairo_int64_t I _cairo_double_to_int64 (double i) { return i; } +static cairo_always_inline double I _cairo_int64_to_double (cairo_int64_t i) { return i; } + #define _cairo_uint32_to_uint64(i) ((uint64_t) (i)) #define _cairo_uint64_to_uint32(i) ((uint32_t) (i)) #define _cairo_uint64_add(a,b) ((a) + (b)) diff --git a/src/cairo-wideint.c b/src/cairo-wideint.c index b6e22808..59af2c8c 100644 --- a/src/cairo-wideint.c +++ b/src/cairo-wideint.c @@ -99,6 +99,22 @@ _cairo_uint64_to_double (cairo_uint64_t i) return i.hi * 4294967296. + i.lo; } +cairo_int64_t +_cairo_double_to_int64 (double i) +{ + cairo_uint64_t q; + + q.hi = i * (1. / INT32_MAX); + q.lo = i - q.hi * (double)INT32_MAX; + return q; +} + +double +_cairo_int64_to_double (cairo_int64_t i) +{ + return i.hi * INT32_MAX + i.lo; +} + cairo_uint64_t _cairo_uint32_to_uint64 (uint32_t i) { diff --git a/src/cairo-win32-printing-surface.c b/src/cairo-win32-printing-surface.c index 99aca4a9..f6ce2028 100644 --- a/src/cairo-win32-printing-surface.c +++ b/src/cairo-win32-printing-surface.c @@ -56,6 +56,7 @@ #include "cairo-scaled-font-subsets-private.h" #include "cairo-image-info-private.h" #include "cairo-image-surface-private.h" +#include "cairo-surface-backend-private.h" #include "cairo-surface-clipper-private.h" #include <windows.h> @@ -1873,21 +1874,17 @@ static const cairo_surface_backend_t cairo_win32_printing_surface_backend = { NULL, /* acquire_source_image */ NULL, /* release_source_image */ - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + NULL, /* snapshot */ + NULL, /* copy_page */ _cairo_win32_printing_surface_show_page, + _cairo_win32_surface_get_extents, - NULL, /* old_show_glyphs */ _cairo_win32_printing_surface_get_font_options, + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ + NULL, /* scaled_font_fini */ NULL, /* scaled_glyph_fini */ @@ -1895,10 +1892,8 @@ static const cairo_surface_backend_t cairo_win32_printing_surface_backend = { NULL, /* mask */ _cairo_win32_printing_surface_stroke, _cairo_win32_printing_surface_fill, + NULL, /* fill/stroke */ _cairo_win32_printing_surface_show_glyphs, - NULL, /* snapshot */ - NULL, /* is_similar */ - NULL, /* fill_stroke */ }; static const cairo_paginated_surface_backend_t cairo_win32_surface_paginated_backend = { diff --git a/src/cairo-win32-surface.c b/src/cairo-win32-surface.c index b1d1c616..274df3ff 100644 --- a/src/cairo-win32-surface.c +++ b/src/cairo-win32-surface.c @@ -2213,7 +2213,7 @@ _cairo_win32_save_initial_clip (HDC hdc, cairo_win32_surface_t *surface) * set. GetClipBox returns values in logical (transformed) coordinates; * it's unclear what GetClipRgn returns, because the region is empty in the * case of a SIMPLEREGION clip, but I assume device (untransformed) coordinates. - * Similarily, IntersectClipRect works in logical units, whereas SelectClipRgn + * Similarly, IntersectClipRect works in logical units, whereas SelectClipRgn * works in device units. * * So, avoid the whole mess and get rid of the world transform diff --git a/src/cairo-xcb-connection.c b/src/cairo-xcb-connection.c index b2526484..2808395e 100644 --- a/src/cairo-xcb-connection.c +++ b/src/cairo-xcb-connection.c @@ -527,7 +527,7 @@ _device_finish (void *device) font = cairo_list_first_entry (&connection->fonts, cairo_xcb_font_t, link); - _cairo_xcb_font_finish (font); + _cairo_xcb_font_close (font); } while (! cairo_list_is_empty (&connection->screens)) { diff --git a/src/cairo-xcb-private.h b/src/cairo-xcb-private.h index e87f0e88..9223d670 100644 --- a/src/cairo-xcb-private.h +++ b/src/cairo-xcb-private.h @@ -48,6 +48,7 @@ #include "cairo-mutex-private.h" #include "cairo-pattern-private.h" #include "cairo-reference-count-private.h" +#include "cairo-scaled-font-private.h" #include "cairo-spans-private.h" #include "cairo-surface-private.h" @@ -167,6 +168,7 @@ typedef struct _cairo_xcb_font_glyphset_info { } cairo_xcb_font_glyphset_info_t; struct _cairo_xcb_font { + cairo_scaled_font_private_t base; cairo_scaled_font_t *scaled_font; cairo_xcb_connection_t *connection; cairo_xcb_font_glyphset_info_t glyphset_info[NUM_GLYPHSETS]; @@ -321,7 +323,7 @@ cairo_private void _cairo_xcb_connection_shm_mem_pools_fini (cairo_xcb_connection_t *connection); cairo_private void -_cairo_xcb_font_finish (cairo_xcb_font_t *font); +_cairo_xcb_font_close (cairo_xcb_font_t *font); cairo_private cairo_xcb_screen_t * _cairo_xcb_screen_get (xcb_connection_t *connection, diff --git a/src/cairo-xcb-surface-core.c b/src/cairo-xcb-surface-core.c index c2885750..447529d5 100644 --- a/src/cairo-xcb-surface-core.c +++ b/src/cairo-xcb-surface-core.c @@ -34,6 +34,7 @@ #include "cairo-boxes-private.h" #include "cairo-xcb-private.h" #include "cairo-image-surface-private.h" +#include "cairo-surface-backend-private.h" /* XXX dithering */ diff --git a/src/cairo-xcb-surface-render.c b/src/cairo-xcb-surface-render.c index aa9100fc..f9d33c71 100644 --- a/src/cairo-xcb-surface-render.c +++ b/src/cairo-xcb-surface-render.c @@ -31,6 +31,8 @@ #include "cairoint.h" +#include "cairo-xcb-private.h" + #include "cairo-boxes-private.h" #include "cairo-clip-private.h" #include "cairo-composite-rectangles-private.h" @@ -39,7 +41,7 @@ #include "cairo-surface-offset-private.h" #include "cairo-surface-snapshot-private.h" #include "cairo-surface-subsurface-private.h" -#include "cairo-xcb-private.h" +#include "cairo-traps-private.h" #define PIXMAN_MAX_INT ((pixman_fixed_1 >> 1) - pixman_fixed_e) /* need to ensure deltas also fit */ @@ -2501,10 +2503,10 @@ _composite_boxes (cairo_xcb_surface_t *dst, return CAIRO_INT_STATUS_UNSUPPORTED; } - if (cairo_region_contains_rectangle (clip_region, &extents->bounded) == CAIRO_REGION_OVERLAP_IN) { - clip = NULL; + if (clip_region != NULL && + cairo_region_contains_rectangle (clip_region, + &extents->bounded) == CAIRO_REGION_OVERLAP_IN) clip_region = NULL; - } status = _cairo_xcb_connection_acquire (dst->connection); if (unlikely (status)) @@ -3396,7 +3398,6 @@ _cairo_xcb_surface_render_paint (cairo_xcb_surface_t *surface, const cairo_clip_t *clip) { cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_boxes_t boxes; cairo_status_t status; @@ -3427,18 +3428,16 @@ _cairo_xcb_surface_render_paint (cairo_xcb_surface_t *surface, return CAIRO_STATUS_SUCCESS; } - _cairo_xcb_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_paint (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_paint (&extents, + &surface->base, op, source, clip); if (unlikely (status)) return status; - status = _cairo_clip_to_boxes(extents.clip, &boxes); - if (likely (status == CAIRO_STATUS_SUCCESS)) { - status = _clip_and_composite_boxes (surface, op, source, - &boxes, &extents); - } + _cairo_clip_steal_boxes(extents.clip, &boxes); + status = _clip_and_composite_boxes (surface, op, source, &boxes, &extents); + _cairo_clip_unsteal_boxes (extents.clip, &boxes); _cairo_composite_rectangles_fini (&extents); @@ -3453,7 +3452,6 @@ _cairo_xcb_surface_render_mask (cairo_xcb_surface_t *surface, const cairo_clip_t *clip) { cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_status_t status; if (unlikely (! _operator_is_supported (surface->connection->flags, op))) @@ -3462,8 +3460,7 @@ _cairo_xcb_surface_render_mask (cairo_xcb_surface_t *surface, if ((surface->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE) == 0) return CAIRO_INT_STATUS_UNSUPPORTED; - _cairo_xcb_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_mask (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_mask (&extents, &surface->base, op, source, mask, clip); if (unlikely (status)) return status; @@ -3599,7 +3596,6 @@ _cairo_xcb_surface_render_stroke (cairo_xcb_surface_t *surface, const cairo_clip_t *clip) { cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_int_status_t status; if (unlikely (! _operator_is_supported (surface->connection->flags, op))) @@ -3611,8 +3607,8 @@ _cairo_xcb_surface_render_stroke (cairo_xcb_surface_t *surface, return CAIRO_INT_STATUS_UNSUPPORTED; } - _cairo_xcb_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_stroke (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_stroke (&extents, + &surface->base, op, source, path, style, ctm, clip); @@ -3750,7 +3746,6 @@ _cairo_xcb_surface_render_fill (cairo_xcb_surface_t *surface, const cairo_clip_t *clip) { cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_int_status_t status; if (unlikely (! _operator_is_supported (surface->connection->flags, op))) @@ -3762,8 +3757,7 @@ _cairo_xcb_surface_render_fill (cairo_xcb_surface_t *surface, return CAIRO_INT_STATUS_UNSUPPORTED; } - _cairo_xcb_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_fill (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_fill (&extents, &surface->base, op, source, path, clip); if (unlikely (status)) @@ -3916,7 +3910,7 @@ _can_composite_glyphs (cairo_xcb_surface_t *dst, valid_glyphs = glyphs; for (glyphs_end = glyphs + *num_glyphs; glyphs != glyphs_end; glyphs++) { double x1, y1, x2, y2; - cairo_scaled_glyph_t *scaled_glyph; + cairo_scaled_glyph_t *glyph; cairo_box_t *bbox; int width, height, len; int g; @@ -3926,12 +3920,12 @@ _can_composite_glyphs (cairo_xcb_surface_t *dst, status = _cairo_scaled_glyph_lookup (scaled_font, glyphs->index, CAIRO_SCALED_GLYPH_INFO_METRICS, - &scaled_glyph); + &glyph); if (unlikely (status)) break; glyph_cache[g] = glyphs->index; - bbox_cache[g] = scaled_glyph->bbox; + bbox_cache[g] = glyph->bbox; } bbox = &bbox_cache[g]; @@ -4013,170 +4007,115 @@ typedef struct { } x_glyph_elt_t; #define _cairo_sz_x_glyph_elt_t (sizeof (x_glyph_elt_t) + 4) -static cairo_xcb_font_glyphset_info_t * -_cairo_xcb_scaled_glyph_get_glyphset_info (cairo_scaled_glyph_t *scaled_glyph) -{ - return scaled_glyph->surface_private; -} - -static void -_cairo_xcb_scaled_glyph_set_glyphset_info (cairo_scaled_glyph_t *scaled_glyph, - cairo_xcb_font_glyphset_info_t *glyphset_info) -{ - scaled_glyph->surface_private = glyphset_info; -} - -static cairo_status_t -_cairo_xcb_surface_font_init (cairo_xcb_connection_t *connection, - cairo_scaled_font_t *scaled_font) -{ - cairo_xcb_font_t *font_private; - int i; - - font_private = malloc (sizeof (cairo_xcb_font_t)); - if (unlikely (font_private == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - font_private->scaled_font = scaled_font; - font_private->connection = _cairo_xcb_connection_reference (connection); - for (i = 0; i < NUM_GLYPHSETS; i++) { - cairo_xcb_font_glyphset_info_t *glyphset_info = &font_private->glyphset_info[i]; - switch (i) { - case GLYPHSET_INDEX_ARGB32: glyphset_info->format = CAIRO_FORMAT_ARGB32; break; - case GLYPHSET_INDEX_A8: glyphset_info->format = CAIRO_FORMAT_A8; break; - case GLYPHSET_INDEX_A1: glyphset_info->format = CAIRO_FORMAT_A1; break; - default: ASSERT_NOT_REACHED; break; - } - glyphset_info->xrender_format = 0; - glyphset_info->glyphset = XCB_NONE; - glyphset_info->pending_free_glyphs = NULL; - } - - scaled_font->surface_private = font_private; - scaled_font->surface_backend = &_cairo_xcb_surface_backend; - - cairo_list_add (&font_private->link, &connection->fonts); - - return CAIRO_STATUS_SUCCESS; -} - static void _cairo_xcb_font_destroy (cairo_xcb_font_t *font) { int i; for (i = 0; i < NUM_GLYPHSETS; i++) { - cairo_xcb_font_glyphset_info_t *glyphset_info; + cairo_xcb_font_glyphset_info_t *info; - glyphset_info = &font->glyphset_info[i]; - - free (glyphset_info->pending_free_glyphs); + info = &font->glyphset_info[i]; + free (info->pending_free_glyphs); } + cairo_list_del (&font->base.link); cairo_list_del (&font->link); + _cairo_xcb_connection_destroy (font->connection); free (font); } -void -_cairo_xcb_font_finish (cairo_xcb_font_t *font) -{ - cairo_scaled_font_t *scaled_font; - - scaled_font = font->scaled_font; - - CAIRO_MUTEX_LOCK (scaled_font->mutex); - scaled_font->surface_private = NULL; - _cairo_scaled_font_reset_cache (scaled_font); - CAIRO_MUTEX_UNLOCK (scaled_font->mutex); - - _cairo_xcb_font_destroy (font); -} - -void -_cairo_xcb_surface_scaled_font_fini (cairo_scaled_font_t *scaled_font) +static void +_cairo_xcb_font_fini (cairo_scaled_font_private_t *abstract_private, + cairo_scaled_font_t *scaled_font) { - cairo_xcb_font_t *font_private; + cairo_xcb_font_t *font_private = (cairo_xcb_font_t *)abstract_private; cairo_xcb_connection_t *connection; cairo_bool_t have_connection; cairo_status_t status; int i; - font_private = scaled_font->surface_private; - if (font_private == NULL) - return; - connection = font_private->connection; status = _cairo_xcb_connection_acquire (connection); have_connection = status == CAIRO_STATUS_SUCCESS; for (i = 0; i < NUM_GLYPHSETS; i++) { - cairo_xcb_font_glyphset_info_t *glyphset_info; + cairo_xcb_font_glyphset_info_t *info; - glyphset_info = &font_private->glyphset_info[i]; - if (glyphset_info->glyphset && status == CAIRO_STATUS_SUCCESS) { + info = &font_private->glyphset_info[i]; + if (info->glyphset && status == CAIRO_STATUS_SUCCESS) { _cairo_xcb_connection_render_free_glyph_set (connection, - glyphset_info->glyphset); + info->glyphset); } } if (have_connection) _cairo_xcb_connection_release (connection); - _cairo_xcb_font_destroy (font_private); } -static void -_cairo_xcb_render_free_glyphs (cairo_xcb_connection_t *connection, - cairo_xcb_font_glyphset_free_glyphs_t *to_free) -{ - _cairo_xcb_connection_render_free_glyphs (connection, - to_free->glyphset, - to_free->glyph_count, - to_free->glyph_indices); -} -void -_cairo_xcb_surface_scaled_glyph_fini (cairo_scaled_glyph_t *scaled_glyph, - cairo_scaled_font_t *scaled_font) +static cairo_xcb_font_t * +_cairo_xcb_font_create (cairo_xcb_connection_t *connection, + cairo_scaled_font_t *font) { - cairo_xcb_font_t *font_private; - cairo_xcb_font_glyphset_info_t *glyphset_info; + cairo_xcb_font_t *priv; + int i; - if (scaled_font->finished) - return; + priv = malloc (sizeof (cairo_xcb_font_t)); + if (unlikely (priv == NULL)) + return NULL; - font_private = scaled_font->surface_private; - glyphset_info = _cairo_xcb_scaled_glyph_get_glyphset_info (scaled_glyph); - if (font_private != NULL && glyphset_info != NULL) { - cairo_xcb_font_glyphset_free_glyphs_t *to_free; + _cairo_scaled_font_attach_private (font, &priv->base, connection, + _cairo_xcb_font_fini); - to_free = glyphset_info->pending_free_glyphs; - if (to_free != NULL && - to_free->glyph_count == ARRAY_LENGTH (to_free->glyph_indices)) - { - _cairo_xcb_render_free_glyphs (font_private->connection, to_free); - to_free = glyphset_info->pending_free_glyphs = NULL; + priv->scaled_font = font; + priv->connection = _cairo_xcb_connection_reference (connection); + cairo_list_add (&priv->link, &connection->fonts); + + for (i = 0; i < NUM_GLYPHSETS; i++) { + cairo_xcb_font_glyphset_info_t *info = &priv->glyphset_info[i]; + switch (i) { + case GLYPHSET_INDEX_ARGB32: info->format = CAIRO_FORMAT_ARGB32; break; + case GLYPHSET_INDEX_A8: info->format = CAIRO_FORMAT_A8; break; + case GLYPHSET_INDEX_A1: info->format = CAIRO_FORMAT_A1; break; + default: ASSERT_NOT_REACHED; break; } + info->xrender_format = 0; + info->glyphset = XCB_NONE; + info->pending_free_glyphs = NULL; + } - if (to_free == NULL) { - to_free = malloc (sizeof (cairo_xcb_font_glyphset_free_glyphs_t)); - if (unlikely (to_free == NULL)) { - _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); - return; /* XXX cannot propagate failure */ - } + return priv; +} - to_free->glyphset = glyphset_info->glyphset; - to_free->glyph_count = 0; - glyphset_info->pending_free_glyphs = to_free; - } +void +_cairo_xcb_font_close (cairo_xcb_font_t *font) +{ + cairo_scaled_font_t *scaled_font; - to_free->glyph_indices[to_free->glyph_count++] = - _cairo_scaled_glyph_index (scaled_glyph); - } + scaled_font = font->scaled_font; + + CAIRO_MUTEX_LOCK (scaled_font->mutex); + //scaled_font->surface_private = NULL; + _cairo_scaled_font_reset_cache (scaled_font); + CAIRO_MUTEX_UNLOCK (scaled_font->mutex); + + _cairo_xcb_font_destroy (font); +} + +static void +_cairo_xcb_render_free_glyphs (cairo_xcb_connection_t *connection, + cairo_xcb_font_glyphset_free_glyphs_t *to_free) +{ + _cairo_xcb_connection_render_free_glyphs (connection, + to_free->glyphset, + to_free->glyph_count, + to_free->glyph_indices); } static int @@ -4191,42 +4130,57 @@ _cairo_xcb_get_glyphset_index_for_format (cairo_format_t format) return GLYPHSET_INDEX_ARGB32; } + + +static inline cairo_xcb_font_t * +_cairo_xcb_font_get (const cairo_xcb_connection_t *c, + cairo_scaled_font_t *font) +{ + return (cairo_xcb_font_t *)_cairo_scaled_font_find_private (font, c); +} + + static cairo_xcb_font_glyphset_info_t * -_cairo_xcb_scaled_font_get_glyphset_info_for_format (cairo_scaled_font_t *scaled_font, +_cairo_xcb_scaled_font_get_glyphset_info_for_format (cairo_xcb_connection_t *c, + cairo_scaled_font_t *font, cairo_format_t format) { - cairo_xcb_font_t *font_private; - cairo_xcb_font_glyphset_info_t *glyphset_info; + cairo_xcb_font_t *priv; + cairo_xcb_font_glyphset_info_t *info; int glyphset_index; glyphset_index = _cairo_xcb_get_glyphset_index_for_format (format); - font_private = scaled_font->surface_private; - glyphset_info = &font_private->glyphset_info[glyphset_index]; - if (glyphset_info->glyphset == XCB_NONE) { - cairo_xcb_connection_t *connection = font_private->connection; - glyphset_info->glyphset = _cairo_xcb_connection_get_xid (font_private->connection); - glyphset_info->xrender_format = - connection->standard_formats[glyphset_info->format]; + priv = _cairo_xcb_font_get (c, font); + if (priv == NULL) { + priv = _cairo_xcb_font_create (c, font); + if (priv == NULL) + return NULL; + } + + info = &priv->glyphset_info[glyphset_index]; + if (info->glyphset == XCB_NONE) { + info->glyphset = _cairo_xcb_connection_get_xid (c); + info->xrender_format = c->standard_formats[info->format]; - _cairo_xcb_connection_render_create_glyph_set (font_private->connection, - glyphset_info->glyphset, - glyphset_info->xrender_format); + _cairo_xcb_connection_render_create_glyph_set (c, + info->glyphset, + info->xrender_format); } - return glyphset_info; + return info; } static cairo_bool_t _cairo_xcb_glyphset_info_has_pending_free_glyph ( - cairo_xcb_font_glyphset_info_t *glyphset_info, + cairo_xcb_font_glyphset_info_t *info, unsigned long glyph_index) { - if (glyphset_info->pending_free_glyphs != NULL) { + if (info->pending_free_glyphs != NULL) { cairo_xcb_font_glyphset_free_glyphs_t *to_free; int i; - to_free = glyphset_info->pending_free_glyphs; + to_free = info->pending_free_glyphs; for (i = 0; i < to_free->glyph_count; i++) { if (to_free->glyph_indices[i] == glyph_index) { to_free->glyph_count--; @@ -4241,44 +4195,115 @@ _cairo_xcb_glyphset_info_has_pending_free_glyph ( return FALSE; } +typedef struct { + cairo_scaled_glyph_private_t base; + + cairo_xcb_font_glyphset_info_t *glyphset; +} cairo_xcb_glyph_private_t; + static cairo_xcb_font_glyphset_info_t * -_cairo_xcb_scaled_font_get_glyphset_info_for_pending_free_glyph ( - cairo_scaled_font_t *scaled_font, +_cairo_xcb_scaled_font_get_glyphset_info_for_pending_free_glyph (cairo_xcb_connection_t *c, + cairo_scaled_font_t *font, unsigned long glyph_index, cairo_image_surface_t *surface) { - cairo_xcb_font_t *font_private; + cairo_xcb_font_t *priv; int i; - font_private = scaled_font->surface_private; - if (font_private == NULL) + priv = _cairo_xcb_font_get (c, font); + if (priv == NULL) return NULL; if (surface != NULL) { i = _cairo_xcb_get_glyphset_index_for_format (surface->format); if (_cairo_xcb_glyphset_info_has_pending_free_glyph ( - &font_private->glyphset_info[i], + &priv->glyphset_info[i], glyph_index)) { - return &font_private->glyphset_info[i]; + return &priv->glyphset_info[i]; } } else { for (i = 0; i < NUM_GLYPHSETS; i++) { if (_cairo_xcb_glyphset_info_has_pending_free_glyph ( - &font_private->glyphset_info[i], + &priv->glyphset_info[i], glyph_index)) { - return &font_private->glyphset_info[i]; + return &priv->glyphset_info[i]; } } } return NULL; } + +static void +_cairo_xcb_glyph_fini (cairo_scaled_glyph_private_t *glyph_private, + cairo_scaled_glyph_t *glyph, + cairo_scaled_font_t *font) +{ + cairo_xcb_glyph_private_t *priv = (cairo_xcb_glyph_private_t *)glyph_private; + + if (! font->finished) { + cairo_xcb_font_glyphset_info_t *info = priv->glyphset; + cairo_xcb_font_glyphset_free_glyphs_t *to_free; + cairo_xcb_font_t *font_private; + + font_private = _cairo_xcb_font_get (glyph_private->key, font); + assert (font_private); + + to_free = info->pending_free_glyphs; + if (to_free != NULL && + to_free->glyph_count == ARRAY_LENGTH (to_free->glyph_indices)) + { + _cairo_xcb_render_free_glyphs (font_private->connection, to_free); + to_free = info->pending_free_glyphs = NULL; + } + + if (to_free == NULL) { + to_free = malloc (sizeof (cairo_xcb_font_glyphset_free_glyphs_t)); + if (unlikely (to_free == NULL)) { + _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); + return; /* XXX cannot propagate failure */ + } + + to_free->glyphset = info->glyphset; + to_free->glyph_count = 0; + info->pending_free_glyphs = to_free; + } + + to_free->glyph_indices[to_free->glyph_count++] = + _cairo_scaled_glyph_index (glyph); + } + + cairo_list_del (&glyph_private->link); + free (glyph_private); +} + + +static cairo_status_t +_cairo_xcb_glyph_attach (cairo_xcb_connection_t *c, + cairo_scaled_glyph_t *glyph, + cairo_xcb_font_glyphset_info_t *info) +{ + cairo_xcb_glyph_private_t *priv; + + priv = malloc (sizeof (*priv)); + if (unlikely (priv == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + _cairo_scaled_glyph_attach_private (glyph, &priv->base, c, + _cairo_xcb_glyph_fini); + priv->glyphset = info; + + glyph->dev_private = info; + glyph->dev_private_key = c; + return CAIRO_STATUS_SUCCESS; +} + static cairo_status_t _cairo_xcb_surface_add_glyph (cairo_xcb_connection_t *connection, - cairo_scaled_font_t *scaled_font, + cairo_scaled_font_t *font, cairo_scaled_glyph_t **scaled_glyph_out) { xcb_render_glyphinfo_t glyph_info; @@ -4288,19 +4313,17 @@ _cairo_xcb_surface_add_glyph (cairo_xcb_connection_t *connection, cairo_scaled_glyph_t *scaled_glyph = *scaled_glyph_out; cairo_image_surface_t *glyph_surface = scaled_glyph->surface; cairo_bool_t already_had_glyph_surface; - cairo_xcb_font_glyphset_info_t *glyphset_info; + cairo_xcb_font_glyphset_info_t *info; glyph_index = _cairo_scaled_glyph_index (scaled_glyph); /* check to see if we have a pending XRenderFreeGlyph for this glyph */ - glyphset_info = _cairo_xcb_scaled_font_get_glyphset_info_for_pending_free_glyph (scaled_font, glyph_index, glyph_surface); - if (glyphset_info != NULL) { - _cairo_xcb_scaled_glyph_set_glyphset_info (scaled_glyph, glyphset_info); - return CAIRO_STATUS_SUCCESS; - } + info = _cairo_xcb_scaled_font_get_glyphset_info_for_pending_free_glyph (connection, font, glyph_index, glyph_surface); + if (info != NULL) + return _cairo_xcb_glyph_attach (connection, scaled_glyph, info); if (glyph_surface == NULL) { - status = _cairo_scaled_glyph_lookup (scaled_font, + status = _cairo_scaled_glyph_lookup (font, glyph_index, CAIRO_SCALED_GLYPH_INFO_METRICS | CAIRO_SCALED_GLYPH_INFO_SURFACE, @@ -4315,22 +4338,22 @@ _cairo_xcb_surface_add_glyph (cairo_xcb_connection_t *connection, already_had_glyph_surface = TRUE; } - if (scaled_font->surface_private == NULL) { - status = _cairo_xcb_surface_font_init (connection, scaled_font); - if (unlikely (status)) - return status; + info = _cairo_xcb_scaled_font_get_glyphset_info_for_format (connection, + font, + glyph_surface->format); + if (unlikely (info == NULL)) { + status = _cairo_error (CAIRO_STATUS_NO_MEMORY); + goto BAIL; } - glyphset_info = _cairo_xcb_scaled_font_get_glyphset_info_for_format (scaled_font, - glyph_surface->format); - +#if 0 /* If the glyph surface has zero height or width, we create * a clear 1x1 surface, to avoid various X server bugs. */ if (glyph_surface->width == 0 || glyph_surface->height == 0) { cairo_surface_t *tmp_surface; - tmp_surface = cairo_image_surface_create (glyphset_info->format, 1, 1); + tmp_surface = cairo_image_surface_create (info->format, 1, 1); status = tmp_surface->status; if (unlikely (status)) goto BAIL; @@ -4340,14 +4363,15 @@ _cairo_xcb_surface_add_glyph (cairo_xcb_connection_t *connection, glyph_surface = (cairo_image_surface_t *) tmp_surface; } +#endif /* If the glyph format does not match the font format, then we * create a temporary surface for the glyph image with the font's * format. */ - if (glyph_surface->format != glyphset_info->format) { + if (glyph_surface->format != info->format) { glyph_surface = _cairo_image_surface_coerce_to_format (glyph_surface, - glyphset_info->format); + info->format); status = glyph_surface->base.status; if (unlikely (status)) goto BAIL; @@ -4423,7 +4447,7 @@ _cairo_xcb_surface_add_glyph (cairo_xcb_connection_t *connection, /* XXX assume X server wants pixman padding. Xft assumes this as well */ _cairo_xcb_connection_render_add_glyphs (connection, - glyphset_info->glyphset, + info->glyphset, 1, &glyph_index, &glyph_info, glyph_surface->stride * glyph_surface->height, data); @@ -4431,7 +4455,7 @@ _cairo_xcb_surface_add_glyph (cairo_xcb_connection_t *connection, if (data != glyph_surface->data) free (data); - _cairo_xcb_scaled_glyph_set_glyphset_info (scaled_glyph, glyphset_info); + status = _cairo_xcb_glyph_attach (connection, scaled_glyph, info); BAIL: if (glyph_surface != scaled_glyph->surface) @@ -4444,7 +4468,7 @@ _cairo_xcb_surface_add_glyph (cairo_xcb_connection_t *connection, * the cache */ if (! already_had_glyph_surface) - _cairo_scaled_glyph_set_surface (scaled_glyph, scaled_font, NULL); + _cairo_scaled_glyph_set_surface (scaled_glyph, font, NULL); return status; } @@ -4471,7 +4495,7 @@ _emit_glyphs_chunk (cairo_xcb_surface_t *dst, int num_glyphs, int width, int estimated_req_size, - cairo_xcb_font_glyphset_info_t *glyphset_info, + cairo_xcb_font_glyphset_info_t *info, xcb_render_pictformat_t mask_format) { cairo_xcb_render_composite_text_func_t composite_text_func; @@ -4529,7 +4553,7 @@ _emit_glyphs_chunk (cairo_xcb_surface_t *dst, src->picture, dst->picture, mask_format, - glyphset_info->glyphset, + info->glyphset, src->x + glyphs[0].i.x, src->y + glyphs[0].i.y, len, buf); @@ -4577,43 +4601,43 @@ _composite_glyphs (void *closure, memset (glyph_cache, 0, sizeof (glyph_cache)); for (i = 0; i < info->num_glyphs; i++) { - cairo_scaled_glyph_t *scaled_glyph; + cairo_scaled_glyph_t *glyph; unsigned long glyph_index = info->glyphs[i].index; int cache_index = glyph_index % ARRAY_LENGTH (glyph_cache); int old_width = width; int this_x, this_y; - scaled_glyph = glyph_cache[cache_index]; - if (scaled_glyph == NULL || - _cairo_scaled_glyph_index (scaled_glyph) != glyph_index) + glyph = glyph_cache[cache_index]; + if (glyph == NULL || + _cairo_scaled_glyph_index (glyph) != glyph_index) { status = _cairo_scaled_glyph_lookup (info->font, glyph_index, CAIRO_SCALED_GLYPH_INFO_METRICS, - &scaled_glyph); + &glyph); if (unlikely (status)) { cairo_surface_destroy (&src->base); return status; } /* Send unseen glyphs to the server */ - if (_cairo_xcb_scaled_glyph_get_glyphset_info (scaled_glyph) == NULL) { + if (glyph->dev_private_key != dst->connection) { status = _cairo_xcb_surface_add_glyph (dst->connection, info->font, - &scaled_glyph); + &glyph); if (unlikely (status)) { cairo_surface_destroy (&src->base); return status; } } - glyph_cache[cache_index] = scaled_glyph; + glyph_cache[cache_index] = glyph; } this_x = _cairo_lround (info->glyphs[i].d.x) - dst_x; this_y = _cairo_lround (info->glyphs[i].d.y) - dst_y; - this_glyphset_info = _cairo_xcb_scaled_glyph_get_glyphset_info (scaled_glyph); + this_glyphset_info = glyph->dev_private; if (glyphset_info == NULL) glyphset_info = this_glyphset_info; @@ -4689,8 +4713,8 @@ _composite_glyphs (void *closure, request_size += _cairo_sz_x_glyph_elt_t; /* adjust current-position */ - x = this_x + scaled_glyph->x_advance; - y = this_y + scaled_glyph->y_advance; + x = this_x + glyph->x_advance; + y = this_y + glyph->y_advance; request_size += width; } @@ -4708,23 +4732,6 @@ _composite_glyphs (void *closure, return status; } -static cairo_bool_t -_surface_owns_font (cairo_xcb_surface_t *dst, - cairo_scaled_font_t *scaled_font) -{ - cairo_xcb_font_t *font_private; - - font_private = scaled_font->surface_private; - if ((scaled_font->surface_backend != NULL && - scaled_font->surface_backend != dst->base.backend) || - (font_private != NULL && font_private->connection != dst->connection)) - { - return FALSE; - } - - return TRUE; -} - cairo_int_status_t _cairo_xcb_surface_render_glyphs (cairo_xcb_surface_t *surface, cairo_operator_t op, @@ -4735,7 +4742,6 @@ _cairo_xcb_surface_render_glyphs (cairo_xcb_surface_t *surface, const cairo_clip_t *clip) { cairo_composite_rectangles_t extents; - cairo_rectangle_int_t unbounded; cairo_int_status_t status; cairo_bool_t overlap; @@ -4745,8 +4751,7 @@ _cairo_xcb_surface_render_glyphs (cairo_xcb_surface_t *surface, if ((surface->connection->flags & (CAIRO_XCB_RENDER_HAS_COMPOSITE_GLYPHS | CAIRO_XCB_RENDER_HAS_COMPOSITE)) == 0) return CAIRO_INT_STATUS_UNSUPPORTED; - _cairo_xcb_surface_get_extents (surface, &unbounded); - status = _cairo_composite_rectangles_init_for_glyphs (&extents, &unbounded, + status = _cairo_composite_rectangles_init_for_glyphs (&extents, &surface->base, op, source, scaled_font, glyphs, num_glyphs, @@ -4755,40 +4760,38 @@ _cairo_xcb_surface_render_glyphs (cairo_xcb_surface_t *surface, return status; status = CAIRO_INT_STATUS_UNSUPPORTED; - if (surface->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE_GLYPHS) { + if (surface->connection->flags & CAIRO_XCB_RENDER_HAS_COMPOSITE_GLYPHS && 0) { _cairo_scaled_font_freeze_cache (scaled_font); - if (_surface_owns_font (surface, scaled_font)) { - status = _can_composite_glyphs (surface, &extents.bounded, - scaled_font, glyphs, &num_glyphs); - if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { - composite_glyphs_info_t info; - unsigned flags = 0; - - info.font = scaled_font; - info.glyphs = (cairo_xcb_glyph_t *) glyphs; - info.num_glyphs = num_glyphs; - info.use_mask = - overlap || - ! extents.is_bounded || - ! _cairo_clip_is_region(extents.clip); - - if (extents.mask.width > extents.unbounded.width || - extents.mask.height > extents.unbounded.height) - { - /* Glyphs are tricky since we do not directly control the - * geometry and their inked extents depend on the - * individual glyph-surface size. We must set a clip region - * so that the X server can trim the glyphs appropriately. - */ - flags |= FORCE_CLIP_REGION; - } - status = _clip_and_composite (surface, op, source, - _composite_glyphs, NULL, - &info, &extents, - need_bounded_clip (&extents) | - flags); + status = _can_composite_glyphs (surface, &extents.bounded, + scaled_font, glyphs, &num_glyphs); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) { + composite_glyphs_info_t info; + unsigned flags = 0; + + info.font = scaled_font; + info.glyphs = (cairo_xcb_glyph_t *) glyphs; + info.num_glyphs = num_glyphs; + info.use_mask = + overlap || + ! extents.is_bounded || + ! _cairo_clip_is_region(extents.clip); + + if (extents.mask.width > extents.unbounded.width || + extents.mask.height > extents.unbounded.height) + { + /* Glyphs are tricky since we do not directly control the + * geometry and their inked extents depend on the + * individual glyph-surface size. We must set a clip region + * so that the X server can trim the glyphs appropriately. + */ + flags |= FORCE_CLIP_REGION; } + status = _clip_and_composite (surface, op, source, + _composite_glyphs, NULL, + &info, &extents, + need_bounded_clip (&extents) | + flags); } _cairo_scaled_font_thaw_cache (scaled_font); diff --git a/src/cairo-xcb-surface.c b/src/cairo-xcb-surface.c index 9639f916..fe4d6286 100644 --- a/src/cairo-xcb-surface.c +++ b/src/cairo-xcb-surface.c @@ -45,6 +45,7 @@ #include "cairo-default-context-private.h" #include "cairo-image-surface-private.h" +#include "cairo-surface-backend-private.h" #if CAIRO_HAS_XLIB_XCB_FUNCTIONS slim_hidden_proto (cairo_xcb_surface_create); @@ -822,14 +823,11 @@ _cairo_xcb_surface_glyphs (void *abstract_surface, cairo_glyph_t *glyphs, int num_glyphs, cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip, - int *num_remaining) + const cairo_clip_t *clip) { cairo_xcb_surface_t *surface = abstract_surface; cairo_int_status_t status; - *num_remaining = 0; - if (surface->fallback == NULL) { status = _cairo_xcb_surface_cairo_glyphs (surface, op, source, @@ -864,36 +862,28 @@ const cairo_surface_backend_t _cairo_xcb_surface_backend = { _cairo_xcb_surface_create_similar, _cairo_xcb_surface_create_similar_image, - _cairo_xcb_surface_map_to_image, _cairo_xcb_surface_unmap, _cairo_xcb_surface_acquire_source_image, _cairo_xcb_surface_release_source_image, + NULL, /* snapshot */ - NULL, NULL, NULL, /* dest acquire/release/clone */ - - NULL, /* composite */ - NULL, /* fill */ - NULL, /* trapezoids */ - NULL, /* span */ - NULL, /* check-span */ NULL, /* copy_page */ NULL, /* show_page */ + _cairo_xcb_surface_get_extents, - NULL, /* old-glyphs */ _cairo_xcb_surface_get_font_options, _cairo_xcb_surface_flush, NULL, - _cairo_xcb_surface_scaled_font_fini, - _cairo_xcb_surface_scaled_glyph_fini, _cairo_xcb_surface_paint, _cairo_xcb_surface_mask, _cairo_xcb_surface_stroke, _cairo_xcb_surface_fill, + NULL, /* fill-stroke */ _cairo_xcb_surface_glyphs, }; @@ -1231,26 +1221,25 @@ cairo_xcb_surface_set_size (cairo_surface_t *abstract_surface, int height) { cairo_xcb_surface_t *surface; - cairo_status_t status_ignored; if (unlikely (abstract_surface->status)) return; if (unlikely (abstract_surface->finished)) { - status_ignored = _cairo_surface_set_error (abstract_surface, - _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); + _cairo_surface_set_error (abstract_surface, + _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); return; } if (abstract_surface->type != CAIRO_SURFACE_TYPE_XCB) { - status_ignored = _cairo_surface_set_error (abstract_surface, - _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); + _cairo_surface_set_error (abstract_surface, + _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); return; } if (width > XLIB_COORD_MAX || height > XLIB_COORD_MAX || width <= 0 || height <= 0) { - status_ignored = _cairo_surface_set_error (abstract_surface, - _cairo_error (CAIRO_STATUS_INVALID_SIZE)); + _cairo_surface_set_error (abstract_surface, + _cairo_error (CAIRO_STATUS_INVALID_SIZE)); return; } diff --git a/src/cairo-xlib-core-compositor.c b/src/cairo-xlib-core-compositor.c new file mode 100644 index 00000000..4d59c1f1 --- /dev/null +++ b/src/cairo-xlib-core-compositor.c @@ -0,0 +1,524 @@ +/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Behdad Esfahbod <behdad@behdad.org> + * Chris Wilson <chris@chris-wilson.co.uk> + * Karl Tomlinson <karlt+@karlt.net>, Mozilla Corporation + */ + +/* The original X drawing API was very restrictive in what it could handle, + * pixel-aligned fill/blits are all that map into Cairo's drawing model. + */ + +#include "cairoint.h" + +#include "cairo-xlib-private.h" +#include "cairo-xlib-surface-private.h" + +#include "cairo-boxes-private.h" +#include "cairo-compositor-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-pattern-private.h" +#include "cairo-region-private.h" +#include "cairo-surface-offset-private.h" + +/* the low-level interface */ + +static cairo_int_status_t +acquire (void *abstract_dst) +{ + cairo_xlib_surface_t *dst = abstract_dst; + return _cairo_xlib_display_acquire (dst->base.device, &dst->display); +} + +static cairo_int_status_t +release (void *abstract_dst) +{ + cairo_xlib_surface_t *dst = abstract_dst; + + cairo_device_release (&dst->display->base); + dst->display = NULL; + + return CAIRO_STATUS_SUCCESS; +} + +struct _fill_box { + Display *dpy; + Drawable drawable; + GC gc; +}; + +static cairo_bool_t fill_box (cairo_box_t *box, void *closure) +{ + struct _fill_box *data = closure; + int x = _cairo_fixed_integer_part (box->p1.x); + int y = _cairo_fixed_integer_part (box->p1.y); + int width = _cairo_fixed_integer_part (box->p2.x - box->p1.x); + int height = _cairo_fixed_integer_part (box->p2.y - box->p1.y); + + XFillRectangle (data->dpy, data->drawable, data->gc, x, y, width, height); + return TRUE; +} + +static cairo_int_status_t +fill_boxes (cairo_xlib_surface_t *dst, + const cairo_color_t *color, + cairo_boxes_t *boxes) +{ + cairo_surface_t *dither = NULL; + cairo_status_t status; + struct _fill_box fb; + + status = _cairo_xlib_surface_get_gc (dst->display, dst, &fb.gc); + if (unlikely (status)) + return status; + + fb.dpy = dst->display->display; + fb.drawable = dst->drawable; + + if (dst->visual && dst->visual->class != TrueColor) { + cairo_solid_pattern_t solid; + cairo_surface_attributes_t attrs; + + _cairo_pattern_init_solid (&solid, color); +#if 0 + status = _cairo_pattern_acquire_surface (&solid.base, &dst->base, + 0, 0, + ARRAY_LENGTH (dither_pattern[0]), + ARRAY_LENGTH (dither_pattern), + CAIRO_PATTERN_ACQUIRE_NONE, + &dither, + &attrs); + if (unlikely (status)) { + _cairo_xlib_surface_put_gc (dst->display, dst, fb.gc); + return status; + } +#endif + + XSetTSOrigin (fb.dpy, fb.gc, + - (dst->base.device_transform.x0 + attrs.x_offset), + - (dst->base.device_transform.y0 + attrs.y_offset)); + XSetTile (fb.dpy, fb.gc, ((cairo_xlib_surface_t *) dither)->drawable); + } else { + //XChangeGC (fb.dpy, fb.gc, GCForeground, color_to_pixel (&color)); + } + + _cairo_boxes_for_each_box (boxes, fill_box, &fb); + _cairo_xlib_surface_put_gc (dst->display, dst, fb.gc); + + cairo_surface_destroy (dither); + + return CAIRO_STATUS_SUCCESS; +} + +struct _fallback_box { + cairo_xlib_surface_t *dst; + cairo_format_t format; + const cairo_pattern_t *pattern; +}; + +static cairo_bool_t fallback_box (cairo_box_t *box, void *closure) +{ + struct _fallback_box *data = closure; + int x = _cairo_fixed_integer_part (box->p1.x); + int y = _cairo_fixed_integer_part (box->p1.y); + int width = _cairo_fixed_integer_part (box->p2.x - box->p1.x); + int height = _cairo_fixed_integer_part (box->p2.y - box->p1.y); + cairo_surface_t *image; + cairo_status_t status; + + /* XXX for EXTEND_NONE and if the box is wholly outside we can just fill */ + + image = cairo_surface_create_similar_image (&data->dst->base, data->format, + width, height); + status = _cairo_surface_offset_paint (image, x, y, + CAIRO_OPERATOR_SOURCE, + data->pattern, NULL); + if (status == CAIRO_STATUS_SUCCESS) { + status = _cairo_xlib_surface_draw_image (data->dst, + (cairo_image_surface_t *)image, + 0, 0, + width, height, + x, y); + } + cairo_surface_destroy (image); + + return status == CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +fallback_boxes (cairo_xlib_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_boxes_t *boxes) +{ + struct _fallback_box fb; + + /* XXX create_similar_image using pixman_format? */ + switch (dst->depth) { + case 8: fb.format = CAIRO_FORMAT_A8; break; + case 16: fb.format = CAIRO_FORMAT_RGB16_565; break; + case 24: fb.format = CAIRO_FORMAT_RGB24; break; + case 30: fb.format = CAIRO_FORMAT_RGB30; break; + case 32: fb.format = CAIRO_FORMAT_ARGB32; break; + default: return CAIRO_INT_STATUS_UNSUPPORTED; + } + + fb.dst = dst; + fb.pattern = pattern; + + if (! _cairo_boxes_for_each_box (boxes, fallback_box, &fb)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +render_boxes (cairo_xlib_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_boxes_t *boxes) +{ + double pad; + + if (_cairo_pattern_analyze_filter (pattern, &pad) != CAIRO_FILTER_NEAREST) + return fallback_boxes (dst, pattern, boxes); + + switch (pattern->extend) { + default: + case CAIRO_EXTEND_NONE: + case CAIRO_EXTEND_REFLECT: + case CAIRO_EXTEND_PAD: + return fallback_boxes (dst, pattern, boxes); + + case CAIRO_EXTEND_REPEAT: /* XXX Use tiling */ + return fallback_boxes (dst, pattern, boxes); + } +} + +/* the mid-level: converts boxes into drawing operations */ + +struct _box_data { + Display *dpy; + cairo_xlib_surface_t *dst; + cairo_surface_t *src; + GC gc; + int tx, ty; + int width, height; +}; + +static cairo_bool_t source_contains_box (cairo_box_t *box, void *closure) +{ + struct _box_data *data = closure; + + /* The box is pixel-aligned so the truncation is safe. */ + return + _cairo_fixed_integer_part (box->p1.x) + data->tx >= 0 && + _cairo_fixed_integer_part (box->p1.y) + data->ty >= 0 && + _cairo_fixed_integer_part (box->p2.x) + data->tx <= data->width && + _cairo_fixed_integer_part (box->p2.y) + data->ty <= data->height; +} + +static cairo_bool_t image_upload_box (cairo_box_t *box, void *closure) +{ + const struct _box_data *iub = closure; + int x = _cairo_fixed_integer_part (box->p1.x); + int y = _cairo_fixed_integer_part (box->p1.y); + int width = _cairo_fixed_integer_part (box->p2.x - box->p1.x); + int height = _cairo_fixed_integer_part (box->p2.y - box->p1.y); + + return _cairo_xlib_surface_draw_image (iub->dst, + (cairo_image_surface_t *)iub->src, + x + iub->tx, y + iub->ty, + width, height, + x, y) == CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +upload_image_inplace (cairo_xlib_surface_t *dst, + const cairo_pattern_t *source, + cairo_boxes_t *boxes) +{ + const cairo_surface_pattern_t *pattern; + struct _box_data iub; + cairo_image_surface_t *image; + + if (source->type != CAIRO_PATTERN_TYPE_SURFACE) + return CAIRO_INT_STATUS_UNSUPPORTED; + + pattern = (const cairo_surface_pattern_t *) source; + if (pattern->surface->type != CAIRO_SURFACE_TYPE_IMAGE) + return CAIRO_INT_STATUS_UNSUPPORTED; + + image = (cairo_image_surface_t *) pattern->surface; + if (image->format == CAIRO_FORMAT_INVALID) + return CAIRO_INT_STATUS_UNSUPPORTED; + + if (image->depth != dst->depth) + return CAIRO_INT_STATUS_UNSUPPORTED; + + /* XXX subsurface */ + + if (! _cairo_matrix_is_integer_translation (&source->matrix, + &iub.tx, &iub.ty)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + iub.dst = dst; + iub.src = &image->base; + iub.width = image->width; + iub.height = image->height; + + /* First check that the data is entirely within the image */ + if (! _cairo_boxes_for_each_box (boxes, source_contains_box, &iub)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + if (! _cairo_boxes_for_each_box (boxes, image_upload_box, &iub)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_bool_t copy_box (cairo_box_t *box, void *closure) +{ + const struct _box_data *cb = closure; + int x = _cairo_fixed_integer_part (box->p1.x); + int y = _cairo_fixed_integer_part (box->p1.y); + int width = _cairo_fixed_integer_part (box->p2.x - box->p1.x); + int height = _cairo_fixed_integer_part (box->p2.y - box->p1.y); + + XCopyArea (cb->dpy, + ((cairo_xlib_surface_t *)cb->src)->drawable, + cb->dst->drawable, + cb->gc, + x + cb->tx, y + cb->ty, + width, height, + x, y); + return TRUE; +} + +static cairo_status_t +copy_boxes (cairo_xlib_surface_t *dst, + const cairo_pattern_t *source, + cairo_boxes_t *boxes) +{ + const cairo_surface_pattern_t *pattern; + struct _box_data cb; + cairo_xlib_surface_t *src; + cairo_status_t status; + + if (source->type != CAIRO_PATTERN_TYPE_SURFACE) + return CAIRO_INT_STATUS_UNSUPPORTED; + + pattern = (const cairo_surface_pattern_t *) source; + if (pattern->surface->type != CAIRO_SURFACE_TYPE_XLIB) + return CAIRO_INT_STATUS_UNSUPPORTED; + + src = (cairo_xlib_surface_t *) pattern->surface; + if (src->depth != dst->depth) + return CAIRO_INT_STATUS_UNSUPPORTED; + + if (! _cairo_xlib_surface_same_screen (dst, src)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + /* XXX subsurface */ + + if (! _cairo_matrix_is_integer_translation (&source->matrix, + &cb.tx, &cb.ty)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + cb.dpy = dst->display->display; + cb.dst = dst; + cb.src = &src->base; + cb.width = src->width; + cb.height = src->height; + + /* First check that the data is entirely within the image */ + if (! _cairo_boxes_for_each_box (boxes, source_contains_box, &cb)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + status = _cairo_xlib_surface_get_gc (dst->display, dst, &cb.gc); + if (unlikely (status)) + return status; + + if (! _cairo_boxes_for_each_box (boxes, copy_box, &cb)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + _cairo_xlib_surface_put_gc (dst->display, dst, cb.gc); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +draw_boxes (cairo_composite_rectangles_t *extents, + cairo_boxes_t *boxes) +{ + cairo_xlib_surface_t *dst = (cairo_xlib_surface_t *)extents->surface; + cairo_operator_t op = extents->op; + const cairo_pattern_t *src = &extents->source_pattern.base; + cairo_int_status_t status; + + if (boxes->num_boxes == 0 && extents->is_bounded) + return CAIRO_STATUS_SUCCESS; + + if (! boxes->is_pixel_aligned) + return CAIRO_INT_STATUS_UNSUPPORTED; + + if (op == CAIRO_OPERATOR_CLEAR) + op = CAIRO_OPERATOR_SOURCE; + + if (_cairo_pattern_is_opaque (src, &extents->bounded)) + op = CAIRO_OPERATOR_SOURCE; + + if (dst->base.is_clear && op == CAIRO_OPERATOR_OVER) + op = CAIRO_OPERATOR_SOURCE; + + if (op != CAIRO_OPERATOR_SOURCE) + return CAIRO_INT_STATUS_UNSUPPORTED; + + status = acquire (dst); + if (unlikely (status)) + return status; + + if (src->type == CAIRO_PATTERN_TYPE_SOLID) { + status = fill_boxes (dst, + &((cairo_solid_pattern_t *) src)->color, + boxes); + } else { + status = upload_image_inplace (dst, src, boxes); + if (status == CAIRO_INT_STATUS_UNSUPPORTED) + status = copy_boxes (dst, src, boxes); + if (status == CAIRO_INT_STATUS_UNSUPPORTED) + status = render_boxes (dst, src, boxes); + } + + release (dst); + + return status; +} + +/* high-level compositor interface */ + +static cairo_int_status_t +_cairo_xlib_core_compositor_paint (const cairo_compositor_t *compositor, + cairo_composite_rectangles_t *extents) +{ + cairo_int_status_t status; + + status = CAIRO_INT_STATUS_UNSUPPORTED; + if (_cairo_clip_is_region (extents->clip)) { + cairo_boxes_t boxes; + + _cairo_clip_steal_boxes (extents->clip, &boxes); + status = draw_boxes (extents, &boxes); + _cairo_clip_unsteal_boxes (extents->clip, &boxes); + } + + return status; +} + +static cairo_int_status_t +_cairo_xlib_core_compositor_stroke (const cairo_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + 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) +{ + cairo_int_status_t status; + + status = CAIRO_INT_STATUS_UNSUPPORTED; + if (_cairo_path_fixed_stroke_is_rectilinear (path)) { + cairo_boxes_t boxes; + + _cairo_boxes_init_with_clip (&boxes, extents->clip); + status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path, + style, + ctm, + antialias, + &boxes); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = draw_boxes (extents, &boxes); + _cairo_boxes_fini (&boxes); + } + + return status; +} + +static cairo_int_status_t +_cairo_xlib_core_compositor_fill (const cairo_compositor_t *compositor, + cairo_composite_rectangles_t *extents, + const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + cairo_antialias_t antialias) +{ + cairo_int_status_t status; + + status = CAIRO_INT_STATUS_UNSUPPORTED; + if (_cairo_path_fixed_fill_is_rectilinear (path)) { + cairo_boxes_t boxes; + + _cairo_boxes_init_with_clip (&boxes, extents->clip); + status = _cairo_path_fixed_fill_rectilinear_to_boxes (path, + fill_rule, + antialias, + &boxes); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = draw_boxes (extents, &boxes); + _cairo_boxes_fini (&boxes); + } + + return status; +} + +const cairo_compositor_t * +_cairo_xlib_core_compositor_get (void) +{ + static cairo_compositor_t compositor; + + if (compositor.delegate == NULL) { + compositor.delegate = _cairo_xlib_fallback_compositor_get (); + + compositor.paint = _cairo_xlib_core_compositor_paint; + compositor.mask = NULL; + compositor.fill = _cairo_xlib_core_compositor_fill; + compositor.stroke = _cairo_xlib_core_compositor_stroke; + compositor.glyphs = NULL; /* XXX PolyGlyph? */ + } + + return &compositor; +} diff --git a/src/cairo-xlib-display.c b/src/cairo-xlib-display.c index 3acc8937..fd7253cc 100644 --- a/src/cairo-xlib-display.c +++ b/src/cairo-xlib-display.c @@ -47,52 +47,8 @@ typedef int (*cairo_xlib_error_func_t) (Display *display, XErrorEvent *event); -struct _cairo_xlib_job { - cairo_xlib_job_t *next; - enum { - RESOURCE, - WORK - } type; - union { - struct { - cairo_xlib_notify_resource_func notify; - XID xid; - } resource; - struct { - cairo_xlib_notify_func notify; - void *data; - void (*destroy) (void *); - } work; - } func; -}; - static cairo_xlib_display_t *_cairo_xlib_display_list; -static void -_cairo_xlib_remove_close_display_hook_internal (cairo_xlib_display_t *display, - cairo_xlib_hook_t *hook); - -static void -_cairo_xlib_call_close_display_hooks (cairo_xlib_display_t *display) -{ - cairo_xlib_screen_t *screen; - cairo_xlib_hook_t *hook; - - cairo_list_foreach_entry (screen, cairo_xlib_screen_t, &display->screens, link) - _cairo_xlib_screen_close_display (display, screen); - - while (TRUE) { - hook = display->close_display_hooks; - if (hook == NULL) - break; - - _cairo_xlib_remove_close_display_hook_internal (display, hook); - - hook->func (display, hook); - } - display->closed = TRUE; -} - static int _noop_error_handler (Display *display, XErrorEvent *event) @@ -101,59 +57,6 @@ _noop_error_handler (Display *display, } static void -_cairo_xlib_display_notify (cairo_xlib_display_t *display) -{ - cairo_xlib_job_t *jobs, *job, *freelist; - Display *dpy = display->display; - - /* Optimistic atomic pointer read -- don't care if it is wrong due to - * contention as we will check again very shortly. - */ - if (display->workqueue == NULL) - return; - - jobs = display->workqueue; - while (jobs != NULL) { - display->workqueue = NULL; - - /* reverse the list to obtain FIFO order */ - job = NULL; - do { - cairo_xlib_job_t *next = jobs->next; - jobs->next = job; - job = jobs; - jobs = next; - } while (jobs != NULL); - freelist = jobs = job; - - do { - job = jobs; - jobs = job->next; - - switch (job->type){ - case WORK: - job->func.work.notify (dpy, job->func.work.data); - if (job->func.work.destroy != NULL) - job->func.work.destroy (job->func.work.data); - break; - - case RESOURCE: - job->func.resource.notify (dpy, job->func.resource.xid); - break; - } - } while (jobs != NULL); - - do { - job = freelist; - freelist = job->next; - _cairo_freelist_free (&display->wq_freelist, job); - } while (freelist != NULL); - - jobs = display->workqueue; - } -} - -static void _cairo_xlib_display_finish (void *abstract_display) { cairo_xlib_display_t *display = abstract_display; @@ -166,11 +69,18 @@ _cairo_xlib_display_finish (void *abstract_display) XSync (dpy, False); old_handler = XSetErrorHandler (_noop_error_handler); - _cairo_xlib_display_notify (display); - _cairo_xlib_call_close_display_hooks (display); + while (! cairo_list_is_empty (&display->fonts)) { + _cairo_xlib_font_close (cairo_list_first_entry (&display->fonts, + cairo_xlib_font_t, + link)); + } - /* catch any that arrived before marking the display as closed */ - _cairo_xlib_display_notify (display); + while (! cairo_list_is_empty (&display->screens)) { + _cairo_xlib_screen_destroy (display, + cairo_list_first_entry (&display->screens, + cairo_xlib_screen_t, + link)); + } XSync (dpy, False); XSetErrorHandler (old_handler); @@ -184,24 +94,6 @@ _cairo_xlib_display_destroy (void *abstract_display) { cairo_xlib_display_t *display = abstract_display; - /* destroy all outstanding notifies */ - while (display->workqueue != NULL) { - cairo_xlib_job_t *job = display->workqueue; - display->workqueue = job->next; - - if (job->type == WORK && job->func.work.destroy != NULL) - job->func.work.destroy (job->func.work.data); - - _cairo_freelist_free (&display->wq_freelist, job); - } - _cairo_freelist_fini (&display->wq_freelist); - - while (! cairo_list_is_empty (&display->screens)) { - _cairo_xlib_screen_destroy (cairo_list_first_entry (&display->screens, - cairo_xlib_screen_t, - link)); - } - free (display); } @@ -340,15 +232,18 @@ _cairo_xlib_device_create (Display *dpy) XESetCloseDisplay (dpy, codes->extension, _cairo_xlib_close_display); - _cairo_freelist_init (&display->wq_freelist, sizeof (cairo_xlib_job_t)); - cairo_device_reference (&display->base); /* add one for the CloseDisplay */ display->display = dpy; cairo_list_init (&display->screens); - display->workqueue = NULL; - display->close_display_hooks = NULL; + cairo_list_init (&display->fonts); display->closed = FALSE; + display->white = NULL; + memset (display->alpha, 0, sizeof (display->alpha)); + memset (display->solid, 0, sizeof (display->solid)); + memset (display->solid_cache, 0, sizeof (display->solid_cache)); + memset (display->last_solid_cache, 0, sizeof (display->last_solid_cache)); + memset (display->cached_xrender_formats, 0, sizeof (display->cached_xrender_formats)); @@ -436,6 +331,13 @@ _cairo_xlib_device_create (Display *dpy) display->buggy_pad_reflect = TRUE; } + if (display->render_major > 0 || display->render_minor >= 4) + display->compositor = _cairo_xlib_traps_compositor_get (); + else if (display->render_major > 0 || display->render_minor >= 0) + display->compositor = _cairo_xlib_mask_compositor_get (); + else + display->compositor = _cairo_xlib_core_compositor_get (); + display->next = _cairo_xlib_display_list; _cairo_xlib_display_list = display; @@ -446,92 +348,6 @@ UNLOCK: return device; } -void -_cairo_xlib_add_close_display_hook (cairo_xlib_display_t *display, - cairo_xlib_hook_t *hook) -{ - hook->prev = NULL; - hook->next = display->close_display_hooks; - if (hook->next != NULL) - hook->next->prev = hook; - display->close_display_hooks = hook; -} - -static void -_cairo_xlib_remove_close_display_hook_internal (cairo_xlib_display_t *display, - cairo_xlib_hook_t *hook) -{ - if (display->close_display_hooks == hook) - display->close_display_hooks = hook->next; - else if (hook->prev != NULL) - hook->prev->next = hook->next; - - if (hook->next != NULL) - hook->next->prev = hook->prev; - - hook->prev = NULL; - hook->next = NULL; -} - -void -_cairo_xlib_remove_close_display_hook (cairo_xlib_display_t *display, - cairo_xlib_hook_t *hook) -{ - _cairo_xlib_remove_close_display_hook_internal (display, hook); -} - -cairo_status_t -_cairo_xlib_display_queue_resource (cairo_xlib_display_t *display, - cairo_xlib_notify_resource_func notify, - XID xid) -{ - cairo_xlib_job_t *job; - cairo_status_t status = CAIRO_STATUS_NO_MEMORY; - - if (display->closed == FALSE) { - job = _cairo_freelist_alloc (&display->wq_freelist); - if (job != NULL) { - job->type = RESOURCE; - job->func.resource.xid = xid; - job->func.resource.notify = notify; - - job->next = display->workqueue; - display->workqueue = job; - - status = CAIRO_STATUS_SUCCESS; - } - } - - return status; -} - -cairo_status_t -_cairo_xlib_display_queue_work (cairo_xlib_display_t *display, - cairo_xlib_notify_func notify, - void *data, - void (*destroy) (void *)) -{ - cairo_xlib_job_t *job; - cairo_status_t status = CAIRO_STATUS_NO_MEMORY; - - if (display->closed == FALSE) { - job = _cairo_freelist_alloc (&display->wq_freelist); - if (job != NULL) { - job->type = WORK; - job->func.work.data = data; - job->func.work.notify = notify; - job->func.work.destroy = destroy; - - job->next = display->workqueue; - display->workqueue = job; - - status = CAIRO_STATUS_SUCCESS; - } - } - - return status; -} - cairo_status_t _cairo_xlib_display_acquire (cairo_device_t *device, cairo_xlib_display_t **display) { @@ -542,7 +358,6 @@ _cairo_xlib_display_acquire (cairo_device_t *device, cairo_xlib_display_t **disp return status; *display = (cairo_xlib_display_t *) device; - _cairo_xlib_display_notify (*display); return status; } @@ -719,14 +534,6 @@ _cairo_xlib_display_get_screen (cairo_xlib_display_t *display, return NULL; } -void -_cairo_xlib_display_get_xrender_version (cairo_xlib_display_t *display, - int *major, int *minor) -{ - *major = display->render_major; - *minor = display->render_minor; -} - cairo_bool_t _cairo_xlib_display_has_repeat (cairo_device_t *device) { diff --git a/src/test-null-surface.h b/src/cairo-xlib-fallback-compositor.c index 3c05190f..53919268 100644 --- a/src/test-null-surface.h +++ b/src/cairo-xlib-fallback-compositor.c @@ -1,6 +1,9 @@ +/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */ /* cairo - a vector graphics library with display and print output * - * Copyright © 2009 Chris Wilson + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * 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 @@ -27,20 +30,25 @@ * * The Original Code is the cairo graphics library. * + * The Initial Developer of the Original Code is University of Southern + * California. + * * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Behdad Esfahbod <behdad@behdad.org> * Chris Wilson <chris@chris-wilson.co.uk> + * Karl Tomlinson <karlt+@karlt.net>, Mozilla Corporation */ -#ifndef TEST_NULL_SURFACE_H -#define TEST_NULL_SURFACE_H - -#include "cairo.h" - -CAIRO_BEGIN_DECLS +#include "cairoint.h" -cairo_public cairo_surface_t * -_cairo_test_null_surface_create (cairo_content_t content); +#include "cairo-xlib-private.h" -CAIRO_END_DECLS +#include "cairo-compositor-private.h" -#endif /* TEST_NULL_SURFACE_H */ +const cairo_compositor_t * +_cairo_xlib_fallback_compositor_get (void) +{ + /* XXX Do something interesting here to mitigate fallbacks ala xcb */ + return &_cairo_fallback_compositor; +} diff --git a/src/cairo-xlib-private.h b/src/cairo-xlib-private.h index 3a32eff2..45228323 100644 --- a/src/cairo-xlib-private.h +++ b/src/cairo-xlib-private.h @@ -46,21 +46,15 @@ #include "cairo-list-private.h" #include "cairo-reference-count-private.h" #include "cairo-types-private.h" +#include "cairo-scaled-font-private.h" +#include "cairo-surface-private.h" #include <pixman.h> typedef struct _cairo_xlib_display cairo_xlib_display_t; typedef struct _cairo_xlib_screen cairo_xlib_screen_t; - -typedef struct _cairo_xlib_hook cairo_xlib_hook_t; -typedef struct _cairo_xlib_job cairo_xlib_job_t; -typedef void (*cairo_xlib_notify_func) (Display *, void *); -typedef void (*cairo_xlib_notify_resource_func) (Display *, XID); - -struct _cairo_xlib_hook { - cairo_xlib_hook_t *prev, *next; /* private */ - void (*func) (cairo_xlib_display_t *display, void *data); -}; +typedef struct _cairo_xlib_source cairo_xlib_source_t; +typedef struct _cairo_xlib_surface cairo_xlib_surface_t; /* size of color cube */ #define CUBE_SIZE 6 @@ -76,20 +70,43 @@ struct _cairo_xlib_display { Display *display; cairo_list_t screens; + cairo_list_t fonts; + + const cairo_compositor_t *compositor; int render_major; int render_minor; XRenderPictFormat *cached_xrender_formats[CAIRO_FORMAT_RGB16_565 + 1]; - cairo_xlib_job_t *workqueue; - cairo_freelist_t wq_freelist; - int force_precision; - cairo_xlib_hook_t *close_display_hooks; - unsigned int buggy_gradients :1; - unsigned int buggy_pad_reflect :1; - unsigned int buggy_repeat :1; + cairo_surface_t *white; + cairo_surface_t *alpha[256]; + cairo_surface_t *solid[32]; + uint32_t solid_cache[32]; /* low 16 are opaque, high 16 transparent */ + struct { + uint32_t color; + int index; + } last_solid_cache[2]; + + /* TRUE if the server has a bug with repeating pictures + * + * https://bugs.freedesktop.org/show_bug.cgi?id=3566 + * + * We can't test for this because it depends on whether the + * picture is in video memory or not. + * + * We also use this variable as a guard against a second + * independent bug with transformed repeating pictures: + * + * http://lists.freedesktop.org/archives/cairo/2004-September/001839.html + * + * Both are fixed in xorg >= 6.9 and hopefully in > 6.8.2, so + * we can reuse the test for now. + */ + unsigned int buggy_gradients : 1; + unsigned int buggy_pad_reflect : 1; + unsigned int buggy_repeat : 1; unsigned int closed :1; }; @@ -120,6 +137,79 @@ struct _cairo_xlib_screen { cairo_list_t visuals; }; +enum { + GLYPHSET_INDEX_ARGB32, + GLYPHSET_INDEX_A8, + GLYPHSET_INDEX_A1, + NUM_GLYPHSETS +}; + +typedef struct _cairo_xlib_font_glyphset { + GlyphSet glyphset; + cairo_format_t format; + XRenderPictFormat *xrender_format; + struct _cairo_xlib_font_glyphset_free_glyphs { + int count; + unsigned long indices[128]; + } to_free; +} cairo_xlib_font_glyphset_t; + +typedef struct _cairo_xlib_font { + cairo_scaled_font_private_t base; + cairo_scaled_font_t *font; + cairo_device_t *device; + cairo_list_t link; + cairo_xlib_font_glyphset_t glyphset[NUM_GLYPHSETS]; +} cairo_xlib_font_t; + +struct _cairo_xlib_surface { + cairo_surface_t base; + + Picture picture; + + const cairo_compositor_t *compositor; + + cairo_xlib_display_t *display; + cairo_xlib_screen_t *screen; + cairo_list_t link; + + Display *dpy; /* only valid between acquire/release */ + Drawable drawable; + cairo_bool_t owns_pixmap; + Visual *visual; + + int use_pixmap; + + int width; + int height; + int depth; + + int precision; + XRenderPictFormat *xrender_format; + /* XXX pixman_format instead of masks? */ + uint32_t a_mask; + uint32_t r_mask; + uint32_t g_mask; + uint32_t b_mask; + + struct _cairo_xlib_source { + cairo_surface_t base; + + Picture picture; + Display *dpy; + + unsigned int filter:3; + unsigned int extend:3; + unsigned int has_matrix:1; + unsigned int has_component_alpha:1; + } embedded_source; +}; + +cairo_private cairo_status_t +_cairo_xlib_surface_get_gc (cairo_xlib_display_t *display, + cairo_xlib_surface_t *surface, + GC *gc); + cairo_private cairo_device_t * _cairo_xlib_device_create (Display *display); @@ -127,29 +217,10 @@ cairo_private cairo_xlib_screen_t * _cairo_xlib_display_get_screen (cairo_xlib_display_t *display, Screen *screen); -cairo_private void -_cairo_xlib_add_close_display_hook (cairo_xlib_display_t *display, cairo_xlib_hook_t *hook); - -cairo_private void -_cairo_xlib_remove_close_display_hook (cairo_xlib_display_t *display, cairo_xlib_hook_t *hook); - -cairo_private cairo_status_t -_cairo_xlib_display_queue_work (cairo_xlib_display_t *display, - cairo_xlib_notify_func notify, - void *data, - void (*destroy)(void *)); -cairo_private cairo_status_t -_cairo_xlib_display_queue_resource (cairo_xlib_display_t *display, - cairo_xlib_notify_resource_func notify, - XID resource); cairo_private cairo_status_t _cairo_xlib_display_acquire (cairo_device_t *device, cairo_xlib_display_t **display); -cairo_private void -_cairo_xlib_display_get_xrender_version (cairo_xlib_display_t *display, - int *major, int *minor); - cairo_private cairo_bool_t _cairo_xlib_display_has_repeat (cairo_device_t *device); @@ -177,21 +248,17 @@ _cairo_xlib_screen_get (Display *dpy, cairo_xlib_screen_t **out); cairo_private void -_cairo_xlib_screen_destroy (cairo_xlib_screen_t *info); - -cairo_private void -_cairo_xlib_screen_close_display (cairo_xlib_display_t *display, - cairo_xlib_screen_t *info); +_cairo_xlib_screen_destroy (cairo_xlib_display_t *display, + cairo_xlib_screen_t *info); cairo_private GC _cairo_xlib_screen_get_gc (cairo_xlib_display_t *display, cairo_xlib_screen_t *info, int depth, Drawable drawable); - cairo_private void _cairo_xlib_screen_put_gc (cairo_xlib_display_t *display, - cairo_xlib_screen_t *info, + cairo_xlib_screen_t *info, int depth, GC gc); @@ -213,4 +280,105 @@ _cairo_xlib_visual_info_create (Display *dpy, cairo_private void _cairo_xlib_visual_info_destroy (cairo_xlib_visual_info_t *info); +cairo_private const cairo_compositor_t * +_cairo_xlib_core_compositor_get (void); + +cairo_private const cairo_compositor_t * +_cairo_xlib_fallback_compositor_get (void); + +cairo_private const cairo_compositor_t * +_cairo_xlib_mask_compositor_get (void); + +cairo_private const cairo_compositor_t * +_cairo_xlib_traps_compositor_get (void); + +cairo_private void +_cairo_xlib_surface_ensure_picture (cairo_xlib_surface_t *surface); + +cairo_private void +_cairo_xlib_surface_set_precision (cairo_xlib_surface_t *surface, + cairo_antialias_t antialias); + +cairo_private cairo_int_status_t +_cairo_xlib_surface_set_attributes (cairo_xlib_display_t *display, + cairo_xlib_surface_t *surface, + cairo_surface_attributes_t *attributes, + double xc, + double yc); + +cairo_private cairo_status_t +_cairo_xlib_surface_draw_image (cairo_xlib_surface_t *surface, + cairo_image_surface_t *image, + int src_x, + int src_y, + int width, + int height, + int dst_x, + int dst_y); + +cairo_private cairo_surface_t * +_cairo_xlib_source_create_for_pattern (cairo_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y); + +cairo_private void +_cairo_xlib_font_close (cairo_xlib_font_t *font); + +#define CAIRO_RENDER_AT_LEAST(surface, major, minor) \ + (((surface)->render_major > major) || \ + (((surface)->render_major == major) && ((surface)->render_minor >= minor))) + +#define CAIRO_RENDER_HAS_CREATE_PICTURE(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 0) +#define CAIRO_RENDER_HAS_COMPOSITE(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 0) +#define CAIRO_RENDER_HAS_COMPOSITE_TEXT(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 0) + +#define CAIRO_RENDER_HAS_FILL_RECTANGLES(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 1) + +#define CAIRO_RENDER_HAS_DISJOINT(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 2) +#define CAIRO_RENDER_HAS_CONJOINT(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 2) + +#define CAIRO_RENDER_HAS_TRAPEZOIDS(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 4) +#define CAIRO_RENDER_HAS_TRIANGLES(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 4) +#define CAIRO_RENDER_HAS_TRISTRIP(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 4) +#define CAIRO_RENDER_HAS_TRIFAN(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 4) + +#define CAIRO_RENDER_HAS_PICTURE_TRANSFORM(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 6) +#define CAIRO_RENDER_HAS_FILTERS(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 6) + +#define CAIRO_RENDER_HAS_EXTENDED_REPEAT(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 10) +#define CAIRO_RENDER_HAS_GRADIENTS(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 10) + +#define CAIRO_RENDER_HAS_PDF_OPERATORS(surface) CAIRO_RENDER_AT_LEAST((surface), 0, 11) + +#define CAIRO_RENDER_SUPPORTS_OPERATOR(surface, op) \ + ((op) <= CAIRO_OPERATOR_SATURATE || \ + (CAIRO_RENDER_HAS_PDF_OPERATORS(surface) && \ + (op) <= CAIRO_OPERATOR_HSL_LUMINOSITY)) + +/* + * Return whether two xlib surfaces share the same + * screen. Both core and Render drawing require this + * when using multiple drawables in an operation. + */ +static inline cairo_bool_t +_cairo_xlib_surface_same_screen (cairo_xlib_surface_t *dst, + cairo_xlib_surface_t *src) +{ + return dst->screen == src->screen; +} + +static inline void +_cairo_xlib_surface_put_gc (cairo_xlib_display_t *display, + cairo_xlib_surface_t *surface, + GC gc) +{ + _cairo_xlib_screen_put_gc (display, + surface->screen, + surface->depth, + gc); +} + #endif /* CAIRO_XLIB_PRIVATE_H */ diff --git a/src/cairo-xlib-render-compositor.c b/src/cairo-xlib-render-compositor.c new file mode 100644 index 00000000..6e53f133 --- /dev/null +++ b/src/cairo-xlib-render-compositor.c @@ -0,0 +1,1685 @@ +/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Behdad Esfahbod <behdad@behdad.org> + * Chris Wilson <chris@chris-wilson.co.uk> + * Karl Tomlinson <karlt+@karlt.net>, Mozilla Corporation + */ + +#include "cairoint.h" + +#include "cairo-xlib-private.h" + +#include "cairo-compositor-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-pattern-private.h" +#include "cairo-traps-private.h" +#include "cairo-tristrip-private.h" + +static cairo_int_status_t +acquire (void *abstract_dst) +{ + cairo_xlib_surface_t *dst = abstract_dst; + cairo_int_status_t status; + + status = _cairo_xlib_display_acquire (dst->base.device, &dst->display); + if (unlikely (status)) + return status; + + dst->dpy = dst->display->display; + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +release (void *abstract_dst) +{ + cairo_xlib_surface_t *dst = abstract_dst; + + cairo_device_release (&dst->display->base); + dst->dpy = NULL; + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +set_clip_region (void *_surface, + cairo_region_t *region) +{ + cairo_xlib_surface_t *surface = _surface; + + _cairo_xlib_surface_ensure_picture (surface); + + if (region != NULL) { + XRectangle stack_rects[CAIRO_STACK_ARRAY_LENGTH (sizeof (XRectangle))]; + XRectangle *rects = stack_rects; + int n_rects, i; + + n_rects = cairo_region_num_rectangles (region); + if (n_rects > ARRAY_LENGTH (stack_rects)) { + rects = _cairo_malloc_ab (n_rects, sizeof (XRectangle)); + if (unlikely (rects == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + for (i = 0; i < n_rects; i++) { + cairo_rectangle_int_t rect; + + cairo_region_get_rectangle (region, i, &rect); + + rects[i].x = rect.x; + rects[i].y = rect.y; + rects[i].width = rect.width; + rects[i].height = rect.height; + } + XRenderSetPictureClipRectangles (surface->dpy, + surface->picture, + 0, 0, + rects, n_rects); + if (rects != stack_rects) + free (rects); + } else { + XRenderPictureAttributes pa; + pa.clip_mask = None; + XRenderChangePicture (surface->dpy, + surface->picture, + CPClipMask, &pa); + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +draw_image_boxes (void *_dst, + cairo_image_surface_t *image, + cairo_boxes_t *boxes, + int dx, int dy) +{ + struct _cairo_boxes_chunk *chunk; + int i; + + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + cairo_box_t *b = &chunk->base[i]; + int x1 = _cairo_fixed_integer_part (b->p1.x); + int y1 = _cairo_fixed_integer_part (b->p1.y); + int x2 = _cairo_fixed_integer_part (b->p2.x); + int y2 = _cairo_fixed_integer_part (b->p2.y); + if ( _cairo_xlib_surface_draw_image (_dst, image, + x1 + dx, y1 + dy, + x2 - x1, y2 - y1, + x1, y1)) + return CAIRO_INT_STATUS_UNSUPPORTED; + } + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +copy_boxes (void *_dst, + cairo_surface_t *_src, + cairo_boxes_t *boxes, + const cairo_rectangle_int_t *extents, + int dx, int dy) +{ + cairo_xlib_surface_t *dst = _dst; + cairo_xlib_surface_t *src = (cairo_xlib_surface_t *)_src; + struct _cairo_boxes_chunk *chunk; + cairo_int_status_t status; + GC gc; + int i, j; + + if (! _cairo_xlib_surface_same_screen (dst, src)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + if (dst->depth != src->depth) + return CAIRO_INT_STATUS_UNSUPPORTED; + + status = acquire (dst); + if (unlikely (status)) + return status; + + status = _cairo_xlib_surface_get_gc (dst->display, dst, &gc); + if (unlikely (status)) { + release (dst); + return status; + } + + if (boxes->num_boxes == 1) { + int x1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.x); + int y1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.y); + int x2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.x); + int y2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.y); + + XCopyArea (dst->dpy, src->drawable, dst->drawable, gc, + x1 + dx, y1 + dy, + x2 - x1, y2 - y1, + x1, y1); + } else { + XRectangle stack_rects[CAIRO_STACK_ARRAY_LENGTH (XRectangle)]; + XRectangle *rects = stack_rects; + + if (boxes->num_boxes > ARRAY_LENGTH (stack_rects)) { + rects = _cairo_malloc_ab (boxes->num_boxes, sizeof (XRectangle)); + if (unlikely (rects == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + j = 0; + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x); + int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y); + int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x); + int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y); + + rects[j].x = x1; + rects[j].y = y1; + rects[j].width = x2 - x1; + rects[j].height = y2 - y1; + j++; + } + } + assert (j == boxes->num_boxes); + + XSetClipRectangles (dst->dpy, gc, 0, 0, rects, j, YSorted); + + XCopyArea (dst->dpy, src->drawable, dst->drawable, gc, + extents->x + dx, extents->y + dy, + extents->width, extents->height, + extents->x, extents->y); + + XSetClipMask (dst->dpy, gc, None); + + if (rects != stack_rects) + free (rects); + } + + _cairo_xlib_surface_put_gc (dst->display, dst, gc); + release (dst); + return CAIRO_STATUS_SUCCESS; +} + +static int +_render_operator (cairo_operator_t op) +{ + switch (op) { + case CAIRO_OPERATOR_CLEAR: + return PictOpClear; + + case CAIRO_OPERATOR_SOURCE: + return PictOpSrc; + case CAIRO_OPERATOR_OVER: + return PictOpOver; + case CAIRO_OPERATOR_IN: + return PictOpIn; + case CAIRO_OPERATOR_OUT: + return PictOpOut; + case CAIRO_OPERATOR_ATOP: + return PictOpAtop; + + case CAIRO_OPERATOR_DEST: + return PictOpDst; + case CAIRO_OPERATOR_DEST_OVER: + return PictOpOverReverse; + case CAIRO_OPERATOR_DEST_IN: + return PictOpInReverse; + case CAIRO_OPERATOR_DEST_OUT: + return PictOpOutReverse; + case CAIRO_OPERATOR_DEST_ATOP: + return PictOpAtopReverse; + + case CAIRO_OPERATOR_XOR: + return PictOpXor; + case CAIRO_OPERATOR_ADD: + return PictOpAdd; + case CAIRO_OPERATOR_SATURATE: + return PictOpSaturate; + + case CAIRO_OPERATOR_MULTIPLY: + return PictOpMultiply; + case CAIRO_OPERATOR_SCREEN: + return PictOpScreen; + case CAIRO_OPERATOR_OVERLAY: + return PictOpOverlay; + case CAIRO_OPERATOR_DARKEN: + return PictOpDarken; + case CAIRO_OPERATOR_LIGHTEN: + return PictOpLighten; + case CAIRO_OPERATOR_COLOR_DODGE: + return PictOpColorDodge; + case CAIRO_OPERATOR_COLOR_BURN: + return PictOpColorBurn; + case CAIRO_OPERATOR_HARD_LIGHT: + return PictOpHardLight; + case CAIRO_OPERATOR_SOFT_LIGHT: + return PictOpSoftLight; + case CAIRO_OPERATOR_DIFFERENCE: + return PictOpDifference; + case CAIRO_OPERATOR_EXCLUSION: + return PictOpExclusion; + case CAIRO_OPERATOR_HSL_HUE: + return PictOpHSLHue; + case CAIRO_OPERATOR_HSL_SATURATION: + return PictOpHSLSaturation; + case CAIRO_OPERATOR_HSL_COLOR: + return PictOpHSLColor; + case CAIRO_OPERATOR_HSL_LUMINOSITY: + return PictOpHSLLuminosity; + + default: + ASSERT_NOT_REACHED; + return PictOpOver; + } +} + +static cairo_bool_t +fill_reduces_to_source (cairo_operator_t op, + const cairo_color_t *color, + cairo_xlib_surface_t *dst) +{ + if (dst->base.is_clear || CAIRO_COLOR_IS_OPAQUE (color)) + return op == CAIRO_OPERATOR_OVER || op == CAIRO_OPERATOR_ADD; + + return FALSE; +} + +static cairo_int_status_t +fill_rectangles (void *abstract_surface, + cairo_operator_t op, + const cairo_color_t *color, + cairo_rectangle_int_t *rects, + int num_rects) +{ + cairo_xlib_surface_t *dst = abstract_surface; + XRenderColor render_color; + int i; + + //X_DEBUG ((display->display, "fill_rectangles (dst=%x)", (unsigned int) surface->drawable)); + + render_color.red = color->red_short; + render_color.green = color->green_short; + render_color.blue = color->blue_short; + render_color.alpha = color->alpha_short; + + if (fill_reduces_to_source (op, color, dst)) + op = CAIRO_OPERATOR_SOURCE; + + _cairo_xlib_surface_ensure_picture (dst); + if (num_rects == 1) { + /* Take advantage of the protocol compaction that libXrender performs + * to amalgamate sequences of XRenderFillRectangle(). + */ + XRenderFillRectangle (dst->dpy, + _render_operator (op), + dst->picture, + &render_color, + rects->x, rects->y, + rects->width, rects->height); + } else { + XRectangle stack_xrects[CAIRO_STACK_ARRAY_LENGTH (XRectangle)]; + XRectangle *xrects = stack_xrects; + + if (num_rects > ARRAY_LENGTH (stack_xrects)) { + xrects = _cairo_malloc_ab (num_rects, sizeof (XRectangle)); + if (unlikely (xrects == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + for (i = 0; i < num_rects; i++) { + xrects[i].x = rects[i].x; + xrects[i].y = rects[i].y; + xrects[i].width = rects[i].width; + xrects[i].height = rects[i].height; + } + + XRenderFillRectangles (dst->dpy, + _render_operator (op), + dst->picture, + &render_color, xrects, num_rects); + + if (xrects != stack_xrects) + free (xrects); + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +fill_boxes (void *abstract_surface, + cairo_operator_t op, + const cairo_color_t *color, + cairo_boxes_t *boxes) +{ + cairo_xlib_surface_t *dst = abstract_surface; + XRenderColor render_color; + + render_color.red = color->red_short; + render_color.green = color->green_short; + render_color.blue = color->blue_short; + render_color.alpha = color->alpha_short; + + if (fill_reduces_to_source (op, color, dst)) + op = CAIRO_OPERATOR_SOURCE; + + _cairo_xlib_surface_ensure_picture (dst); + if (boxes->num_boxes == 1) { + int x1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.x); + int y1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.y); + int x2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.x); + int y2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.y); + + /* Take advantage of the protocol compaction that libXrender performs + * to amalgamate sequences of XRenderFillRectangle(). + */ + XRenderFillRectangle (dst->dpy, + _render_operator (op), + dst->picture, + &render_color, + x1, y1, + x2 - x1, y2 - y1); + } else { + XRectangle stack_xrects[CAIRO_STACK_ARRAY_LENGTH (XRectangle)]; + XRectangle *xrects = stack_xrects; + struct _cairo_boxes_chunk *chunk; + int i, j; + + if (boxes->num_boxes > ARRAY_LENGTH (stack_xrects)) { + xrects = _cairo_malloc_ab (boxes->num_boxes, sizeof (XRectangle)); + if (unlikely (xrects == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + j = 0; + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x); + int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y); + int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x); + int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y); + + xrects[j].x = x1; + xrects[j].y = y1; + xrects[j].width = x2 - x1; + xrects[j].height = y2 - y1; + j++; + } + } + + XRenderFillRectangles (dst->dpy, + _render_operator (op), + dst->picture, + &render_color, xrects, j); + + if (xrects != stack_xrects) + free (xrects); + } + + return CAIRO_STATUS_SUCCESS; +} + +#if 0 +check_composite () + operation = _categorize_composite_operation (dst, op, src_pattern, + mask_pattern != NULL); + if (operation == DO_UNSUPPORTED) + return UNSUPPORTED ("unsupported operation"); + + //X_DEBUG ((display->display, "composite (dst=%x)", (unsigned int) dst->drawable)); + + operation = _recategorize_composite_operation (dst, op, src, &src_attr, + mask_pattern != NULL); + if (operation == DO_UNSUPPORTED) { + status = UNSUPPORTED ("unsupported operation"); + goto BAIL; + } +#endif + +static cairo_int_status_t +composite (void *abstract_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height) +{ + cairo_xlib_surface_t *dst = abstract_dst; + cairo_xlib_source_t *src = (cairo_xlib_source_t *)abstract_src; + + op = _render_operator (op); + + _cairo_xlib_surface_ensure_picture (dst); + if (abstract_mask) { + cairo_xlib_source_t *mask = (cairo_xlib_source_t *)abstract_mask; + + XRenderComposite (dst->dpy, op, + src->picture, mask->picture, dst->picture, + src_x, src_y, + mask_x, mask_y, + dst_x, dst_y, + width, height); + } else { + XRenderComposite (dst->dpy, op, + src->picture, 0, dst->picture, + src_x, src_y, + 0, 0, + dst_x, dst_y, + width, height); + } + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +lerp (void *abstract_dst, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height) +{ + cairo_xlib_surface_t *dst = abstract_dst; + cairo_xlib_source_t *src = (cairo_xlib_source_t *)abstract_src; + cairo_xlib_source_t *mask = (cairo_xlib_source_t *)abstract_mask; + + _cairo_xlib_surface_ensure_picture (dst); + XRenderComposite (dst->dpy, PictOpOutReverse, + mask->picture, None, dst->picture, + mask_x, mask_y, + 0, 0, + dst_x, dst_y, + width, height); + XRenderComposite (dst->dpy, PictOpAdd, + src->picture, mask->picture, dst->picture, + src_x, src_y, + mask_x, mask_y, + dst_x, dst_y, + width, height); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_boxes (void *abstract_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + cairo_boxes_t *boxes, + const cairo_rectangle_int_t *extents) +{ + cairo_xlib_surface_t *dst = abstract_dst; + Picture src = ((cairo_xlib_source_t *)abstract_src)->picture; + Picture mask = abstract_mask ? ((cairo_xlib_source_t *)abstract_mask)->picture : 0; + XRectangle stack_rects[CAIRO_STACK_ARRAY_LENGTH (XRectangle)]; + XRectangle *rects = stack_rects; + struct _cairo_boxes_chunk *chunk; + int i, j; + + op = _render_operator (op); + _cairo_xlib_surface_ensure_picture (dst); + if (boxes->num_boxes == 1) { + int x1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.x); + int y1 = _cairo_fixed_integer_part (boxes->chunks.base[0].p1.y); + int x2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.x); + int y2 = _cairo_fixed_integer_part (boxes->chunks.base[0].p2.y); + + XRenderComposite (dst->dpy, op, + src, mask, dst->picture, + x1 + src_x, y1 + src_y, + x1 + mask_x, y1 + mask_y, + x1 - dst_x, y1 - dst_y, + x2 - x1, y2 - y1); + return CAIRO_STATUS_SUCCESS; + } + + if (boxes->num_boxes > ARRAY_LENGTH (stack_rects)) { + rects = _cairo_malloc_ab (boxes->num_boxes, sizeof (XRectangle)); + if (unlikely (rects == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + j = 0; + for (chunk = &boxes->chunks; chunk; chunk = chunk->next) { + for (i = 0; i < chunk->count; i++) { + int x1 = _cairo_fixed_integer_part (chunk->base[i].p1.x); + int y1 = _cairo_fixed_integer_part (chunk->base[i].p1.y); + int x2 = _cairo_fixed_integer_part (chunk->base[i].p2.x); + int y2 = _cairo_fixed_integer_part (chunk->base[i].p2.y); + + rects[j].x = x1 - dst_x; + rects[j].y = y1 - dst_y; + rects[j].width = x2 - x1; + rects[j].height = y2 - y1; + j++; + } + } + assert (j == boxes->num_boxes); + + XRenderSetPictureClipRectangles (dst->dpy, + dst->picture, + 0, 0, + rects, j); + if (rects != stack_rects) + free (rects); + + XRenderComposite (dst->dpy, op, + src, mask, dst->picture, + extents->x + src_x, extents->y + src_y, + extents->x + mask_x, extents->y + mask_y, + extents->x - dst_x, extents->y - dst_y, + extents->width, extents->height); + + set_clip_region (dst, NULL); + + return CAIRO_STATUS_SUCCESS; +} + +/* font rendering */ + +void +_cairo_xlib_font_close (cairo_xlib_font_t *priv) +{ + cairo_xlib_display_t *display = (cairo_xlib_display_t *)priv->base.key; + int i; + + /* XXX All I really want is to do is zap my glyphs... */ + _cairo_scaled_font_reset_cache (priv->font); + + for (i = 0; i < NUM_GLYPHSETS; i++) { + cairo_xlib_font_glyphset_t *info; + + info = &priv->glyphset[i]; + if (info->glyphset) + XRenderFreeGlyphSet (display->display, info->glyphset); + } + + /* XXX locking */ + cairo_list_del (&priv->link); + cairo_list_del (&priv->base.link); + free (priv); +} + +static void +_cairo_xlib_font_fini (cairo_scaled_font_private_t *abstract_private, + cairo_scaled_font_t *font) +{ + cairo_xlib_font_t *priv = (cairo_xlib_font_t *) abstract_private; + cairo_status_t status; + cairo_xlib_display_t *display; + int i; + + cairo_list_del (&priv->base.link); + cairo_list_del (&priv->link); + + status = _cairo_xlib_display_acquire (priv->device, &display); + if (status) + goto BAIL; + + for (i = 0; i < NUM_GLYPHSETS; i++) { + cairo_xlib_font_glyphset_t *info; + + info = &priv->glyphset[i]; + if (info->glyphset) + XRenderFreeGlyphSet (display->display, info->glyphset); + } + + cairo_device_release (&display->base); +BAIL: + cairo_device_destroy (&display->base); + free (priv); +} + +static cairo_xlib_font_t * +_cairo_xlib_font_create (cairo_xlib_display_t *display, + cairo_scaled_font_t *font) +{ + cairo_xlib_font_t *priv; + int i; + + priv = malloc (sizeof (cairo_xlib_font_t)); + if (unlikely (priv == NULL)) + return NULL; + + _cairo_scaled_font_attach_private (font, &priv->base, display, + _cairo_xlib_font_fini); + + priv->device = cairo_device_reference (&display->base); + priv->font = font; + cairo_list_add (&priv->link, &display->fonts); + + for (i = 0; i < NUM_GLYPHSETS; i++) { + cairo_xlib_font_glyphset_t *info = &priv->glyphset[i]; + switch (i) { + case GLYPHSET_INDEX_ARGB32: info->format = CAIRO_FORMAT_ARGB32; break; + case GLYPHSET_INDEX_A8: info->format = CAIRO_FORMAT_A8; break; + case GLYPHSET_INDEX_A1: info->format = CAIRO_FORMAT_A1; break; + default: ASSERT_NOT_REACHED; break; + } + info->xrender_format = NULL; + info->glyphset = None; + info->to_free.count = 0; + } + + return priv; +} + +static int +_cairo_xlib_get_glyphset_index_for_format (cairo_format_t format) +{ + if (format == CAIRO_FORMAT_A8) + return GLYPHSET_INDEX_A8; + if (format == CAIRO_FORMAT_A1) + return GLYPHSET_INDEX_A1; + + assert (format == CAIRO_FORMAT_ARGB32); + return GLYPHSET_INDEX_ARGB32; +} + +static inline cairo_xlib_font_t * +_cairo_xlib_font_get (const cairo_xlib_display_t *display, + cairo_scaled_font_t *font) +{ + return (cairo_xlib_font_t *)_cairo_scaled_font_find_private (font, display); +} + +typedef struct { + cairo_scaled_glyph_private_t base; + + + cairo_xlib_font_glyphset_t *glyphset; +} cairo_xlib_glyph_private_t; + +static void +_cairo_xlib_glyph_fini (cairo_scaled_glyph_private_t *glyph_private, + cairo_scaled_glyph_t *glyph, + cairo_scaled_font_t *font) +{ + cairo_xlib_glyph_private_t *priv = (cairo_xlib_glyph_private_t *)glyph_private; + + if (! font->finished) { + cairo_xlib_font_t *font_private; + struct _cairo_xlib_font_glyphset_free_glyphs *to_free; + cairo_xlib_font_glyphset_t *info; + + font_private = _cairo_xlib_font_get (glyph_private->key, font); + assert (font_private); + + info = priv->glyphset; + to_free = &info->to_free; + if (to_free->count == ARRAY_LENGTH (to_free->indices)) { + cairo_xlib_display_t *display; + + if (_cairo_xlib_display_acquire (font_private->device, + &display) == CAIRO_STATUS_SUCCESS) { + XRenderFreeGlyphs (display->display, + info->glyphset, + to_free->indices, + to_free->count); + cairo_device_release (&display->base); + } + + to_free->count = 0; + } + + to_free->indices[to_free->count++] = + _cairo_scaled_glyph_index (glyph); + } + + cairo_list_del (&glyph_private->link); + free (glyph_private); +} + +static cairo_status_t +_cairo_xlib_glyph_attach (cairo_xlib_display_t *display, + cairo_scaled_glyph_t *glyph, + cairo_xlib_font_glyphset_t *info) +{ + cairo_xlib_glyph_private_t *priv; + + priv = malloc (sizeof (*priv)); + if (unlikely (priv == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + _cairo_scaled_glyph_attach_private (glyph, &priv->base, display, + _cairo_xlib_glyph_fini); + priv->glyphset = info; + + glyph->dev_private = info; + glyph->dev_private_key = display; + return CAIRO_STATUS_SUCCESS; +} + +static cairo_xlib_font_glyphset_t * +_cairo_xlib_font_get_glyphset_info_for_format (cairo_xlib_display_t *display, + cairo_scaled_font_t *font, + cairo_format_t format) +{ + cairo_xlib_font_t *priv; + cairo_xlib_font_glyphset_t *info; + int glyphset_index; + + glyphset_index = _cairo_xlib_get_glyphset_index_for_format (format); + + priv = _cairo_xlib_font_get (display, font); + if (priv == NULL) { + priv = _cairo_xlib_font_create (display, font); + if (priv == NULL) + return NULL; + } + + info = &priv->glyphset[glyphset_index]; + if (info->glyphset == None) { + info->xrender_format = + _cairo_xlib_display_get_xrender_format (display, info->format); + info->glyphset = XRenderCreateGlyphSet (display->display, + info->xrender_format); + } + + return info; +} + +static cairo_bool_t +has_pending_free_glyph (cairo_xlib_font_glyphset_t *info, + unsigned long glyph_index) +{ + struct _cairo_xlib_font_glyphset_free_glyphs *to_free; + int i; + + to_free = &info->to_free; + for (i = 0; i < to_free->count; i++) { + if (to_free->indices[i] == glyph_index) { + to_free->count--; + memmove (&to_free->indices[i], + &to_free->indices[i+1], + (to_free->count - i) * sizeof (to_free->indices[0])); + return TRUE; + } + } + + return FALSE; +} + +static cairo_xlib_font_glyphset_t * +find_pending_free_glyph (cairo_xlib_display_t *display, + cairo_scaled_font_t *font, + unsigned long glyph_index, + cairo_image_surface_t *surface) +{ + cairo_xlib_font_t *priv; + int i; + + priv = _cairo_xlib_font_get (display, font); + if (priv == NULL) + return NULL; + + if (surface != NULL) { + i = _cairo_xlib_get_glyphset_index_for_format (surface->format); + if (has_pending_free_glyph (&priv->glyphset[i], glyph_index)) + return &priv->glyphset[i]; + } else { + for (i = 0; i < NUM_GLYPHSETS; i++) { + if (has_pending_free_glyph (&priv->glyphset[i], glyph_index)) + return &priv->glyphset[i]; + } + } + + return NULL; +} + +static cairo_status_t +_cairo_xlib_surface_add_glyph (cairo_xlib_display_t *display, + cairo_scaled_font_t *font, + cairo_scaled_glyph_t **pscaled_glyph) +{ + XGlyphInfo glyph_info; + unsigned long glyph_index; + unsigned char *data; + cairo_status_t status = CAIRO_STATUS_SUCCESS; + cairo_scaled_glyph_t *glyph = *pscaled_glyph; + cairo_image_surface_t *glyph_surface = glyph->surface; + cairo_bool_t already_had_glyph_surface; + cairo_xlib_font_glyphset_t *info; + + glyph_index = _cairo_scaled_glyph_index (glyph); + + /* check to see if we have a pending XRenderFreeGlyph for this glyph */ + info = find_pending_free_glyph (display, font, glyph_index, glyph_surface); + if (info != NULL) + return _cairo_xlib_glyph_attach (display, glyph, info); + + if (glyph_surface == NULL) { + status = _cairo_scaled_glyph_lookup (font, + glyph_index, + CAIRO_SCALED_GLYPH_INFO_METRICS | + CAIRO_SCALED_GLYPH_INFO_SURFACE, + pscaled_glyph); + if (unlikely (status)) + return status; + + glyph = *pscaled_glyph; + glyph_surface = glyph->surface; + already_had_glyph_surface = FALSE; + } else { + already_had_glyph_surface = TRUE; + } + + info = _cairo_xlib_font_get_glyphset_info_for_format (display, font, + glyph_surface->format); + +#if 0 + /* If the glyph surface has zero height or width, we create + * a clear 1x1 surface, to avoid various X server bugs. + */ + if (glyph_surface->width == 0 || glyph_surface->height == 0) { + cairo_surface_t *tmp_surface; + + tmp_surface = cairo_image_surface_create (info->format, 1, 1); + status = tmp_surface->status; + if (unlikely (status)) + goto BAIL; + + tmp_surface->device_transform = glyph_surface->base.device_transform; + tmp_surface->device_transform_inverse = glyph_surface->base.device_transform_inverse; + + glyph_surface = (cairo_image_surface_t *) tmp_surface; + } +#endif + + /* If the glyph format does not match the font format, then we + * create a temporary surface for the glyph image with the font's + * format. + */ + if (glyph_surface->format != info->format) { + cairo_surface_pattern_t pattern; + cairo_surface_t *tmp_surface; + + tmp_surface = cairo_image_surface_create (info->format, + glyph_surface->width, + glyph_surface->height); + status = tmp_surface->status; + if (unlikely (status)) + goto BAIL; + + tmp_surface->device_transform = glyph_surface->base.device_transform; + tmp_surface->device_transform_inverse = glyph_surface->base.device_transform_inverse; + + _cairo_pattern_init_for_surface (&pattern, &glyph_surface->base); + status = _cairo_surface_paint (tmp_surface, + CAIRO_OPERATOR_SOURCE, &pattern.base, + NULL); + _cairo_pattern_fini (&pattern.base); + + glyph_surface = (cairo_image_surface_t *) tmp_surface; + + if (unlikely (status)) + goto BAIL; + } + + /* XXX: FRAGILE: We're ignore device_transform scaling here. A bug? */ + glyph_info.x = _cairo_lround (glyph_surface->base.device_transform.x0); + glyph_info.y = _cairo_lround (glyph_surface->base.device_transform.y0); + glyph_info.width = glyph_surface->width; + glyph_info.height = glyph_surface->height; + glyph_info.xOff = glyph->x_advance; + glyph_info.yOff = glyph->y_advance; + + data = glyph_surface->data; + + /* flip formats around */ + switch (_cairo_xlib_get_glyphset_index_for_format (glyph->surface->format)) { + case GLYPHSET_INDEX_A1: + /* local bitmaps are always stored with bit == byte */ + if (_cairo_is_little_endian() != (BitmapBitOrder (display->display) == LSBFirst)) { + int c = glyph_surface->stride * glyph_surface->height; + unsigned char *d; + unsigned char *new, *n; + + new = malloc (c); + if (!new) { + status = _cairo_error (CAIRO_STATUS_NO_MEMORY); + goto BAIL; + } + n = new; + d = data; + do { + char b = *d++; + b = ((b << 1) & 0xaa) | ((b >> 1) & 0x55); + b = ((b << 2) & 0xcc) | ((b >> 2) & 0x33); + b = ((b << 4) & 0xf0) | ((b >> 4) & 0x0f); + *n++ = b; + } while (--c); + data = new; + } + break; + case GLYPHSET_INDEX_A8: + break; + case GLYPHSET_INDEX_ARGB32: + if (_cairo_is_little_endian() != (ImageByteOrder (display->display) == LSBFirst)) { + unsigned int c = glyph_surface->stride * glyph_surface->height / 4; + const uint32_t *d; + uint32_t *new, *n; + + new = malloc (4 * c); + if (unlikely (new == NULL)) { + status = _cairo_error (CAIRO_STATUS_NO_MEMORY); + goto BAIL; + } + n = new; + d = (uint32_t *) data; + do { + *n++ = bswap_32 (*d); + d++; + } while (--c); + data = (uint8_t *) new; + } + break; + default: + ASSERT_NOT_REACHED; + break; + } + /* XXX assume X server wants pixman padding. Xft assumes this as well */ + + XRenderAddGlyphs (display->display, info->glyphset, + &glyph_index, &glyph_info, 1, + (char *) data, + glyph_surface->stride * glyph_surface->height); + + if (data != glyph_surface->data) + free (data); + + status = _cairo_xlib_glyph_attach (display, glyph, info); + + BAIL: + if (glyph_surface != glyph->surface) + cairo_surface_destroy (&glyph_surface->base); + + /* if the scaled glyph didn't already have a surface attached + * to it, release the created surface now that we have it + * uploaded to the X server. If the surface has already been + * there (eg. because image backend requested it), leave it in + * the cache + */ + if (!already_had_glyph_surface) + _cairo_scaled_glyph_set_surface (glyph, font, NULL); + + return status; +} + +typedef void (*cairo_xrender_composite_text_func_t) + (Display *dpy, + int op, + Picture src, + Picture dst, + _Xconst XRenderPictFormat *maskFormat, + int xSrc, + int ySrc, + int xDst, + int yDst, + _Xconst XGlyphElt8 *elts, + int nelt); + +/* Build a struct of the same size of #cairo_glyph_t that can be used both as + * an input glyph with double coordinates, and as "working" glyph with + * integer from-current-point offsets. */ +typedef union { + cairo_glyph_t d; + unsigned long index; + struct { + unsigned long index; + int x; + int y; + } i; +} cairo_xlib_glyph_t; + +/* compile-time assert that #cairo_xlib_glyph_t is the same size as #cairo_glyph_t */ +COMPILE_TIME_ASSERT (sizeof (cairo_xlib_glyph_t) == sizeof (cairo_glyph_t)); + +/* Start a new element for the first glyph, + * or for any glyph that has unexpected position, + * or if current element has too many glyphs + * (Xrender limits each element to 252 glyphs, we limit them to 128) + * + * These same conditions need to be mirrored between + * _cairo_xlib_surface_emit_glyphs and _emit_glyph_chunks + */ +#define _start_new_glyph_elt(count, glyph) \ + (((count) & 127) == 0 || (glyph)->i.x || (glyph)->i.y) + +static cairo_status_t +_emit_glyphs_chunk (cairo_xlib_display_t *display, + cairo_xlib_surface_t *dst, + int dst_x, int dst_y, + cairo_xlib_glyph_t *glyphs, + int num_glyphs, + cairo_scaled_font_t *font, + cairo_bool_t use_mask, + cairo_operator_t op, + cairo_xlib_source_t *src, + int src_x, int src_y, + /* info for this chunk */ + int num_elts, + int width, + cairo_xlib_font_glyphset_t *info) +{ + /* Which XRenderCompositeText function to use */ + cairo_xrender_composite_text_func_t composite_text_func; + int size; + + /* Element buffer stuff */ + XGlyphElt8 *elts; + XGlyphElt8 stack_elts[CAIRO_STACK_ARRAY_LENGTH (XGlyphElt8)]; + + /* Reuse the input glyph array for output char generation */ + char *char8 = (char *) glyphs; + unsigned short *char16 = (unsigned short *) glyphs; + unsigned int *char32 = (unsigned int *) glyphs; + + int i; + int nelt; /* Element index */ + int n; /* Num output glyphs in current element */ + int j; /* Num output glyphs so far */ + + switch (width) { + case 1: + /* don't cast the 8-variant, to catch possible mismatches */ + composite_text_func = XRenderCompositeText8; + size = sizeof (char); + break; + case 2: + composite_text_func = (cairo_xrender_composite_text_func_t) XRenderCompositeText16; + size = sizeof (unsigned short); + break; + default: + case 4: + composite_text_func = (cairo_xrender_composite_text_func_t) XRenderCompositeText32; + size = sizeof (unsigned int); + } + + /* Allocate element array */ + if (num_elts <= ARRAY_LENGTH (stack_elts)) { + elts = stack_elts; + } else { + elts = _cairo_malloc_ab (num_elts, sizeof (XGlyphElt8)); + if (unlikely (elts == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + /* Fill them in */ + nelt = 0; + n = 0; + j = 0; + for (i = 0; i < num_glyphs; i++) { + /* Start a new element for first output glyph, + * or for any glyph that has unexpected position, + * or if current element has too many glyphs. + * + * These same conditions are mirrored in _cairo_xlib_surface_emit_glyphs() + */ + if (_start_new_glyph_elt (j, &glyphs[i])) { + if (j) { + elts[nelt].nchars = n; + nelt++; + n = 0; + } + elts[nelt].chars = char8 + size * j; + elts[nelt].glyphset = info->glyphset; + elts[nelt].xOff = glyphs[i].i.x; + elts[nelt].yOff = glyphs[i].i.y; + } + + switch (width) { + case 1: char8 [j] = (char) glyphs[i].index; break; + case 2: char16[j] = (unsigned short) glyphs[i].index; break; + default: + case 4: char32[j] = (unsigned int) glyphs[i].index; break; + } + + n++; + j++; + } + + if (n) { + elts[nelt].nchars = n; + nelt++; + } + + /* Check that we agree with _cairo_xlib_surface_emit_glyphs() on the + * expected number of xGlyphElts. */ + assert (nelt == num_elts); + + composite_text_func (display->display, op, + src->picture, + dst->picture, + use_mask ? info->xrender_format : NULL, + src_x + elts[0].xOff, + src_y + elts[0].yOff, + elts[0].xOff - dst_x, elts[0].yOff - dst_y, + (XGlyphElt8 *) elts, nelt); + + if (elts != stack_elts) + free (elts); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +check_composite_glyphs (const cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *font, + cairo_glyph_t *glyphs, + int *num_glyphs) +{ + cairo_xlib_surface_t *dst = (cairo_xlib_surface_t *)extents->surface; + cairo_xlib_display_t *display = dst->display; + int max_request_size, size; + + if (! CAIRO_RENDER_SUPPORTS_OPERATOR (display, extents->op)) + return CAIRO_INT_STATUS_UNSUPPORTED; + + /* The glyph coordinates must be representable in an int16_t. + * When possible, they will be expressed as an offset from the + * previous glyph, otherwise they will be an offset from the + * surface origin. If we can't guarantee this to be possible, + * fallback. + */ + if (extents->bounded.x + extents->bounded.width > INT16_MAX || + extents->bounded.y + extents->bounded.height> INT16_MAX || + extents->bounded.x < INT16_MIN || + extents->bounded.y < INT16_MIN) + { + return CAIRO_INT_STATUS_UNSUPPORTED; + } + + /* Approximate the size of the largest glyph and fallback if we can not + * upload it to the xserver. + */ + size = ceil (font->max_scale); + size = 4 * size * size; + max_request_size = (XExtendedMaxRequestSize (display->display) ? XExtendedMaxRequestSize (display->display) + : XMaxRequestSize (display->display)) * 4 - + sz_xRenderAddGlyphsReq - + sz_xGlyphInfo - + 8; + if (size >= max_request_size) + return CAIRO_INT_STATUS_UNSUPPORTED; + + return CAIRO_STATUS_SUCCESS; +} + +/* sz_xGlyphtElt required alignment to a 32-bit boundary, so ensure we have + * enough room for padding */ +#define _cairo_sz_xGlyphElt (sz_xGlyphElt + 4) + +static cairo_int_status_t +composite_glyphs (void *surface, + cairo_operator_t op, + cairo_surface_t *_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + cairo_composite_glyphs_info_t *info) +{ + cairo_xlib_surface_t *dst = surface; + cairo_xlib_glyph_t *glyphs = (cairo_xlib_glyph_t *)info->glyphs; + cairo_xlib_source_t *src = (cairo_xlib_source_t *)_src; + cairo_xlib_display_t *display = dst->display; + cairo_int_status_t status = CAIRO_INT_STATUS_SUCCESS; + cairo_scaled_glyph_t *glyph; + cairo_fixed_t x = 0, y = 0; + cairo_xlib_font_glyphset_t *glyphset = NULL, *this_glyphset_info; + + unsigned long max_index = 0; + int width = 1; + int num_elts = 0; + int num_out_glyphs = 0; + int num_glyphs = info->num_glyphs; + + int max_request_size = XMaxRequestSize (display->display) * 4 + - MAX (sz_xRenderCompositeGlyphs8Req, + MAX(sz_xRenderCompositeGlyphs16Req, + sz_xRenderCompositeGlyphs32Req)); + int request_size = 0; + int i; + + op = _render_operator (op), + _cairo_xlib_surface_ensure_picture (dst); + for (i = 0; i < num_glyphs; i++) { + int this_x, this_y; + int old_width; + + status = _cairo_scaled_glyph_lookup (info->font, + glyphs[i].index, + CAIRO_SCALED_GLYPH_INFO_METRICS, + &glyph); + if (unlikely (status)) + return status; + + this_x = _cairo_lround (glyphs[i].d.x); + this_y = _cairo_lround (glyphs[i].d.y); + + /* Send unsent glyphs to the server */ + if (glyph->dev_private_key != display) { + status = _cairo_xlib_surface_add_glyph (display, info->font, &glyph); + if (unlikely (status)) + return status; + } + + this_glyphset_info = glyph->dev_private; + if (!glyphset) + glyphset = this_glyphset_info; + + /* The invariant here is that we can always flush the glyphs + * accumulated before this one, using old_width, and they + * would fit in the request. + */ + old_width = width; + + /* Update max glyph index */ + if (glyphs[i].index > max_index) { + max_index = glyphs[i].index; + if (max_index >= 65536) + width = 4; + else if (max_index >= 256) + width = 2; + if (width != old_width) + request_size += (width - old_width) * num_out_glyphs; + } + + /* If we will pass the max request size by adding this glyph, + * flush current glyphs. Note that we account for a + * possible element being added below. + * + * Also flush if changing glyphsets, as Xrender limits one mask + * format per request, so we can either break up, or use a + * wide-enough mask format. We do the former. One reason to + * prefer the latter is the fact that Xserver ADDs all glyphs + * to the mask first, and then composes that to final surface, + * though it's not a big deal. + * + * If the glyph has a coordinate which cannot be represented + * as a 16-bit offset from the previous glyph, flush the + * current chunk. The current glyph will be the first one in + * the next chunk, thus its coordinates will be an offset from + * the destination origin. This offset is guaranteed to be + * representable as 16-bit offset (otherwise we would have + * fallen back). + */ + if (request_size + width > max_request_size - _cairo_sz_xGlyphElt || + this_x - x > INT16_MAX || this_x - x < INT16_MIN || + this_y - y > INT16_MAX || this_y - y < INT16_MIN || + (this_glyphset_info != glyphset)) { + status = _emit_glyphs_chunk (display, dst, dst_x, dst_y, + glyphs, i, info->font, info->use_mask, + op, src, src_x, src_y, + num_elts, old_width, glyphset); + if (unlikely (status)) + return status; + + glyphs += i; + num_glyphs -= i; + i = 0; + max_index = glyphs[i].index; + width = max_index < 256 ? 1 : max_index < 65536 ? 2 : 4; + request_size = 0; + num_elts = 0; + num_out_glyphs = 0; + x = y = 0; + glyphset = this_glyphset_info; + } + + /* Convert absolute glyph position to relative-to-current-point + * position */ + glyphs[i].i.x = this_x - x; + glyphs[i].i.y = this_y - y; + + /* Start a new element for the first glyph, + * or for any glyph that has unexpected position, + * or if current element has too many glyphs. + * + * These same conditions are mirrored in _emit_glyphs_chunk(). + */ + if (_start_new_glyph_elt (num_out_glyphs, &glyphs[i])) { + num_elts++; + request_size += _cairo_sz_xGlyphElt; + } + + /* adjust current-position */ + x = this_x + glyph->x_advance; + y = this_y + glyph->y_advance; + + num_out_glyphs++; + request_size += width; + } + + if (num_elts) { + status = _emit_glyphs_chunk (display, dst, dst_x, dst_y, + glyphs, i, info->font, info->use_mask, + op, src, src_x, src_y, + num_elts, width, glyphset); + } + + return status; +} + +const cairo_compositor_t * +_cairo_xlib_mask_compositor_get (void) +{ + static cairo_mask_compositor_t compositor; + + if (compositor.base.delegate == NULL) { + _cairo_mask_compositor_init (&compositor, + _cairo_xlib_fallback_compositor_get ()); + + compositor.acquire = acquire; + compositor.release = release; + compositor.set_clip_region = set_clip_region; + compositor.pattern_to_surface = _cairo_xlib_source_create_for_pattern; + compositor.draw_image_boxes = draw_image_boxes; + compositor.fill_rectangles = fill_rectangles; + compositor.fill_boxes = fill_boxes; + //compositor.check_composite = check_composite; + compositor.composite = composite; + //compositor.check_composite_boxes = check_composite_boxes; + compositor.composite_boxes = composite_boxes; + compositor.check_composite_glyphs = check_composite_glyphs; + compositor.composite_glyphs = composite_glyphs; + } + + return &compositor.base; +} + +#define CAIRO_FIXED_16_16_MIN -32768 +#define CAIRO_FIXED_16_16_MAX 32767 + +static cairo_bool_t +line_exceeds_16_16 (const cairo_line_t *line) +{ + return + line->p1.x < _cairo_fixed_from_int (CAIRO_FIXED_16_16_MIN) || + line->p1.x > _cairo_fixed_from_int (CAIRO_FIXED_16_16_MAX) || + line->p2.x < _cairo_fixed_from_int (CAIRO_FIXED_16_16_MIN) || + line->p2.x > _cairo_fixed_from_int (CAIRO_FIXED_16_16_MAX) || + line->p1.y < _cairo_fixed_from_int (CAIRO_FIXED_16_16_MIN) || + line->p1.y > _cairo_fixed_from_int (CAIRO_FIXED_16_16_MAX) || + line->p2.y < _cairo_fixed_from_int (CAIRO_FIXED_16_16_MIN) || + line->p2.y > _cairo_fixed_from_int (CAIRO_FIXED_16_16_MAX); +} + +static void +project_line_x_onto_16_16 (const cairo_line_t *line, + cairo_fixed_t top, + cairo_fixed_t bottom, + XLineFixed *out) +{ + cairo_point_double_t p1, p2; + double m; + + p1.x = _cairo_fixed_to_double (line->p1.x); + p1.y = _cairo_fixed_to_double (line->p1.y); + + p2.x = _cairo_fixed_to_double (line->p2.x); + p2.y = _cairo_fixed_to_double (line->p2.y); + + m = (p2.x - p1.x) / (p2.y - p1.y); + out->p1.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (top - line->p1.y)); + out->p2.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (bottom - line->p1.y)); +} +#if 0 +static cairo_int_status_T +check_composite_trapezoids () +{ + operation = _categorize_composite_operation (dst, op, pattern, TRUE); + if (operation == DO_UNSUPPORTED) + return UNSUPPORTED ("unsupported operation"); + + operation = _recategorize_composite_operation (dst, op, src, + &attributes, TRUE); + if (operation == DO_UNSUPPORTED) { + status = UNSUPPORTED ("unsupported operation"); + goto BAIL; + } + +} +#endif + +static cairo_int_status_t +composite_traps (void *abstract_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_antialias_t antialias, + cairo_traps_t *traps) +{ + cairo_xlib_surface_t *dst = abstract_dst; + cairo_xlib_display_t *display = dst->display; + cairo_xlib_source_t *src = (cairo_xlib_source_t *)abstract_src; + XRenderPictFormat *pict_format; + XTrapezoid xtraps_stack[CAIRO_STACK_ARRAY_LENGTH (XTrapezoid)]; + XTrapezoid *xtraps = xtraps_stack; + int dx, dy; + int i; + + //X_DEBUG ((display->display, "composite_trapezoids (dst=%x)", (unsigned int) dst->drawable)); + + pict_format = + _cairo_xlib_display_get_xrender_format (display, + antialias == CAIRO_ANTIALIAS_NONE ? CAIRO_FORMAT_A1 : CAIRO_FORMAT_A8); + + if (traps->num_traps > ARRAY_LENGTH (xtraps_stack)) { + xtraps = _cairo_malloc_ab (traps->num_traps, sizeof (XTrapezoid)); + if (unlikely (xtraps == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + dx = -dst_x << 16; + dy = -dst_y << 16; + for (i = 0; i < traps->num_traps; i++) { + cairo_trapezoid_t *t = &traps->traps[i]; + + /* top/bottom will be clamped to surface bounds */ + xtraps[i].top = _cairo_fixed_to_16_16(t->top) + dy; + xtraps[i].bottom = _cairo_fixed_to_16_16(t->bottom) + dy; + + /* However, all the other coordinates will have been left untouched so + * as not to introduce numerical error. Recompute them if they + * exceed the 16.16 limits. + */ + if (unlikely (line_exceeds_16_16 (&t->left))) { + project_line_x_onto_16_16 (&t->left, t->top, t->bottom, + &xtraps[i].left); + xtraps[i].left.p1.x += dx; + xtraps[i].left.p2.x += dx; + xtraps[i].left.p1.y = xtraps[i].top; + xtraps[i].left.p2.y = xtraps[i].bottom; + } else { + xtraps[i].left.p1.x = _cairo_fixed_to_16_16(t->left.p1.x) + dx; + xtraps[i].left.p1.y = _cairo_fixed_to_16_16(t->left.p1.y) + dy; + xtraps[i].left.p2.x = _cairo_fixed_to_16_16(t->left.p2.x) + dx; + xtraps[i].left.p2.y = _cairo_fixed_to_16_16(t->left.p2.y) + dy; + } + + if (unlikely (line_exceeds_16_16 (&t->right))) { + project_line_x_onto_16_16 (&t->right, t->top, t->bottom, + &xtraps[i].right); + xtraps[i].right.p1.x += dx; + xtraps[i].right.p2.x += dx; + xtraps[i].right.p1.y = xtraps[i].top; + xtraps[i].right.p2.y = xtraps[i].bottom; + } else { + xtraps[i].right.p1.x = _cairo_fixed_to_16_16(t->right.p1.x) + dx; + xtraps[i].right.p1.y = _cairo_fixed_to_16_16(t->right.p1.y) + dy; + xtraps[i].right.p2.x = _cairo_fixed_to_16_16(t->right.p2.x) + dx; + xtraps[i].right.p2.y = _cairo_fixed_to_16_16(t->right.p2.y) + dy; + } + } + + if (xtraps[0].left.p1.y < xtraps[0].left.p2.y) { + src_x += _cairo_fixed_16_16_floor (xtraps[0].left.p1.x); + src_y += _cairo_fixed_16_16_floor (xtraps[0].left.p1.y); + } else { + src_x += _cairo_fixed_16_16_floor (xtraps[0].left.p2.x); + src_y += _cairo_fixed_16_16_floor (xtraps[0].left.p2.y); + } + src_x += dst_x; + src_y += dst_y; + + _cairo_xlib_surface_ensure_picture (dst); + _cairo_xlib_surface_set_precision (dst, antialias); + XRenderCompositeTrapezoids (dst->dpy, + _render_operator (op), + src->picture, dst->picture, + pict_format, + src_x, src_y, + xtraps, traps->num_traps); + + if (xtraps != xtraps_stack) + free (xtraps); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_tristrip (void *abstract_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_antialias_t antialias, + cairo_tristrip_t *strip) +{ + cairo_xlib_surface_t *dst = abstract_dst; + cairo_xlib_display_t *display = dst->display; + cairo_xlib_source_t *src = (cairo_xlib_source_t *)abstract_src; + XRenderPictFormat *pict_format; + XPointFixed points_stack[CAIRO_STACK_ARRAY_LENGTH (XPointFixed)]; + XPointFixed *points = points_stack; + int dx, dy; + int i; + + //X_DEBUG ((display->display, "composite_trapezoids (dst=%x)", (unsigned int) dst->drawable)); + + pict_format = + _cairo_xlib_display_get_xrender_format (display, + antialias == CAIRO_ANTIALIAS_NONE ? CAIRO_FORMAT_A1 : CAIRO_FORMAT_A8); + + if (strip->num_points > ARRAY_LENGTH (points_stack)) { + points = _cairo_malloc_ab (strip->num_points, sizeof (XPointFixed)); + if (unlikely (points == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + dx = -dst_x << 16; + dy = -dst_y << 16; + for (i = 0; i < strip->num_points; i++) { + cairo_point_t *p = &strip->points[i]; + + points[i].x = _cairo_fixed_to_16_16(p->x) + dx; + points[i].y = _cairo_fixed_to_16_16(p->y) + dy; + } + + src_x += _cairo_fixed_16_16_floor (points[0].x) + dst_x; + src_y += _cairo_fixed_16_16_floor (points[0].y) + dst_y; + + _cairo_xlib_surface_ensure_picture (dst); + _cairo_xlib_surface_set_precision (dst, antialias); + XRenderCompositeTriStrip (dst->dpy, + _render_operator (op), + src->picture, dst->picture, + pict_format, + src_x, src_y, + points, strip->num_points); + + if (points != points_stack) + free (points); + + return CAIRO_STATUS_SUCCESS; +} + +const cairo_compositor_t * +_cairo_xlib_traps_compositor_get (void) +{ + static cairo_traps_compositor_t compositor; + + if (compositor.base.delegate == NULL) { + _cairo_traps_compositor_init (&compositor, + _cairo_xlib_mask_compositor_get ()); + + compositor.acquire = acquire; + compositor.release = release; + compositor.set_clip_region = set_clip_region; + compositor.pattern_to_surface = _cairo_xlib_source_create_for_pattern; + compositor.draw_image_boxes = draw_image_boxes; + compositor.copy_boxes = copy_boxes; + compositor.fill_boxes = fill_boxes; + //compositor.check_composite = check_composite; + compositor.composite = composite; + compositor.lerp = lerp; + //compositor.check_composite_boxes = check_composite_boxes; + compositor.composite_boxes = composite_boxes; + //compositor.check_composite_traps = check_composite_traps; + compositor.composite_traps = composite_traps; + //compositor.check_composite_tristrip = check_composite_tristrip; + compositor.composite_tristrip = composite_tristrip; + compositor.check_composite_glyphs = check_composite_glyphs; + compositor.composite_glyphs = composite_glyphs; + } + + return &compositor.base; +} diff --git a/src/cairo-xlib-screen.c b/src/cairo-xlib-screen.c index 356131fa..7bfdf158 100644 --- a/src/cairo-xlib-screen.c +++ b/src/cairo-xlib-screen.c @@ -269,8 +269,8 @@ _cairo_xlib_init_screen_font_options (Display *dpy, } void -_cairo_xlib_screen_close_display (cairo_xlib_display_t *display, - cairo_xlib_screen_t *info) +_cairo_xlib_screen_destroy (cairo_xlib_display_t *display, + cairo_xlib_screen_t *info) { Display *dpy; int i; @@ -292,11 +292,7 @@ _cairo_xlib_screen_close_display (cairo_xlib_display_t *display, info->gc_depths[i] = 0; } } -} -void -_cairo_xlib_screen_destroy (cairo_xlib_screen_t *info) -{ while (! cairo_list_is_empty (&info->visuals)) { _cairo_xlib_visual_info_destroy (cairo_list_first_entry (&info->visuals, cairo_xlib_visual_info_t, @@ -403,19 +399,9 @@ _cairo_xlib_screen_put_gc (cairo_xlib_display_t *display, } if (i == ARRAY_LENGTH (info->gc)) { - cairo_status_t status; - /* perform random substitution to ensure fair caching over depths */ i = rand () % ARRAY_LENGTH (info->gc); - status = - _cairo_xlib_display_queue_work (display, - (cairo_xlib_notify_func) XFreeGC, - info->gc[i], - NULL); - if (unlikely (status)) { - /* leak the server side resource... */ - XFree ((char *) info->gc[i]); - } + XFreeGC(display->display, info->gc[i]); } info->gc[i] = gc; diff --git a/src/cairo-xlib-source.c b/src/cairo-xlib-source.c new file mode 100644 index 00000000..dc5aa7a0 --- /dev/null +++ b/src/cairo-xlib-source.c @@ -0,0 +1,938 @@ +/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it either under the terms of the GNU Lesser General Public + * License version 2.1 as published by the Free Software Foundation + * (the "LGPL") or, at your option, under the terms of the Mozilla + * Public License Version 1.1 (the "MPL"). If you do not alter this + * notice, a recipient may use your version of this file under either + * the MPL or the LGPL. + * + * You should have received a copy of the LGPL along with this library + * in the file COPYING-LGPL-2.1; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA + * You should have received a copy of the MPL along with this library + * in the file COPYING-MPL-1.1 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Behdad Esfahbod <behdad@behdad.org> + * Chris Wilson <chris@chris-wilson.co.uk> + * Karl Tomlinson <karlt+@karlt.net>, Mozilla Corporation + */ +#include "cairoint.h" + +#if !CAIRO_HAS_XLIB_XCB_FUNCTIONS + +#include "cairo-xlib-private.h" +#include "cairo-xlib-surface-private.h" + +#include "cairo-error-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-paginated-private.h" +#include "cairo-pattern-private.h" +#include "cairo-recording-surface-private.h" +#include "cairo-surface-backend-private.h" +#include "cairo-surface-offset-private.h" +#include "cairo-surface-observer-private.h" +#include "cairo-surface-snapshot-private.h" + +#define PIXMAN_MAX_INT ((pixman_fixed_1 >> 1) - pixman_fixed_e) /* need to ensure deltas also fit */ + +static cairo_surface_t * +unwrap_surface (cairo_surface_t *surface, int *tx, int *ty) +{ + *tx = *ty = 0; + + if (_cairo_surface_is_paginated (surface)) + surface = _cairo_paginated_surface_get_recording (surface); + if (_cairo_surface_is_snapshot (surface)) + surface = _cairo_surface_snapshot_get_target (surface); + if (_cairo_surface_is_observer (surface)) + surface = _cairo_surface_observer_get_target (surface); + return surface; +} + +static cairo_status_t +_cairo_xlib_source_finish (void *abstract_surface) +{ + cairo_xlib_source_t *source = abstract_surface; + + XRenderFreePicture (source->dpy, source->picture); + return CAIRO_STATUS_SUCCESS; +} + +static const cairo_surface_backend_t cairo_xlib_source_backend = { + CAIRO_SURFACE_TYPE_IMAGE, + _cairo_xlib_source_finish, + NULL, /* read-only wrapper */ +}; + +static cairo_surface_t * +source (cairo_xlib_surface_t *dst, Picture picture) +{ + cairo_xlib_source_t *source; + + if (picture == None) + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + + source = malloc (sizeof (cairo_image_surface_t)); + if (unlikely (source == NULL)) { + XRenderFreePicture (dst->display->display, picture); + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + } + + _cairo_surface_init (&source->base, + &cairo_xlib_source_backend, + NULL, /* device */ + CAIRO_CONTENT_COLOR_ALPHA); + + /* The source exists only within an operation */ + source->picture = picture; + source->dpy = dst->display->display; + + return &source->base; +} + +static uint32_t +hars_petruska_f54_1_random (void) +{ +#define rol(x,k) ((x << k) | (x >> (32-k))) + static uint32_t x; + return x = (x ^ rol (x, 5) ^ rol (x, 24)) + 0x37798849; +#undef rol +} + +static const XTransform identity = { + { + { 1 << 16, 0x00000, 0x00000 }, + { 0x00000, 1 << 16, 0x00000 }, + { 0x00000, 0x00000, 1 << 16 }, + } +}; + +static cairo_bool_t +picture_set_matrix (cairo_xlib_display_t *display, + Picture picture, + const cairo_matrix_t *matrix, + cairo_filter_t filter, + double xc, + double yc, + int *x_offset, + int *y_offset) +{ + XTransform xtransform; + pixman_transform_t *pixman_transform; + cairo_int_status_t status; + + /* Casting between pixman_transform_t and XTransform is safe because + * they happen to be the exact same type. + */ + pixman_transform = (pixman_transform_t *) &xtransform; + status = _cairo_matrix_to_pixman_matrix_offset (matrix, filter, xc, yc, + pixman_transform, + x_offset, y_offset); + if (status == CAIRO_INT_STATUS_NOTHING_TO_DO) + return TRUE; + if (unlikely (status != CAIRO_INT_STATUS_SUCCESS)) + return FALSE; + + if (memcmp (&xtransform, &identity, sizeof (XTransform)) == 0) + return TRUE; + + /* a late check in case we perturb the matrix too far */ + if (! CAIRO_RENDER_HAS_PICTURE_TRANSFORM (display)) + return FALSE; + + XRenderSetPictureTransform (display->display, picture, &xtransform); + return TRUE; +} + +static cairo_status_t +picture_set_filter (Display *dpy, + Picture picture, + cairo_filter_t filter) +{ + const char *render_filter; + + switch (filter) { + case CAIRO_FILTER_FAST: + render_filter = FilterFast; + break; + case CAIRO_FILTER_GOOD: + render_filter = FilterGood; + break; + case CAIRO_FILTER_BEST: + render_filter = FilterBest; + break; + case CAIRO_FILTER_NEAREST: + render_filter = FilterNearest; + break; + case CAIRO_FILTER_BILINEAR: + render_filter = FilterBilinear; + break; + case CAIRO_FILTER_GAUSSIAN: + /* XXX: The GAUSSIAN value has no implementation in cairo + * whatsoever, so it was really a mistake to have it in the + * API. We could fix this by officially deprecating it, or + * else inventing semantics and providing an actual + * implementation for it. */ + default: + render_filter = FilterBest; + break; + } + + XRenderSetPictureFilter (dpy, picture, (char *) render_filter, NULL, 0); + return CAIRO_STATUS_SUCCESS; +} + +static int +extend_to_repeat (cairo_extend_t extend) +{ + switch (extend) { + default: + ASSERT_NOT_REACHED; + case CAIRO_EXTEND_NONE: + return RepeatNone; + case CAIRO_EXTEND_REPEAT: + return RepeatNormal; + case CAIRO_EXTEND_REFLECT: + return RepeatReflect; + case CAIRO_EXTEND_PAD: + return RepeatPad; + } +} + +static cairo_bool_t +picture_set_properties (cairo_xlib_display_t *display, + Picture picture, + const cairo_pattern_t *pattern, + const cairo_matrix_t *matrix, + const cairo_rectangle_int_t *extents, + int *x_off, int *y_off) +{ + XRenderPictureAttributes pa; + int mask = 0; + + if (! picture_set_matrix (display, picture, matrix, pattern->filter, + extents->x + extents->width / 2, + extents->y + extents->height / 2, + x_off, y_off)) + return FALSE; + + picture_set_filter (display->display, picture, pattern->filter); + + if (pattern->has_component_alpha) { + pa.component_alpha = 1; + mask |= CPComponentAlpha; + } + + if (pattern->extend != CAIRO_EXTEND_NONE) { + pa.repeat = extend_to_repeat (pattern->extend); + mask |= CPRepeat; + } + + if (mask) + XRenderChangePicture (display->display, picture, mask, &pa); + + return TRUE; +} + +static cairo_surface_t * +render_pattern (cairo_xlib_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + int *src_x, int *src_y) +{ + Display *dpy = dst->display->display; + cairo_xlib_surface_t *src; + cairo_surface_t *image; + cairo_status_t status; + + src = (cairo_xlib_surface_t *) + _cairo_surface_create_similar_scratch (&dst->base, + is_mask ? CAIRO_CONTENT_ALPHA : CAIRO_CONTENT_COLOR_ALPHA, + extents->width, + extents->height); + if (src->base.type != CAIRO_SURFACE_TYPE_XLIB) { + cairo_surface_destroy (&src->base); + return None; + } + + image = cairo_surface_map_to_image (&src->base, NULL); + status = _cairo_surface_offset_paint (image, extents->x, extents->y, + CAIRO_OPERATOR_SOURCE, pattern, + NULL); + cairo_surface_unmap_image (&src->base, image); + if (unlikely (status)) { + cairo_surface_destroy (&src->base); + return _cairo_surface_create_in_error (status); + } + + src->picture = XRenderCreatePicture (dpy, + src->drawable, src->xrender_format, + 0, NULL); + + *src_x = -extents->x; + *src_y = -extents->y; + return &src->base; +} + + +static cairo_surface_t * +gradient_source (cairo_xlib_surface_t *dst, + const cairo_gradient_pattern_t *gradient, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + int *src_x, int *src_y) +{ + cairo_xlib_display_t *display = dst->display; + cairo_matrix_t matrix = gradient->base.matrix; + char buf[CAIRO_STACK_BUFFER_SIZE]; + cairo_circle_double_t extremes[2]; + XFixed *stops; + XRenderColor *colors; + Picture picture; + unsigned int i, n_stops; + + /* The RENDER specification says that the inner circle has + * to be completely contained inside the outer one. */ + if (gradient->base.type == CAIRO_PATTERN_TYPE_RADIAL && + ! _cairo_radial_pattern_focus_is_inside ((cairo_radial_pattern_t *) gradient)) + return render_pattern (dst, &gradient->base, is_mask, extents, src_x, src_y); + + assert (gradient->n_stops > 0); + n_stops = MAX (gradient->n_stops, 2); + + if (n_stops < sizeof (buf) / (sizeof (XFixed) + sizeof (XRenderColor))) + { + stops = (XFixed *) buf; + } + else + { + stops = + _cairo_malloc_ab (n_stops, + sizeof (XFixed) + sizeof (XRenderColor)); + if (unlikely (stops == NULL)) + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + } + + colors = (XRenderColor *) (stops + n_stops); + for (i = 0; i < gradient->n_stops; i++) { + stops[i] = + _cairo_fixed_16_16_from_double (gradient->stops[i].offset); + + colors[i].red = gradient->stops[i].color.red_short; + colors[i].green = gradient->stops[i].color.green_short; + colors[i].blue = gradient->stops[i].color.blue_short; + colors[i].alpha = gradient->stops[i].color.alpha_short; + } + + /* RENDER does not support gradients with less than 2 + * stops. If a gradient has only a single stop, duplicate + * it to make RENDER happy. */ + if (gradient->n_stops == 1) { + stops[1] = + _cairo_fixed_16_16_from_double (gradient->stops[0].offset); + + colors[1].red = gradient->stops[0].color.red_short; + colors[1].green = gradient->stops[0].color.green_short; + colors[1].blue = gradient->stops[0].color.blue_short; + colors[1].alpha = gradient->stops[0].color.alpha_short; + } + +#if 0 + /* For some weird reason the X server is sometimes getting + * CreateGradient requests with bad length. So far I've only seen + * XRenderCreateLinearGradient request with 4 stops sometime end up + * with length field matching 0 stops at the server side. I've + * looked at the libXrender code and I can't see anything that + * could cause this behavior. However, for some reason having a + * XSync call here seems to avoid the issue so I'll keep it here + * until it's solved. + */ + XSync (display->display, False); +#endif + + _cairo_gradient_pattern_fit_to_range (gradient, PIXMAN_MAX_INT >> 1, &matrix, extremes); + + if (gradient->base.type == CAIRO_PATTERN_TYPE_LINEAR) { + XLinearGradient grad; + + grad.p1.x = _cairo_fixed_16_16_from_double (extremes[0].center.x); + grad.p1.y = _cairo_fixed_16_16_from_double (extremes[0].center.y); + grad.p2.x = _cairo_fixed_16_16_from_double (extremes[1].center.x); + grad.p2.y = _cairo_fixed_16_16_from_double (extremes[1].center.y); + + picture = XRenderCreateLinearGradient (display->display, &grad, + stops, colors, + n_stops); + } else { + XRadialGradient grad; + + grad.inner.x = _cairo_fixed_16_16_from_double (extremes[0].center.x); + grad.inner.y = _cairo_fixed_16_16_from_double (extremes[0].center.y); + grad.inner.radius = _cairo_fixed_16_16_from_double (extremes[0].radius); + grad.outer.x = _cairo_fixed_16_16_from_double (extremes[1].center.x); + grad.outer.y = _cairo_fixed_16_16_from_double (extremes[1].center.y); + grad.outer.radius = _cairo_fixed_16_16_from_double (extremes[1].radius); + + picture = XRenderCreateRadialGradient (display->display, &grad, + stops, colors, + n_stops); + } + + if (stops != (XFixed *) buf) + free (stops); + + *src_x = *src_y = 0; + if (! picture_set_properties (display, picture, + &gradient->base, &gradient->base.matrix, + extents, + src_x, src_y)) { + XRenderFreePicture (display->display, picture); + return render_pattern (dst, &gradient->base, is_mask, extents, src_x, src_y); + } + + return source (dst, picture); +} + +static cairo_surface_t * +color_source (cairo_xlib_surface_t *dst, const cairo_color_t *color) +{ + XRenderColor xrender_color; + + xrender_color.red = color->red_short; + xrender_color.green = color->green_short; + xrender_color.blue = color->blue_short; + xrender_color.alpha = color->alpha_short; + + return source (dst, + XRenderCreateSolidFill (dst->display->display, + &xrender_color)); +} + +static cairo_surface_t * +alpha_source (cairo_xlib_surface_t *dst, uint8_t alpha) +{ + cairo_xlib_display_t *display = dst->display; + + if (display->alpha[alpha] == NULL) { + cairo_color_t color; + + color.red_short = color.green_short = color.blue_short = 0; + color.alpha_short = alpha << 8 | alpha; + + display->alpha[alpha] = color_source (dst, &color); + } + + return cairo_surface_reference (display->alpha[alpha]); +} + +static cairo_surface_t * +white_source (cairo_xlib_surface_t *dst) +{ + cairo_xlib_display_t *display = dst->display; + + if (display->white == NULL) + display->white = color_source (dst, CAIRO_COLOR_WHITE); + + return cairo_surface_reference (display->white); +} + +static cairo_surface_t * +opaque_source (cairo_xlib_surface_t *dst, const cairo_color_t *color) +{ + cairo_xlib_display_t *display = dst->display; + uint32_t pixel = + 0xff000000 | + color->red_short >> 8 << 16 | + color->green_short >> 8 << 8 | + color->blue_short >> 8 << 0; + int i; + + if (display->last_solid_cache[0].color == pixel) + return cairo_surface_reference (display->solid[display->last_solid_cache[0].index]); + + for (i = 0; i < 16; i++) { + if (display->solid_cache[i] == pixel) + goto done; + } + + i = hars_petruska_f54_1_random () % 16; + cairo_surface_destroy (display->solid[i]); + + display->solid[i] = color_source (dst, color); + display->solid_cache[i] = pixel; + +done: + display->last_solid_cache[0].color = pixel; + display->last_solid_cache[0].index = i; + return cairo_surface_reference (display->solid[i]); +} + +static cairo_surface_t * +transparent_source (cairo_xlib_surface_t *dst, const cairo_color_t *color) +{ + cairo_xlib_display_t *display = dst->display; + uint32_t pixel = + color->alpha_short >> 8 << 24 | + color->red_short >> 8 << 16 | + color->green_short >> 8 << 8 | + color->blue_short >> 8 << 0; + int i; + + if (display->last_solid_cache[1].color == pixel) { + assert (display->solid[display->last_solid_cache[1].index]); + return cairo_surface_reference (display->solid[display->last_solid_cache[1].index]); + } + + for (i = 16; i < 32; i++) { + if (display->solid_cache[i] == pixel) + goto done; + } + + i = 16 + (hars_petruska_f54_1_random () % 16); + cairo_surface_destroy (display->solid[i]); + + display->solid[i] = color_source (dst, color); + display->solid_cache[i] = pixel; + +done: + display->last_solid_cache[1].color = pixel; + display->last_solid_cache[1].index = i; + assert (display->solid[i]); + return cairo_surface_reference (display->solid[i]); +} + +static cairo_surface_t * +solid_source (cairo_xlib_surface_t *dst, + const cairo_color_t *color) +{ + if ((color->red_short | color->green_short | color->blue_short) <= 0xff) + return alpha_source (dst, color->alpha_short >> 8); + + if (CAIRO_ALPHA_SHORT_IS_OPAQUE (color->alpha_short)) { + if (color->red_short >= 0xff00 && color->green_short >= 0xff00 && color->blue_short >= 0xff00) + return white_source (dst); + + return opaque_source (dst, color); + } else + return transparent_source (dst, color); +} + +static cairo_surface_t * +native_source (cairo_xlib_surface_t *dst, + const cairo_surface_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y) +{ + cairo_xlib_surface_t *src = (cairo_xlib_surface_t *) pattern->surface; + cairo_xlib_source_t *source; + Display *dpy = dst->display->display; + cairo_bool_t is_contained = FALSE; + cairo_int_status_t status; + XTransform xtransform; + XRenderPictureAttributes pa; + int mask = 0; + + src = (cairo_xlib_surface_t *) + unwrap_surface (pattern->surface, src_x, src_y); + + if (sample->x >= 0 && sample->y >= 0 && + sample->x + sample->width <= src->width && + sample->y + sample->height <= src->height) + { + is_contained = TRUE; + } + + if (pattern->base.filter == CAIRO_FILTER_NEAREST && is_contained) { + *src_x += pattern->base.matrix.x0; + *src_y += pattern->base.matrix.y0; + _cairo_xlib_surface_ensure_picture (src); + return cairo_surface_reference (&src->base); + } + + /* As these are frequent and meant to be fast we track pictures for + * enative surface and minimse update requests. + */ + source = &src->embedded_source; + if (source->picture == None) { + Picture picture; + XRenderPictureAttributes pa; + int mask = 0; + + pa.subwindow_mode = IncludeInferiors; + mask |= CPSubwindowMode; + + picture = XRenderCreatePicture (dpy, + src->drawable, + src->xrender_format, + mask, &pa); + + _cairo_surface_init (&source->base, + &cairo_xlib_source_backend, + NULL, /* device */ + CAIRO_CONTENT_COLOR_ALPHA); + source->picture = picture; + + source->has_component_alpha = 0; + source->has_matrix = 0; + source->filter = CAIRO_FILTER_NEAREST; + source->extend = CAIRO_EXTEND_NONE; + } + + status = _cairo_matrix_to_pixman_matrix_offset (&pattern->base.matrix, + pattern->base.filter, + extents->x + extents->width / 2, + extents->y + extents->height / 2, + (pixman_transform_t *)&xtransform, + src_x, src_y); + + if (status == CAIRO_INT_STATUS_NOTHING_TO_DO) { + if (source->has_matrix) { + source->has_matrix = 0; + memcpy (&xtransform, &identity, sizeof (identity)); + status = CAIRO_INT_STATUS_SUCCESS; + } + } else + source->has_matrix = 1; + if (status == CAIRO_INT_STATUS_SUCCESS) + XRenderSetPictureTransform (dpy, source->picture, &xtransform); + + if (source->filter != pattern->base.filter) { + picture_set_filter (dpy, source->picture, pattern->base.filter); + source->filter = pattern->base.filter; + } + + if (source->has_component_alpha != pattern->base.has_component_alpha) { + pa.component_alpha = pattern->base.has_component_alpha; + mask |= CPComponentAlpha; + source->has_component_alpha = pattern->base.has_component_alpha; + } + + if (source->extend != pattern->base.extend) { + pa.repeat = extend_to_repeat (pattern->base.extend); + mask |= CPRepeat; + source->extend = pattern->base.extend; + } + + if (mask) + XRenderChangePicture (dpy, source->picture, mask, &pa); + + return cairo_surface_reference (&source->base); +} + +#if 0 +/* It is general quicker if we let the application choose which images + * to cache for itself and only upload the fragments required for this + * operation. + */ +static cairo_surface_t * +image_source (cairo_xlib_surface_t *dst, + const cairo_surface_pattern_t *pattern, + const cairo_rectangle_int_t *extents, + int *src_x, int *src_y) +{ + cairo_image_surface_t *src = (cairo_image_surface_t *) pattern->surface; + cairo_xlib_surface_t *snapshot; + cairo_surface_pattern_t local_pattern; + cairo_status_t status; + + snapshot = (cairo_xlib_surface_t *) + _cairo_surface_has_snapshot (&src->base, dst->base.backend); + if (snapshot == NULL || snapshot->screen != dst->screen) { + if (snapshot) + _cairo_surface_detach_snapshot (&snapshot->base); + + snapshot = (cairo_xlib_surface_t *) + _cairo_surface_create_similar_scratch (&dst->base, + src->base.content, + src->width, + src->height); + if (snapshot->base.type != CAIRO_SURFACE_TYPE_XLIB) { + cairo_surface_destroy (&snapshot->base); + return _cairo_surface_create_in_error (CAIRO_STATUS_NO_MEMORY); + } + + status = _cairo_xlib_surface_draw_image (snapshot, src, + 0, 0, + src->width, src->height, + 0, 0); + if (unlikely (status)) { + cairo_surface_destroy (&snapshot->base); + return _cairo_surface_create_in_error (status); + } + + _cairo_surface_attach_snapshot (&src->base, + &snapshot->base, + cairo_surface_finish); + + /* reference remains held by the snapshot from image */ + cairo_surface_destroy (&snapshot->base); + } + + local_pattern = *pattern; + local_pattern.surface = &snapshot->base; + + return native_source (dst, &local_pattern, extents, src_x, src_y); +} +#endif + +static cairo_surface_t * +recording_pattern_get_surface (const cairo_pattern_t *pattern) +{ + cairo_surface_t *surface; + + surface = ((const cairo_surface_pattern_t *) pattern)->surface; + if (_cairo_surface_is_paginated (surface)) + surface = _cairo_paginated_surface_get_recording (surface); + if (_cairo_surface_is_snapshot (surface)) + surface = _cairo_surface_snapshot_get_target (surface); + return surface; +} + +static cairo_surface_t * +record_source (cairo_xlib_surface_t *dst, + const cairo_surface_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y) +{ + cairo_xlib_surface_t *src; + cairo_matrix_t matrix, m; + cairo_status_t status; + cairo_rectangle_int_t upload, limit; + + upload = *sample; + if (_cairo_surface_get_extents (pattern->surface, &limit) && + ! _cairo_rectangle_intersect (&upload, &limit)) + { + if (pattern->base.extend == CAIRO_EXTEND_NONE) + return alpha_source (dst, 0); + + upload = limit; + } + + src = (cairo_xlib_surface_t *) + _cairo_surface_create_similar_scratch (&dst->base, + pattern->surface->content, + upload.width, + upload.height); + if (src->base.type != CAIRO_SURFACE_TYPE_XLIB) { + cairo_surface_destroy (&src->base); + return _cairo_surface_create_in_error (CAIRO_STATUS_NO_MEMORY); + } + + cairo_matrix_init_translate (&matrix, upload.x, upload.y); + status = _cairo_recording_surface_replay_with_clip (recording_pattern_get_surface (&pattern->base), + &matrix, &src->base, + NULL); + if (unlikely (status)) { + cairo_surface_destroy (&src->base); + return _cairo_surface_create_in_error (status); + } + + matrix = pattern->base.matrix; + if (upload.x | upload.y) { + cairo_matrix_init_translate (&m, -upload.x, -upload.y); + cairo_matrix_multiply (&matrix, &matrix, &m); + } + + _cairo_xlib_surface_ensure_picture (src); + if (! picture_set_properties (src->display, src->picture, + &pattern->base, &matrix, extents, + src_x, src_y)) + { + cairo_surface_destroy (&src->base); + return render_pattern (dst, &pattern->base, is_mask, + extents, src_x, src_y); + } + + return &src->base; +} + +static cairo_surface_t * +surface_source (cairo_xlib_surface_t *dst, + const cairo_surface_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y) +{ + cairo_xlib_surface_t *src; + cairo_surface_t *image; + cairo_surface_pattern_t local_pattern; + cairo_status_t status; + cairo_rectangle_int_t upload, limit; + cairo_matrix_t m; + + upload = *sample; + if (_cairo_surface_get_extents (pattern->surface, &limit) && + ! _cairo_rectangle_intersect (&upload, &limit)) + { + if (pattern->base.extend == CAIRO_EXTEND_NONE) + return alpha_source (dst, 0); + + upload = limit; + } + + src = (cairo_xlib_surface_t *) + _cairo_surface_create_similar_scratch (&dst->base, + pattern->surface->content, + upload.width, + upload.height); + if (src->base.type != CAIRO_SURFACE_TYPE_XLIB) { + cairo_surface_destroy (&src->base); + return _cairo_surface_create_in_error (CAIRO_STATUS_NO_MEMORY); + } + + _cairo_pattern_init_for_surface (&local_pattern, pattern->surface); + cairo_matrix_init_translate (&local_pattern.base.matrix, + upload.x, upload.y); + + image = cairo_surface_map_to_image (&src->base, NULL); + status = _cairo_surface_paint (image, + CAIRO_OPERATOR_SOURCE, + &local_pattern.base, + NULL); + cairo_surface_unmap_image (&src->base, image); + _cairo_pattern_fini (&local_pattern.base); + + if (unlikely (status)) { + cairo_surface_destroy (&src->base); + return _cairo_surface_create_in_error (status); + } + + local_pattern.base.matrix = pattern->base.matrix; + if (upload.x | upload.y) { + cairo_matrix_init_translate (&m, -upload.x, -upload.y); + cairo_matrix_multiply (&local_pattern.base.matrix, + &local_pattern.base.matrix, + &m); + } + + *src_x = *src_y = 0; + _cairo_xlib_surface_ensure_picture (src); + if (! picture_set_properties (src->display, + src->picture, + &pattern->base, + &local_pattern.base.matrix, + extents, + src_x, src_y)) + { + cairo_surface_destroy (&src->base); + return render_pattern (dst, &pattern->base, + is_mask, extents, + src_x, src_y); + } + + return &src->base; +} + +static cairo_bool_t +pattern_is_supported (cairo_xlib_display_t *display, + const cairo_pattern_t *pattern) +{ + if (pattern->type == CAIRO_PATTERN_TYPE_MESH) + return FALSE; + + if (display->buggy_pad_reflect) { + if (pattern->extend == CAIRO_EXTEND_REPEAT || pattern->extend == CAIRO_EXTEND_PAD) + return FALSE; + } + + if (display->buggy_gradients) { + if (pattern->type == CAIRO_PATTERN_TYPE_LINEAR || pattern->type == CAIRO_PATTERN_TYPE_RADIAL) + return FALSE; + } + + if (! CAIRO_RENDER_HAS_PICTURE_TRANSFORM (display)) { + if (!_cairo_matrix_is_integer_translation (&pattern->matrix, NULL, NULL)) + return FALSE; + } + + if (! CAIRO_RENDER_HAS_FILTERS (display)) { + /* No filters implies no transforms, so we optimise away BILINEAR */ + } + + return TRUE; +} +cairo_surface_t * +_cairo_xlib_source_create_for_pattern (cairo_surface_t *_dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y) +{ + cairo_xlib_surface_t *dst = (cairo_xlib_surface_t *)_dst; + int tx, ty; + + if (pattern == NULL || pattern->type == CAIRO_PATTERN_TYPE_SOLID) { + *src_x = *src_y = 0; + + if (pattern == NULL) + pattern = &_cairo_pattern_white.base; + + return solid_source (dst, &((cairo_solid_pattern_t *)pattern)->color); + } + + if (pattern_is_supported (dst->display, pattern)) { + if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) { + cairo_surface_pattern_t *spattern = (cairo_surface_pattern_t *)pattern; + if (spattern->surface->type == CAIRO_SURFACE_TYPE_XLIB && + _cairo_xlib_surface_same_screen (dst, + (cairo_xlib_surface_t *)unwrap_surface (spattern->surface, &tx, &ty))) + return native_source (dst, spattern, is_mask, + extents, sample, + src_x, src_y); + + if (spattern->surface->type == CAIRO_SURFACE_TYPE_RECORDING) + return record_source (dst, spattern, is_mask, + extents, sample, + src_x, src_y); +#if 0 + if (spattern->surface->type == CAIRO_SURFACE_TYPE_IMAGE) + return image_source (dst, spattern, extents, src_x, src_y); +#endif + + return surface_source (dst, spattern, is_mask, + extents, sample, + src_x, src_y); + } + + if (pattern->type == CAIRO_PATTERN_TYPE_LINEAR || + pattern->type == CAIRO_PATTERN_TYPE_RADIAL) + { + cairo_gradient_pattern_t *gpattern = (cairo_gradient_pattern_t *)pattern; + return gradient_source (dst, gpattern, is_mask, extents, src_x, src_y); + } + } + + return render_pattern (dst, pattern, is_mask, extents, src_x, src_y); +} + +#endif /* !CAIRO_HAS_XLIB_XCB_FUNCTIONS */ diff --git a/src/cairo-xlib-surface-private.h b/src/cairo-xlib-surface-private.h index b56b245c..87db6962 100644 --- a/src/cairo-xlib-surface-private.h +++ b/src/cairo-xlib-surface-private.h @@ -38,76 +38,7 @@ #include "cairo-xlib-xrender-private.h" #include "cairo-surface-private.h" +#include "cairo-surface-backend-private.h" -typedef struct _cairo_xlib_surface cairo_xlib_surface_t; - -struct _cairo_xlib_surface { - cairo_surface_t base; - - cairo_xlib_screen_t *screen; - cairo_xlib_hook_t close_display_hook; - cairo_list_t link; - - Drawable drawable; - cairo_bool_t owns_pixmap; - Visual *visual; - - int use_pixmap; - - int render_major; - int render_minor; - - /* TRUE if the server has a bug with repeating pictures - * - * https://bugs.freedesktop.org/show_bug.cgi?id=3566 - * - * We can't test for this because it depends on whether the - * picture is in video memory or not. - * - * We also use this variable as a guard against a second - * independent bug with transformed repeating pictures: - * - * http://lists.freedesktop.org/archives/cairo/2004-September/001839.html - * - * Both are fixed in xorg >= 6.9 and hopefully in > 6.8.2, so - * we can reuse the test for now. - */ - unsigned int buggy_gradients : 1; - unsigned int buggy_pad_reflect : 1; - unsigned int buggy_repeat : 1; -#define CAIRO_XLIB_SURFACE_HAS_BUGGY_GRADIENTS 1 -#define CAIRO_XLIB_SURFACE_HAS_BUGGY_PAD_REFLECT 1 -#define CAIRO_XLIB_SURFACE_HAS_BUGGY_REPEAT 1 - - int width; - int height; - int depth; - - Picture dst_picture, src_picture; - - unsigned int clip_dirty; - XRectangle embedded_clip_rects[8]; - XRectangle *clip_rects; - int num_clip_rects; - cairo_region_t *clip_region; - - XRenderPictFormat *xrender_format; - cairo_filter_t filter; - cairo_extend_t extend; - cairo_bool_t has_component_alpha; - int precision; - XTransform xtransform; - - uint32_t a_mask; - uint32_t r_mask; - uint32_t g_mask; - uint32_t b_mask; -}; - -enum { - CAIRO_XLIB_SURFACE_CLIP_DIRTY_GC = 0x01, - CAIRO_XLIB_SURFACE_CLIP_DIRTY_PICTURE = 0x02, - CAIRO_XLIB_SURFACE_CLIP_DIRTY_ALL = 0x03 -}; #endif /* CAIRO_XLIB_SURFACE_PRIVATE_H */ diff --git a/src/cairo-xlib-surface.c b/src/cairo-xlib-surface.c index e82de650..1806e64b 100644 --- a/src/cairo-xlib-surface.c +++ b/src/cairo-xlib-surface.c @@ -51,6 +51,8 @@ #include "cairo-xlib-private.h" #include "cairo-xlib-surface-private.h" + +#include "cairo-compositor-private.h" #include "cairo-clip-private.h" #include "cairo-default-context-private.h" #include "cairo-error-private.h" @@ -64,7 +66,6 @@ #include <X11/Xutil.h> /* for XDestroyImage */ #define XLIB_COORD_MAX 32767 -#define PIXMAN_MAX_INT ((pixman_fixed_1 >> 1) - pixman_fixed_e) /* need to ensure deltas also fit */ #define DEBUG 0 @@ -169,16 +170,6 @@ _cairo_xlib_surface_create_internal (cairo_xlib_screen_t *screen, static cairo_bool_t _cairo_surface_is_xlib (cairo_surface_t *surface); -static cairo_int_status_t -_cairo_xlib_surface_show_glyphs (void *abstract_dst, - cairo_operator_t op, - const cairo_pattern_t *src_pattern, - cairo_glyph_t *glyphs, - int num_glyphs, - cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip, - int *remaining_glyphs); - /* * Instead of taking two round trips for each blending request, * assume that if a particular drawable fails GetImage that it will @@ -193,37 +184,6 @@ static const XTransform identity = { { { 0x00000, 0x00000, 1 << 16 }, } }; -#define CAIRO_SURFACE_RENDER_AT_LEAST(surface, major, minor) \ - (((surface)->render_major > major) || \ - (((surface)->render_major == major) && ((surface)->render_minor >= minor))) - -#define CAIRO_SURFACE_RENDER_HAS_CREATE_PICTURE(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 0) -#define CAIRO_SURFACE_RENDER_HAS_COMPOSITE(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 0) -#define CAIRO_SURFACE_RENDER_HAS_COMPOSITE_TEXT(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 0) - -#define CAIRO_SURFACE_RENDER_HAS_FILL_RECTANGLES(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 1) - -#define CAIRO_SURFACE_RENDER_HAS_DISJOINT(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 2) -#define CAIRO_SURFACE_RENDER_HAS_CONJOINT(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 2) - -#define CAIRO_SURFACE_RENDER_HAS_TRAPEZOIDS(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 4) -#define CAIRO_SURFACE_RENDER_HAS_TRIANGLES(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 4) -#define CAIRO_SURFACE_RENDER_HAS_TRISTRIP(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 4) -#define CAIRO_SURFACE_RENDER_HAS_TRIFAN(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 4) - -#define CAIRO_SURFACE_RENDER_HAS_PICTURE_TRANSFORM(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 6) -#define CAIRO_SURFACE_RENDER_HAS_FILTERS(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 6) - -#define CAIRO_SURFACE_RENDER_HAS_EXTENDED_REPEAT(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 10) -#define CAIRO_SURFACE_RENDER_HAS_GRADIENTS(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 10) - -#define CAIRO_SURFACE_RENDER_HAS_PDF_OPERATORS(surface) CAIRO_SURFACE_RENDER_AT_LEAST((surface), 0, 11) - -#define CAIRO_SURFACE_RENDER_SUPPORTS_OPERATOR(surface, op) \ - ((op) <= CAIRO_OPERATOR_SATURATE || \ - (CAIRO_SURFACE_RENDER_HAS_PDF_OPERATORS(surface) && \ - (op) <= CAIRO_OPERATOR_HSL_LUMINOSITY)) - static Visual * _visual_for_xrender_format(Screen *screen, XRenderPictFormat *xrender_format) @@ -274,62 +234,6 @@ _visual_for_xrender_format(Screen *screen, return NULL; } -static cairo_status_t -_cairo_xlib_surface_set_clip_region (cairo_xlib_surface_t *surface, - cairo_region_t *region) -{ - cairo_bool_t had_clip_rects = surface->clip_region != NULL; - - if (had_clip_rects == FALSE && region == NULL) - return CAIRO_STATUS_SUCCESS; - - if (surface->clip_region == region) - return CAIRO_STATUS_SUCCESS; - - if (cairo_region_equal (surface->clip_region, region)) - return CAIRO_STATUS_SUCCESS; - - cairo_region_destroy (surface->clip_region); - surface->clip_region = cairo_region_reference (region); - - if (surface->clip_rects != surface->embedded_clip_rects) { - free (surface->clip_rects); - surface->clip_rects = surface->embedded_clip_rects; - } - surface->num_clip_rects = 0; - - if (region != NULL) { - XRectangle *rects = NULL; - int n_rects, i; - - n_rects = cairo_region_num_rectangles (region); - if (n_rects > ARRAY_LENGTH (surface->embedded_clip_rects)) { - rects = _cairo_malloc_ab (n_rects, sizeof (XRectangle)); - if (unlikely (rects == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } else { - rects = surface->embedded_clip_rects; - } - - for (i = 0; i < n_rects; i++) { - cairo_rectangle_int_t rect; - - cairo_region_get_rectangle (region, i, &rect); - - rects[i].x = rect.x; - rects[i].y = rect.y; - rects[i].width = rect.width; - rects[i].height = rect.height; - } - - surface->clip_rects = rects; - surface->num_clip_rects = n_rects; - } - - surface->clip_dirty = CAIRO_XLIB_SURFACE_CLIP_DIRTY_ALL; - return CAIRO_STATUS_SUCCESS; -} - static cairo_content_t _xrender_format_to_content (XRenderPictFormat *xrender_format) { @@ -373,9 +277,6 @@ _cairo_xlib_surface_create_similar (void *abstract_src, if (width == 0 || height == 0) return NULL; - if (! CAIRO_SURFACE_RENDER_HAS_CREATE_PICTURE (src)) - return NULL; - if (_cairo_xlib_display_acquire (src->base.device, &display)) return NULL; @@ -384,21 +285,25 @@ _cairo_xlib_surface_create_similar (void *abstract_src, * constructing a cairo_format_t instead, (which will fairly * arbitrarily pick a visual/depth for the similar surface. */ - xrender_format = src->xrender_format; - if ((xrender_format != NULL && - _xrender_format_to_content (xrender_format) == content) || - (xrender_format = - _cairo_xlib_display_get_xrender_format (display, - _cairo_format_from_content (content)))) + xrender_format = NULL; + if (src->xrender_format && + _xrender_format_to_content (src->xrender_format) == content) { + xrender_format = src->xrender_format; + } + if (xrender_format == NULL) { + xrender_format = + _cairo_xlib_display_get_xrender_format (display, + _cairo_format_from_content (content)); + } + if (xrender_format) { Visual *visual; /* We've got a compatible XRenderFormat now, which means the * similar surface will match the existing surface as closely in * visual/depth etc. as possible. */ pix = XCreatePixmap (display->display, src->drawable, - width <= 0 ? 1 : width, height <= 0 ? 1 : height, - xrender_format->depth); + width, height, xrender_format->depth); if (xrender_format == src->xrender_format) visual = src->visual; @@ -407,15 +312,13 @@ _cairo_xlib_surface_create_similar (void *abstract_src, xrender_format); surface = (cairo_xlib_surface_t *) - _cairo_xlib_surface_create_internal (src->screen, pix, - visual, + _cairo_xlib_surface_create_internal (src->screen, pix, visual, xrender_format, width, height, xrender_format->depth); } else { -#ifdef DEBUG_FORCE_FALLBACKS Screen *screen = src->screen->screen; int depth; @@ -437,20 +340,12 @@ _cairo_xlib_surface_create_similar (void *abstract_src, DefaultVisualOfScreen (screen), NULL, width, height, depth); -#else - /* No compatabile XRenderFormat, just say no. */ - cairo_device_release (&display->base); - return NULL; -#endif } - if (unlikely (surface->base.status)) { + if (likely (surface->base.status == CAIRO_STATUS_SUCCESS)) + surface->owns_pixmap = TRUE; + else XFreePixmap (display->display, pix); - cairo_device_release (&display->base); - return &surface->base; - } - - surface->owns_pixmap = TRUE; cairo_device_release (&display->base); @@ -472,53 +367,19 @@ _cairo_xlib_surface_finish (void *abstract_surface) if (unlikely (status)) return status; - if (surface->owns_pixmap) { - cairo_status_t status2; - - if (surface->dst_picture != None) { - status2 = _cairo_xlib_display_queue_resource (display, - XRenderFreePicture, - surface->dst_picture); - if (status == CAIRO_STATUS_SUCCESS) - status = status2; - } - - if (surface->src_picture != None) { - status2 = _cairo_xlib_display_queue_resource (display, - XRenderFreePicture, - surface->src_picture); - if (status == CAIRO_STATUS_SUCCESS) - status = status2; - } - - status2 = _cairo_xlib_display_queue_resource (display, - (cairo_xlib_notify_resource_func) XFreePixmap, - surface->drawable); - if (status == CAIRO_STATUS_SUCCESS) - status = status2; - } else { - if (surface->dst_picture != None) - XRenderFreePicture (display->display, surface->dst_picture); - - if (surface->src_picture != None) - XRenderFreePicture (display->display, surface->src_picture); - } - - if (surface->clip_rects != surface->embedded_clip_rects) - free (surface->clip_rects); - - if (display->display != NULL) - _cairo_xlib_remove_close_display_hook (display, - &surface->close_display_hook); + if (surface->embedded_source.picture) + XRenderFreePicture (display->display, surface->embedded_source.picture); + if (surface->picture) + XRenderFreePicture (display->display, surface->picture); + if (surface->owns_pixmap) + XFreePixmap (display->display, surface->drawable); cairo_device_release (&display->base); - cairo_region_destroy (surface->clip_region); - return status; } -static cairo_status_t +cairo_status_t _cairo_xlib_surface_get_gc (cairo_xlib_display_t *display, cairo_xlib_surface_t *surface, GC *gc) @@ -533,17 +394,6 @@ _cairo_xlib_surface_get_gc (cairo_xlib_display_t *display, return CAIRO_STATUS_SUCCESS; } -static void -_cairo_xlib_surface_put_gc (cairo_xlib_display_t *display, - cairo_xlib_surface_t *surface, - GC gc) -{ - _cairo_xlib_screen_put_gc (display, - surface->screen, - surface->depth, - gc); -} - static int _noop_error_handler (Display *display, XErrorEvent *event) @@ -714,7 +564,6 @@ _characterize_field (uint32_t mask, int *width, int *shift) *shift = _cairo_popcount ((mask - 1) & ~mask) & 31; } - /* Convert a field of 'width' bits to 'new_width' bits with correct * rounding. */ static inline uint32_t @@ -806,7 +655,6 @@ _pseudocolor_to_rgb888 (cairo_xlib_visual_info_t *visual_info, (b ); } - /* should range from -128 to 127 */ #define X 16 static const int8_t dither_pattern[4][4] = { @@ -817,7 +665,6 @@ static const int8_t dither_pattern[4][4] = { }; #undef X - static cairo_surface_t * _get_image_surface (cairo_xlib_surface_t *surface, const cairo_rectangle_int_t *extents) @@ -834,6 +681,20 @@ _get_image_surface (cairo_xlib_surface_t *surface, assert (extents->x + extents->width <= surface->width); assert (extents->y + extents->height <= surface->height); + if (surface->base.serial == 0) { + xlib_masks.bpp = (surface->depth + 7) & ~7; + xlib_masks.alpha_mask = surface->a_mask; + xlib_masks.red_mask = surface->r_mask; + xlib_masks.green_mask = surface->g_mask; + xlib_masks.blue_mask = surface->b_mask; + _pixman_format_from_masks (&xlib_masks, &pixman_format); + return _cairo_image_surface_create_with_pixman_format (NULL, + pixman_format, + extents->width, + extents->height, + 0); + } + status = _cairo_xlib_display_acquire (surface->base.device, &display); if (status) return _cairo_surface_create_in_error (status); @@ -1046,48 +907,11 @@ _get_image_surface (cairo_xlib_surface_t *surface, return &image->base; } -static void -_cairo_xlib_surface_ensure_src_picture (cairo_xlib_display_t *display, - cairo_xlib_surface_t *surface) -{ - if (!surface->src_picture) { - XRenderPictureAttributes pa; - int mask = 0; - - pa.subwindow_mode = IncludeInferiors; - mask |= CPSubwindowMode; - - surface->src_picture = XRenderCreatePicture (display->display, - surface->drawable, - surface->xrender_format, - mask, &pa); - } -} - -static void -_cairo_xlib_surface_set_picture_clip_rects (cairo_xlib_display_t *display, - cairo_xlib_surface_t *surface) -{ - if (surface->clip_region != NULL) { - XRenderSetPictureClipRectangles (display->display, surface->dst_picture, - 0, 0, - surface->clip_rects, - surface->num_clip_rects); - } else { - XRenderPictureAttributes pa; - pa.clip_mask = None; - XRenderChangePicture (display->display, surface->dst_picture, - CPClipMask, &pa); - } - - surface->clip_dirty &= ~CAIRO_XLIB_SURFACE_CLIP_DIRTY_PICTURE; -} - -static void -_cairo_xlib_surface_set_precision (cairo_xlib_display_t *display, - cairo_xlib_surface_t *surface, +void +_cairo_xlib_surface_set_precision (cairo_xlib_surface_t *surface, cairo_antialias_t antialias) { + cairo_xlib_display_t *display = surface->display; int precision; if (display->force_precision != -1) @@ -1111,37 +935,46 @@ _cairo_xlib_surface_set_precision (cairo_xlib_display_t *display, XRenderPictureAttributes pa; pa.poly_mode = precision; - XRenderChangePicture (display->display, surface->dst_picture, + XRenderChangePicture (display->display, surface->picture, CPPolyMode, &pa); surface->precision = precision; } } -static void -_cairo_xlib_surface_ensure_dst_picture (cairo_xlib_display_t *display, - cairo_xlib_surface_t *surface) +void +_cairo_xlib_surface_ensure_picture (cairo_xlib_surface_t *surface) { - if (!surface->dst_picture) { - surface->dst_picture = XRenderCreatePicture (display->display, - surface->drawable, - surface->xrender_format, - 0, NULL); - } + cairo_xlib_display_t *display = surface->display; + XRenderPictureAttributes pa; + int mask = 0; - if (surface->clip_dirty & CAIRO_XLIB_SURFACE_CLIP_DIRTY_PICTURE) - _cairo_xlib_surface_set_picture_clip_rects (display, surface); -} + if (surface->picture) + return; -static cairo_status_t -_draw_image_surface (cairo_xlib_surface_t *surface, - cairo_image_surface_t *image, - int src_x, - int src_y, - int width, - int height, - int dst_x, - int dst_y) + if (display->force_precision != -1) + pa.poly_mode = display->force_precision; + else + pa.poly_mode = PolyModeImprecise; + if (pa.poly_mode) + mask |= CPPolyMode; + + surface->precision = pa.poly_mode; + surface->picture = XRenderCreatePicture (display->display, + surface->drawable, + surface->xrender_format, + mask, &pa); +} + +cairo_status_t +_cairo_xlib_surface_draw_image (cairo_xlib_surface_t *surface, + cairo_image_surface_t *image, + int src_x, + int src_y, + int width, + int height, + int dst_x, + int dst_y) { cairo_xlib_display_t *display; XImage ximage; @@ -1400,7 +1233,7 @@ _cairo_xlib_surface_snapshot (void *abstract_surface) extents.width = surface->width; extents.height = surface->height; - /* XXX notice the duplication */ + /* XXX notice the duplication with acquire source */ return _get_image_surface (surface, &extents); } @@ -1428,1703 +1261,114 @@ static cairo_int_status_t _cairo_xlib_surface_unmap_image (void *abstract_surface, cairo_image_surface_t *image) { - return _draw_image_surface (abstract_surface, image, - 0, 0, - image->width, image->height, - image->base.device_transform_inverse.x0, - image->base.device_transform_inverse.y0); -} - -static cairo_status_t -_cairo_xlib_surface_acquire_dest_image (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t **image_out, - cairo_rectangle_int_t *image_rect_out, - void **image_extra) -{ - if (image_rect_out) - *image_rect_out = *interest_rect; - *image_extra = NULL; - *image_out = (cairo_image_surface_t *) - _get_image_surface (abstract_surface, interest_rect); - return (*image_out)->base.status; -} - -static void -_cairo_xlib_surface_release_dest_image (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t *image, - cairo_rectangle_int_t *image_rect, - void *image_extra) -{ - cairo_xlib_surface_t *surface = abstract_surface; - cairo_status_t status; - - status = _draw_image_surface (surface, image, - 0, 0, image->width, image->height, - image_rect->x, image_rect->y); - status = _cairo_surface_set_error (&surface->base, status); - - cairo_surface_destroy (&image->base); -} - -/* - * Return whether two xlib surfaces share the same - * screen. Both core and Render drawing require this - * when using multiple drawables in an operation. - */ -static inline cairo_bool_t -_cairo_xlib_surface_same_screen (cairo_xlib_surface_t *dst, - cairo_xlib_surface_t *src) -{ - return dst->screen == src->screen; -} - -static cairo_xlib_surface_t * -_cairo_xlib_surface_create_similar_for_image(cairo_xlib_surface_t *other, - cairo_image_surface_t *image, - int width, int height) -{ - XRenderPictFormat *xrender_format; - cairo_xlib_display_t *display; - cairo_xlib_surface_t *surface; - cairo_status_t status; - Visual *visual; - Pixmap pix; - - /* Try to create a surface using an xrender format that exactly matches - * the image data so that we can upload the pixels and perform any - * conversion on the GPU. - */ - - if (!CAIRO_SURFACE_RENDER_HAS_CREATE_PICTURE (other)) { -fallback: - return (cairo_xlib_surface_t *) - _cairo_xlib_surface_create_similar (other, - image->base.content, - width, height); - } - - status = _cairo_xlib_display_acquire (other->base.device, &display); - if (unlikely (status)) - return (cairo_xlib_surface_t *) _cairo_surface_create_in_error(status); - - if (image->format != CAIRO_FORMAT_INVALID) - xrender_format = - _cairo_xlib_display_get_xrender_format (display, image->format); - else - xrender_format = - _cairo_xlib_display_get_xrender_format_for_pixman (display, - image->pixman_format); - if (xrender_format == NULL) { - cairo_device_release (&display->base); - goto fallback; - } - - pix = XCreatePixmap (display->display, other->drawable, - width, height, xrender_format->depth); - - if (xrender_format == other->xrender_format) - visual = other->visual; - else - visual = _visual_for_xrender_format(other->screen->screen, - xrender_format); - - surface = (cairo_xlib_surface_t *) - _cairo_xlib_surface_create_internal (other->screen, pix, visual, - xrender_format, - width, height, - xrender_format->depth); - - if (unlikely (surface->base.status)) { - XFreePixmap (display->display, pix); - cairo_device_release (&display->base); - return surface; - } - - surface->owns_pixmap = TRUE; - cairo_device_release (&display->base); - return surface; -} - -static cairo_status_t -_cairo_xlib_surface_clone_similar (void *abstract_surface, - cairo_surface_t *src, - int src_x, - int src_y, - int width, - int height, - int *clone_offset_x, - int *clone_offset_y, - cairo_surface_t **clone_out) -{ - cairo_xlib_surface_t *surface = abstract_surface; - cairo_xlib_surface_t *clone; - cairo_status_t status; - - if (src->backend == surface->base.backend ) { - cairo_xlib_surface_t *xlib_src = (cairo_xlib_surface_t *)src; - - if (_cairo_xlib_surface_same_screen (surface, xlib_src)) { - *clone_offset_x = 0; - *clone_offset_y = 0; - *clone_out = cairo_surface_reference (src); - - return CAIRO_STATUS_SUCCESS; - } - } else if (_cairo_surface_is_image (src)) { - cairo_image_surface_t *image_src = (cairo_image_surface_t *)src; - - if (width > XLIB_COORD_MAX || height > XLIB_COORD_MAX) - return UNSUPPORTED ("roi too large for xlib"); - - clone = _cairo_xlib_surface_create_similar_for_image(surface, - image_src, - width, height); - if (clone == NULL) - return UNSUPPORTED ("unhandled image format, no similar surface"); - - if (unlikely (clone->base.status)) - return clone->base.status; - - status = _draw_image_surface (clone, image_src, - src_x, src_y, - width, height, - 0, 0); - if (unlikely (status)) { - cairo_surface_destroy (&clone->base); - return status; - } - - *clone_offset_x = src_x; - *clone_offset_y = src_y; - *clone_out = &clone->base; - - return CAIRO_STATUS_SUCCESS; - } - - return CAIRO_INT_STATUS_UNSUPPORTED; -} - -static cairo_surface_t * -_cairo_xlib_surface_create_solid_pattern_surface (void *abstract_surface, - const cairo_solid_pattern_t *solid_pattern) -{ - /* This function's only responsibility is to create a proper surface - * for when XRender is not available. The proper surface is a xlib - * surface (as opposed to image surface which is what create_similar - * returns in those cases) and the size of the dithering pattern, not - * 1x1. This surface can then be used in - * _cairo_xlib_surface_solid_fill_rectangles() to do dithered "solid" - * fills using core protocol */ - - cairo_xlib_surface_t *other = abstract_surface; - cairo_image_surface_t *image; - cairo_xlib_surface_t *surface = NULL; - cairo_status_t status = CAIRO_STATUS_SUCCESS; - cairo_xlib_display_t *display; - - int width = ARRAY_LENGTH (dither_pattern[0]); - int height = ARRAY_LENGTH (dither_pattern); - - Pixmap pixmap = None; - - if (CAIRO_SURFACE_RENDER_HAS_COMPOSITE (other)) - return NULL; - - image = (cairo_image_surface_t *) - _cairo_image_surface_create_with_content (_cairo_color_get_content (&solid_pattern->color), - width, height); - status = image->base.status; - if (unlikely (status)) - goto BAIL; - - status = _cairo_xlib_display_acquire (other->base.device, &display); - if (unlikely (status)) - goto BAIL; - - pixmap = XCreatePixmap (display->display, - other->drawable, - width, height, - other->depth); - cairo_device_release (&display->base); - - surface = (cairo_xlib_surface_t *) - _cairo_xlib_surface_create_internal (other->screen, - pixmap, - other->visual, - other->xrender_format, - width, height, - other->depth); - status = surface->base.status; - if (unlikely (status)) - goto BAIL; - - status = _cairo_surface_paint (&image->base, - CAIRO_OPERATOR_SOURCE, - &solid_pattern->base, - NULL); - if (unlikely (status)) - goto BAIL; - - status = _draw_image_surface (surface, image, - 0, 0, - width, height, - 0, 0); - if (unlikely (status)) - goto BAIL; - - BAIL: - cairo_surface_destroy (&image->base); - - if (status) { - if (pixmap != None) { - if (!_cairo_xlib_display_acquire (other->base.device, &display)) { - XFreePixmap (display->display, pixmap); - cairo_device_release (&display->base); - } - } - cairo_surface_destroy (&surface->base); - - return _cairo_surface_create_in_error (status); - } - - surface->owns_pixmap = TRUE; - return &surface->base; -} - -static cairo_bool_t -_cairo_xlib_surface_can_repaint_solid_pattern_surface (void *abstract_surface, - const cairo_solid_pattern_t *solid_pattern) -{ - cairo_xlib_surface_t *other = abstract_surface; - return CAIRO_SURFACE_RENDER_HAS_COMPOSITE (other); -} - -static cairo_int_status_t -_cairo_xlib_surface_set_matrix (cairo_xlib_display_t *display, - cairo_xlib_surface_t *surface, - const cairo_matrix_t *matrix, - cairo_filter_t filter, - double xc, - double yc, - int *x_offset, - int *y_offset) -{ - XTransform xtransform; - pixman_transform_t *pixman_transform; - cairo_int_status_t status; - - /* Casting between pixman_transform_t and XTransform is safe because - * they happen to be the exact same type. - */ - pixman_transform = (pixman_transform_t *) &xtransform; - - status = _cairo_matrix_to_pixman_matrix_offset (matrix, filter, xc, yc, - pixman_transform, - x_offset, y_offset); - if (status == CAIRO_INT_STATUS_NOTHING_TO_DO) - status = CAIRO_INT_STATUS_SUCCESS; - if (unlikely (status != CAIRO_INT_STATUS_SUCCESS)) - return status; - - if (memcmp (&xtransform, &surface->xtransform, sizeof (XTransform)) == 0) - return CAIRO_STATUS_SUCCESS; - - if (! CAIRO_SURFACE_RENDER_HAS_PICTURE_TRANSFORM (surface)) - return UNSUPPORTED ("XRender does not support picture transforms"); - - XRenderSetPictureTransform (display->display, surface->src_picture, &xtransform); - surface->xtransform = xtransform; - - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_cairo_xlib_surface_set_filter (cairo_xlib_display_t *display, - cairo_xlib_surface_t *surface, - cairo_filter_t filter) -{ - const char *render_filter; - - if (surface->filter == filter) - return CAIRO_STATUS_SUCCESS; - - if (!CAIRO_SURFACE_RENDER_HAS_FILTERS (surface)) { - if (filter == CAIRO_FILTER_FAST || filter == CAIRO_FILTER_NEAREST) - return CAIRO_STATUS_SUCCESS; - - return UNSUPPORTED ("XRender does not support filter"); - } - - switch (filter) { - case CAIRO_FILTER_FAST: - render_filter = FilterFast; - break; - case CAIRO_FILTER_GOOD: - render_filter = FilterGood; - break; - case CAIRO_FILTER_BEST: - render_filter = FilterBest; - break; - case CAIRO_FILTER_NEAREST: - render_filter = FilterNearest; - break; - case CAIRO_FILTER_BILINEAR: - render_filter = FilterBilinear; - break; - case CAIRO_FILTER_GAUSSIAN: - /* XXX: The GAUSSIAN value has no implementation in cairo - * whatsoever, so it was really a mistake to have it in the - * API. We could fix this by officially deprecating it, or - * else inventing semantics and providing an actual - * implementation for it. */ - default: - render_filter = FilterBest; - break; - } - - XRenderSetPictureFilter (display->display, surface->src_picture, - (char *) render_filter, NULL, 0); - surface->filter = filter; - - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_cairo_xlib_surface_set_repeat (cairo_xlib_surface_t *surface, - cairo_extend_t extend, - unsigned long *mask, - XRenderPictureAttributes *pa) -{ - int repeat; - - if (surface->extend == extend) - return CAIRO_STATUS_SUCCESS; - - switch (extend) { - case CAIRO_EXTEND_NONE: - repeat = RepeatNone; - break; - case CAIRO_EXTEND_REPEAT: - repeat = RepeatNormal; - break; - case CAIRO_EXTEND_REFLECT: - if (surface->buggy_pad_reflect) - return UNSUPPORTED ("buggy reflect"); - - repeat = RepeatReflect; - break; - case CAIRO_EXTEND_PAD: - if (surface->buggy_pad_reflect) - return UNSUPPORTED ("buggy pad"); - - repeat = RepeatPad; - break; - default: - ASSERT_NOT_REACHED; - return CAIRO_INT_STATUS_UNSUPPORTED; - } - - *mask |= CPRepeat; - pa->repeat = repeat; - - surface->extend = extend; - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_cairo_xlib_surface_set_component_alpha (cairo_xlib_surface_t *surface, - cairo_bool_t ca, - unsigned long *mask, - XRenderPictureAttributes *pa) -{ - if (surface->has_component_alpha == ca) - return CAIRO_STATUS_SUCCESS; - - *mask |= CPComponentAlpha; - pa->component_alpha = ca; - - surface->has_component_alpha = ca; - return CAIRO_STATUS_SUCCESS; + return _cairo_xlib_surface_draw_image (abstract_surface, image, + 0, 0, + image->width, image->height, + image->base.device_transform_inverse.x0, + image->base.device_transform_inverse.y0); } -static cairo_int_status_t -_cairo_xlib_surface_set_attributes (cairo_xlib_display_t *display, - cairo_xlib_surface_t *surface, - cairo_surface_attributes_t *attributes, - double xc, - double yc) -{ - cairo_int_status_t status; - XRenderPictureAttributes pa; - unsigned long mask = 0; - - _cairo_xlib_surface_ensure_src_picture (display, surface); - - status = _cairo_xlib_surface_set_matrix (display, surface, - &attributes->matrix, - attributes->filter, - xc, yc, - &attributes->x_offset, - &attributes->y_offset); - if (unlikely (status)) - return status; - - status = _cairo_xlib_surface_set_repeat (surface, attributes->extend, - &mask, &pa); - if (unlikely (status)) - return status; - - status = _cairo_xlib_surface_set_component_alpha (surface, - attributes->has_component_alpha, - &mask, &pa); - if (unlikely (status)) - return status; - - status = _cairo_xlib_surface_set_filter (display, surface, attributes->filter); - if (unlikely (status)) - return status; - - if (mask) - XRenderChangePicture (display->display, surface->src_picture, mask, &pa); - - return CAIRO_STATUS_SUCCESS; -} - -/* Checks whether we can can directly draw from src to dst with - * the core protocol: either with CopyArea or using src as a - * a tile in a GC. - */ static cairo_bool_t -_surfaces_compatible (cairo_xlib_surface_t *dst, - cairo_xlib_surface_t *src) +_cairo_xlib_surface_get_extents (void *abstract_surface, + cairo_rectangle_int_t *rectangle) { - /* same screen */ - if (! _cairo_xlib_surface_same_screen (dst, src)) - return FALSE; - - /* same depth (for core) */ - if (src->depth != dst->depth) - return FALSE; - - /* if Render is supported, match picture formats */ - if (src->xrender_format != dst->xrender_format) - return FALSE; - else if (src->xrender_format != NULL) - return TRUE; - - /* Without Render, match visuals instead */ - if (src->visual == dst->visual) - return TRUE; - - return FALSE; -} + cairo_xlib_surface_t *surface = abstract_surface; -static cairo_bool_t -_surface_has_alpha (cairo_xlib_surface_t *surface) -{ - if (surface->xrender_format) { - if (surface->xrender_format->type == PictTypeDirect && - surface->xrender_format->direct.alphaMask != 0) - return TRUE; - else - return FALSE; - } else { - /* In the no-render case, we never have alpha */ - return FALSE; - } -} + rectangle->x = 0; + rectangle->y = 0; -/* Returns true if the given operator and source-alpha combination - * requires alpha compositing to complete. - */ -static cairo_bool_t -_operator_needs_alpha_composite (cairo_operator_t op, - cairo_bool_t destination_has_alpha, - cairo_bool_t source_has_alpha) -{ - if (op == CAIRO_OPERATOR_SOURCE || - (! source_has_alpha && - (op == CAIRO_OPERATOR_OVER || - op == CAIRO_OPERATOR_ATOP || - op == CAIRO_OPERATOR_IN))) - return destination_has_alpha; + rectangle->width = surface->width; + rectangle->height = surface->height; return TRUE; } -/* There is a bug in most older X servers with compositing using a - * untransformed repeating source pattern when the source is in off-screen - * video memory, and another with repeated transformed images using a - * general transform matrix. When these bugs could be triggered, we need a - * fallback: in the common case where we have no transformation and the - * source and destination have the same format/visual, we can do the - * operation using the core protocol for the first bug, otherwise, we need - * a software fallback. - * - * We can also often optimize a compositing operation by calling XCopyArea - * for some common cases where there is no alpha compositing to be done. - * We figure that out here as well. - */ -typedef enum { - DO_RENDER, /* use render */ - DO_XCOPYAREA, /* core protocol XCopyArea optimization/fallback */ - DO_XTILE, /* core protocol XSetTile optimization/fallback */ - DO_UNSUPPORTED /* software fallback */ -} composite_operation_t; - -/* Initial check for the render bugs; we need to recheck for the - * offscreen-memory bug after we turn patterns into surfaces, since that - * may introduce a repeating pattern for gradient patterns. We don't need - * to check for the repeat+transform bug because gradient surfaces aren't - * transformed. - * - * All we do here is reject cases where we *know* are going to - * hit the bug and won't be able to use a core protocol fallback. - */ -static composite_operation_t -_categorize_composite_operation (cairo_xlib_surface_t *dst, - cairo_operator_t op, - const cairo_pattern_t *src_pattern, - cairo_bool_t have_mask) - -{ - if (!CAIRO_SURFACE_RENDER_SUPPORTS_OPERATOR (dst, op)) - return DO_UNSUPPORTED; - - if (! dst->buggy_repeat) - return DO_RENDER; - - if (src_pattern->type != CAIRO_PATTERN_TYPE_SOLID && - src_pattern->extend == CAIRO_EXTEND_REPEAT) - { - /* Check for the bug with repeat patterns nad general transforms. */ - if (! _cairo_matrix_is_integer_translation (&src_pattern->matrix, - NULL, NULL)) - { - return DO_UNSUPPORTED; - } - - if (have_mask || - !(op == CAIRO_OPERATOR_SOURCE || op == CAIRO_OPERATOR_OVER)) - { - return DO_UNSUPPORTED; - } - - if (src_pattern->type == CAIRO_PATTERN_TYPE_SURFACE) { - cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) src_pattern; - - /* This is the case where we have the bug involving - * untransformed repeating source patterns with off-screen - * video memory; reject some cases where a core protocol - * fallback is impossible. - */ - if (_cairo_surface_is_xlib (surface_pattern->surface)) { - cairo_xlib_surface_t *src = (cairo_xlib_surface_t *) surface_pattern->surface; - - if (op == CAIRO_OPERATOR_OVER && _surface_has_alpha (src)) - return DO_UNSUPPORTED; - - /* If these are on the same screen but otherwise incompatible, - * make a copy as core drawing can't cross depths and doesn't - * work right across visuals of the same depth - */ - if (_cairo_xlib_surface_same_screen (dst, src) && - !_surfaces_compatible (dst, src)) - { - return DO_UNSUPPORTED; - } - } - } - } - - return DO_RENDER; -} - -/* Recheck for composite-repeat once we've turned patterns into Xlib surfaces - * If we end up returning DO_UNSUPPORTED here, we're throwing away work we - * did to turn gradients into a pattern, but most of the time we can handle - * that case with core protocol fallback. - * - * Also check here if we can just use XCopyArea, instead of going through - * Render. - */ -static composite_operation_t -_recategorize_composite_operation (cairo_xlib_surface_t *dst, - cairo_operator_t op, - cairo_xlib_surface_t *src, - cairo_surface_attributes_t *src_attr, - cairo_bool_t have_mask) -{ - /* Can we use the core protocol? */ - if (! have_mask && - src->owns_pixmap && - src->depth == dst->depth && - _cairo_matrix_is_integer_translation (&src_attr->matrix, NULL, NULL) && - ! _operator_needs_alpha_composite (op, - _surface_has_alpha (dst), - _surface_has_alpha (src))) - { - if (src_attr->extend == CAIRO_EXTEND_NONE) - return DO_XCOPYAREA; - - if (dst->buggy_repeat && src_attr->extend == CAIRO_EXTEND_REPEAT) - return DO_XTILE; - } - - if (dst->buggy_repeat && src_attr->extend == CAIRO_EXTEND_REPEAT) - return DO_UNSUPPORTED; - - if (! CAIRO_SURFACE_RENDER_HAS_COMPOSITE (src)) - return DO_UNSUPPORTED; - - if (! CAIRO_SURFACE_RENDER_HAS_COMPOSITE (dst)) - return DO_UNSUPPORTED; - - return DO_RENDER; -} - -static int -_render_operator (cairo_operator_t op) -{ - switch (op) { - case CAIRO_OPERATOR_CLEAR: - return PictOpClear; - - case CAIRO_OPERATOR_SOURCE: - return PictOpSrc; - case CAIRO_OPERATOR_OVER: - return PictOpOver; - case CAIRO_OPERATOR_IN: - return PictOpIn; - case CAIRO_OPERATOR_OUT: - return PictOpOut; - case CAIRO_OPERATOR_ATOP: - return PictOpAtop; - - case CAIRO_OPERATOR_DEST: - return PictOpDst; - case CAIRO_OPERATOR_DEST_OVER: - return PictOpOverReverse; - case CAIRO_OPERATOR_DEST_IN: - return PictOpInReverse; - case CAIRO_OPERATOR_DEST_OUT: - return PictOpOutReverse; - case CAIRO_OPERATOR_DEST_ATOP: - return PictOpAtopReverse; - - case CAIRO_OPERATOR_XOR: - return PictOpXor; - case CAIRO_OPERATOR_ADD: - return PictOpAdd; - case CAIRO_OPERATOR_SATURATE: - return PictOpSaturate; - - case CAIRO_OPERATOR_MULTIPLY: - return PictOpMultiply; - case CAIRO_OPERATOR_SCREEN: - return PictOpScreen; - case CAIRO_OPERATOR_OVERLAY: - return PictOpOverlay; - case CAIRO_OPERATOR_DARKEN: - return PictOpDarken; - case CAIRO_OPERATOR_LIGHTEN: - return PictOpLighten; - case CAIRO_OPERATOR_COLOR_DODGE: - return PictOpColorDodge; - case CAIRO_OPERATOR_COLOR_BURN: - return PictOpColorBurn; - case CAIRO_OPERATOR_HARD_LIGHT: - return PictOpHardLight; - case CAIRO_OPERATOR_SOFT_LIGHT: - return PictOpSoftLight; - case CAIRO_OPERATOR_DIFFERENCE: - return PictOpDifference; - case CAIRO_OPERATOR_EXCLUSION: - return PictOpExclusion; - case CAIRO_OPERATOR_HSL_HUE: - return PictOpHSLHue; - case CAIRO_OPERATOR_HSL_SATURATION: - return PictOpHSLSaturation; - case CAIRO_OPERATOR_HSL_COLOR: - return PictOpHSLColor; - case CAIRO_OPERATOR_HSL_LUMINOSITY: - return PictOpHSLLuminosity; - - default: - ASSERT_NOT_REACHED; - return PictOpOver; - } -} - -static cairo_int_status_t -_cairo_xlib_surface_acquire_pattern_surface (cairo_xlib_display_t *display, - cairo_xlib_surface_t *dst, - const cairo_pattern_t *pattern, - int x, int y, - int width, int height, - cairo_xlib_surface_t **surface_out, - cairo_surface_attributes_t *attributes) +static void +_cairo_xlib_surface_get_font_options (void *abstract_surface, + cairo_font_options_t *options) { - switch (pattern->type) { - case CAIRO_PATTERN_TYPE_LINEAR: - case CAIRO_PATTERN_TYPE_RADIAL: - { - cairo_gradient_pattern_t *gradient = - (cairo_gradient_pattern_t *) pattern; - cairo_matrix_t matrix = pattern->matrix; - cairo_xlib_surface_t *surface; - char buf[CAIRO_STACK_BUFFER_SIZE]; - cairo_circle_double_t extremes[2]; - XFixed *stops; - XRenderColor *colors; - XRenderPictFormat *format; - Picture picture; - unsigned int i, n_stops; - - if (dst->buggy_gradients) - break; - - /* The RENDER specification says that the inner circle has - * to be completely contained inside the outer one. */ - if (pattern->type == CAIRO_PATTERN_TYPE_RADIAL && - ! _cairo_radial_pattern_focus_is_inside ((cairo_radial_pattern_t *) gradient)) - break; - - assert (gradient->n_stops > 0); - n_stops = MAX (gradient->n_stops, 2); - - if (n_stops < sizeof (buf) / (sizeof (XFixed) + sizeof (XRenderColor))) - { - stops = (XFixed *) buf; - } - else - { - stops = - _cairo_malloc_ab (n_stops, - sizeof (XFixed) + sizeof (XRenderColor)); - if (unlikely (stops == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - colors = (XRenderColor *) (stops + n_stops); - for (i = 0; i < gradient->n_stops; i++) { - stops[i] = - _cairo_fixed_16_16_from_double (gradient->stops[i].offset); - - colors[i].red = gradient->stops[i].color.red_short; - colors[i].green = gradient->stops[i].color.green_short; - colors[i].blue = gradient->stops[i].color.blue_short; - colors[i].alpha = gradient->stops[i].color.alpha_short; - } - - /* RENDER does not support gradients with less than 2 - * stops. If a gradient has only a single stop, duplicate - * it to make RENDER happy. */ - if (gradient->n_stops == 1) { - stops[1] = - _cairo_fixed_16_16_from_double (gradient->stops[0].offset); - - colors[1].red = gradient->stops[0].color.red_short; - colors[1].green = gradient->stops[0].color.green_short; - colors[1].blue = gradient->stops[0].color.blue_short; - colors[1].alpha = gradient->stops[0].color.alpha_short; - } - -#if 0 - /* For some weird reason the X server is sometimes getting - * CreateGradient requests with bad length. So far I've only seen - * XRenderCreateLinearGradient request with 4 stops sometime end up - * with length field matching 0 stops at the server side. I've - * looked at the libXrender code and I can't see anything that - * could cause this behavior. However, for some reason having a - * XSync call here seems to avoid the issue so I'll keep it here - * until it's solved. - */ - XSync (display->display, False); -#endif - - _cairo_gradient_pattern_fit_to_range (gradient, PIXMAN_MAX_INT >> 1, &matrix, extremes); - - if (pattern->type == CAIRO_PATTERN_TYPE_LINEAR) { - XLinearGradient grad; - - grad.p1.x = _cairo_fixed_16_16_from_double (extremes[0].center.x); - grad.p1.y = _cairo_fixed_16_16_from_double (extremes[0].center.y); - grad.p2.x = _cairo_fixed_16_16_from_double (extremes[1].center.x); - grad.p2.y = _cairo_fixed_16_16_from_double (extremes[1].center.y); - - picture = XRenderCreateLinearGradient (display->display, &grad, - stops, colors, - n_stops); - } else { - XRadialGradient grad; - - grad.inner.x = _cairo_fixed_16_16_from_double (extremes[0].center.x); - grad.inner.y = _cairo_fixed_16_16_from_double (extremes[0].center.y); - grad.inner.radius = _cairo_fixed_16_16_from_double (extremes[0].radius); - grad.outer.x = _cairo_fixed_16_16_from_double (extremes[1].center.x); - grad.outer.y = _cairo_fixed_16_16_from_double (extremes[1].center.y); - grad.outer.radius = _cairo_fixed_16_16_from_double (extremes[1].radius); - - picture = XRenderCreateRadialGradient (display->display, &grad, - stops, colors, - n_stops); - } - - if (stops != (XFixed *) buf) - free (stops); - - if (unlikely (picture == None)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - /* Wrap the remote Picture in an xlib surface. */ - format = _cairo_xlib_display_get_xrender_format (display, - CAIRO_FORMAT_ARGB32); - - surface = (cairo_xlib_surface_t *) - _cairo_xlib_surface_create_internal (dst->screen, None, - NULL, format, - /* what could possibly go wrong? */ - XLIB_COORD_MAX, XLIB_COORD_MAX, 32); - if (unlikely (surface->base.status)) { - XRenderFreePicture (display->display, picture); - return surface->base.status; - } - - surface->src_picture = picture; - - attributes->matrix = matrix; - attributes->extend = pattern->extend; - attributes->filter = CAIRO_FILTER_NEAREST; - attributes->x_offset = 0; - attributes->y_offset = 0; - attributes->has_component_alpha = FALSE; - - *surface_out = surface; - return CAIRO_STATUS_SUCCESS; - } - default: - ASSERT_NOT_REACHED; - case CAIRO_PATTERN_TYPE_SOLID: - case CAIRO_PATTERN_TYPE_SURFACE: - case CAIRO_PATTERN_TYPE_MESH: - break; - } + cairo_xlib_surface_t *surface = abstract_surface; - return _cairo_pattern_acquire_surface (pattern, &dst->base, - x, y, width, height, - dst->buggy_pad_reflect ? - CAIRO_PATTERN_ACQUIRE_NO_REFLECT : - CAIRO_PATTERN_ACQUIRE_NONE, - (cairo_surface_t **) surface_out, - attributes); + *options = *_cairo_xlib_screen_get_font_options (surface->screen); } -static cairo_int_status_t -_cairo_xlib_surface_acquire_pattern_surfaces (cairo_xlib_display_t *display, - cairo_xlib_surface_t *dst, - const cairo_pattern_t *src, - const cairo_pattern_t *mask, - int src_x, - int src_y, - int mask_x, - int mask_y, - unsigned int width, - unsigned int height, - cairo_xlib_surface_t **src_out, - cairo_xlib_surface_t **mask_out, - cairo_surface_attributes_t *src_attr, - cairo_surface_attributes_t *mask_attr) -{ - if (! dst->buggy_gradients && - (src->type == CAIRO_PATTERN_TYPE_LINEAR || - src->type == CAIRO_PATTERN_TYPE_RADIAL || - (mask && (mask->type == CAIRO_PATTERN_TYPE_LINEAR || - mask->type == CAIRO_PATTERN_TYPE_RADIAL)))) - { - cairo_int_status_t status; - - status = _cairo_xlib_surface_acquire_pattern_surface (display, - dst, src, - src_x, src_y, - width, height, - src_out, - src_attr); - if (unlikely (status)) - return status; - - if (mask) { - status = _cairo_xlib_surface_acquire_pattern_surface (display, - dst, mask, - mask_x, - mask_y, - width, - height, - mask_out, - mask_attr); - if (unlikely (status)) { - _cairo_pattern_release_surface (src, &(*src_out)->base, - src_attr); - return status; - } - } else { - *mask_out = NULL; - } - - return CAIRO_STATUS_SUCCESS; - } - - return _cairo_pattern_acquire_surfaces (src, mask, - &dst->base, - src_x, src_y, - mask_x, mask_y, - width, height, - dst->buggy_pad_reflect ? - CAIRO_PATTERN_ACQUIRE_NO_REFLECT : - CAIRO_PATTERN_ACQUIRE_NONE, - (cairo_surface_t **) src_out, - (cairo_surface_t **) mask_out, - src_attr, mask_attr); -} static cairo_int_status_t -_cairo_xlib_surface_upload(cairo_xlib_surface_t *surface, - cairo_operator_t op, - const cairo_pattern_t *pattern, - int src_x, int src_y, - int dst_x, int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region) +_cairo_xlib_surface_paint (void *_surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_clip_t *clip) { - cairo_image_surface_t *image; - cairo_rectangle_int_t extents; - cairo_status_t status; - int tx, ty; - - if (pattern->type != CAIRO_PATTERN_TYPE_SURFACE) - return CAIRO_INT_STATUS_UNSUPPORTED; - - image = (cairo_image_surface_t *) ((cairo_surface_pattern_t *) pattern)->surface; - if (image->base.type != CAIRO_SURFACE_TYPE_IMAGE) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (! (op == CAIRO_OPERATOR_SOURCE || - (op == CAIRO_OPERATOR_OVER && - (image->base.content & CAIRO_CONTENT_ALPHA) == 0))) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (image->base.backend->type != CAIRO_SURFACE_TYPE_IMAGE) { - if (_cairo_surface_is_snapshot (&image->base)) { - image = (cairo_image_surface_t *) ((cairo_surface_snapshot_t *) image)->target; - extents.x = extents.y = 0; - extents.width = image->width; - extents.height = image->height; - } else if (image->base.backend->type == CAIRO_SURFACE_TYPE_SUBSURFACE) { - cairo_surface_subsurface_t *sub = (cairo_surface_subsurface_t *) image; - image = (cairo_image_surface_t *) sub->target; - src_x += sub->extents.x; - src_y += sub->extents.y; - extents = sub->extents; - } else { - return CAIRO_INT_STATUS_UNSUPPORTED; - } - } else { - extents.x = extents.y = 0; - extents.width = image->width; - extents.height = image->height; - } - - if (image->format == CAIRO_FORMAT_INVALID) - return CAIRO_INT_STATUS_UNSUPPORTED; - if (image->depth != surface->depth) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (! _cairo_matrix_is_integer_translation (&pattern->matrix, &tx, &ty)) - return CAIRO_INT_STATUS_UNSUPPORTED; - - src_x += tx; - src_y += ty; - - /* XXX for EXTEND_NONE perform unbounded fixups? */ - if (src_x < extents.x || - src_y < extents.y || - src_x + width > (unsigned) extents.width || - src_y + height > (unsigned) extents.height) - { - return CAIRO_INT_STATUS_UNSUPPORTED; - } - - status = cairo_device_acquire (surface->base.device); - if (unlikely (status)) - return status; - - if (clip_region != NULL) { - int n, num_rect; - - src_x -= dst_x; - src_y -= dst_y; - - num_rect = cairo_region_num_rectangles (clip_region); - for (n = 0; n < num_rect; n++) { - cairo_rectangle_int_t rect; - - cairo_region_get_rectangle (clip_region, n, &rect); - status = _draw_image_surface (surface, image, - rect.x + src_x, rect.y + src_y, - rect.width, rect.height, - rect.x, rect.y); - if (unlikely (status)) - break; - } - } else { - status = _draw_image_surface (surface, image, - src_x, src_y, - width, height, - dst_x, dst_y); - } - - cairo_device_release (surface->base.device); - - return status; + cairo_xlib_surface_t *surface = _surface; + return _cairo_compositor_paint (surface->compositor, + &surface->base, op, source, + clip); } static cairo_int_status_t -_cairo_xlib_surface_composite (cairo_operator_t op, - const cairo_pattern_t *src_pattern, - const cairo_pattern_t *mask_pattern, - void *abstract_dst, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region) +_cairo_xlib_surface_mask (void *_surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_pattern_t *mask, + const cairo_clip_t *clip) { - cairo_surface_attributes_t src_attr, mask_attr; - cairo_xlib_surface_t *dst = abstract_dst; - cairo_xlib_surface_t *src; - cairo_xlib_surface_t *mask; - cairo_xlib_display_t *display; - cairo_int_status_t status; - composite_operation_t operation; - int itx, ity; - cairo_bool_t is_integer_translation; - GC gc; - - if (mask_pattern != NULL && ! CAIRO_SURFACE_RENDER_HAS_COMPOSITE (dst)) - return UNSUPPORTED ("no support for masks"); - - operation = _categorize_composite_operation (dst, op, src_pattern, - mask_pattern != NULL); - if (operation == DO_UNSUPPORTED) - return UNSUPPORTED ("unsupported operation"); - - X_DEBUG ((display->display, "composite (dst=%x)", (unsigned int) dst->drawable)); - - if (mask_pattern == NULL) { - /* Can we do a simple upload in-place? */ - status = _cairo_xlib_surface_upload(dst, op, src_pattern, - src_x, src_y, - dst_x, dst_y, - width, height, - clip_region); - if (status != CAIRO_INT_STATUS_UNSUPPORTED) - return status; - } - - status = _cairo_xlib_display_acquire (dst-> base.device, &display); - if (unlikely (status)) - return status; - - status = - _cairo_xlib_surface_acquire_pattern_surfaces (display, dst, - src_pattern, mask_pattern, - src_x, src_y, - mask_x, mask_y, - width, height, - &src, &mask, - &src_attr, &mask_attr); - if (unlikely (status)) - goto BAIL0; - - /* check for fallback surfaces that we cannot handle ... */ - assert (_cairo_surface_is_xlib (&src->base)); - assert (mask == NULL || _cairo_surface_is_xlib (&mask->base)); - - if (mask != NULL && ! CAIRO_SURFACE_RENDER_HAS_COMPOSITE (mask)) { - status = UNSUPPORTED ("unsupported mask"); - goto BAIL; - } - - operation = _recategorize_composite_operation (dst, op, src, &src_attr, - mask_pattern != NULL); - if (operation == DO_UNSUPPORTED) { - status = UNSUPPORTED ("unsupported operation"); - goto BAIL; - } - - switch (operation) - { - case DO_RENDER: - status = _cairo_xlib_surface_set_attributes (display, - src, &src_attr, - dst_x + width / 2., - dst_y + height / 2.); - if (unlikely (status)) - goto BAIL; - - status = _cairo_xlib_surface_set_clip_region (dst, clip_region); - if (unlikely (status)) - goto BAIL; - - _cairo_xlib_surface_ensure_dst_picture (display, dst); - if (mask) { - status = _cairo_xlib_surface_set_attributes (display, - mask, &mask_attr, - dst_x + width / 2., - dst_y + height/ 2.); - if (unlikely (status)) - goto BAIL; - - XRenderComposite (display->display, - _render_operator (op), - src->src_picture, - mask->src_picture, - dst->dst_picture, - src_x + src_attr.x_offset, - src_y + src_attr.y_offset, - mask_x + mask_attr.x_offset, - mask_y + mask_attr.y_offset, - dst_x, dst_y, - width, height); - } else { - XRenderComposite (display->display, - _render_operator (op), - src->src_picture, - 0, - dst->dst_picture, - src_x + src_attr.x_offset, - src_y + src_attr.y_offset, - 0, 0, - dst_x, dst_y, - width, height); - } - - break; - - case DO_XCOPYAREA: - status = _cairo_xlib_surface_get_gc (display, dst, &gc); - if (unlikely (status)) - goto BAIL; - - is_integer_translation = - _cairo_matrix_is_integer_translation (&src_attr.matrix, &itx, &ity); - /* This is a pre-condition for DO_XCOPYAREA. */ - assert (is_integer_translation); - - if (clip_region == NULL) { - XCopyArea (display->display, src->drawable, dst->drawable, gc, - src_x + src_attr.x_offset + itx, - src_y + src_attr.y_offset + ity, - width, height, - dst_x, dst_y); - } else { - int n, num_rects, x, y; - - x = src_x + src_attr.x_offset + itx - dst_x; - y = src_y + src_attr.y_offset + ity - dst_y; - - num_rects = cairo_region_num_rectangles (clip_region); - for (n = 0; n < num_rects; n++) { - cairo_rectangle_int_t rect; - - cairo_region_get_rectangle (clip_region, n, &rect); - XCopyArea (display->display, src->drawable, dst->drawable, gc, - rect.x + x, rect.y + y, - rect.width, rect.height, - rect.x, rect.y); - } - } - - _cairo_xlib_surface_put_gc (display, dst, gc); - break; - - case DO_XTILE: - /* This case is only used for bug fallbacks, though we also use it for - * the case where we don't have the RENDER extension, by forcing - * buggy_repeat to TRUE. - * - * We've checked that we have a repeating unscaled source in - * _recategorize_composite_operation. - */ - - status = _cairo_xlib_surface_get_gc (display, dst, &gc); - if (unlikely (status)) - goto BAIL; - - is_integer_translation = - _cairo_matrix_is_integer_translation (&src_attr.matrix, &itx, &ity); - /* This is a pre-condition for DO_XTILE. */ - assert (is_integer_translation); - - XSetTSOrigin (display->display, gc, - - (itx + src_attr.x_offset), - (ity + src_attr.y_offset)); - XSetTile (display->display, gc, src->drawable); - - if (clip_region == NULL) { - XFillRectangle (display->display, dst->drawable, gc, - dst_x, dst_y, width, height); - } else { - int n, num_rects; - - num_rects = cairo_region_num_rectangles (clip_region); - for (n = 0; n < num_rects; n++) { - cairo_rectangle_int_t rect; - - cairo_region_get_rectangle (clip_region, n, &rect); - XFillRectangle (display->display, dst->drawable, gc, - rect.x, rect.y, rect.width, rect.height); - } - } - - _cairo_xlib_surface_put_gc (display, dst, gc); - break; - - case DO_UNSUPPORTED: - default: - ASSERT_NOT_REACHED; - } - - if (!_cairo_operator_bounded_by_source (op)) - status = _cairo_surface_composite_fixup_unbounded (&dst->base, - &src_attr, src->width, src->height, - mask ? &mask_attr : NULL, - mask ? mask->width : 0, - mask ? mask->height : 0, - src_x, src_y, - mask_x, mask_y, - dst_x, dst_y, width, height, - clip_region); - - BAIL: - if (mask) - _cairo_pattern_release_surface (mask_pattern, &mask->base, &mask_attr); - - _cairo_pattern_release_surface (src_pattern, &src->base, &src_attr); - - BAIL0: - cairo_device_release (&display->base); - - return status; + cairo_xlib_surface_t *surface = _surface; + return _cairo_compositor_mask (surface->compositor, + &surface->base, op, source, mask, + clip); } -/* XXX move this out of core and into acquire_pattern_surface() above. */ static cairo_int_status_t -_cairo_xlib_surface_solid_fill_rectangles (cairo_xlib_surface_t *surface, - const cairo_color_t *color, - cairo_rectangle_int_t *rects, - int num_rects) -{ - cairo_status_t status; - cairo_solid_pattern_t solid; - cairo_surface_t *solid_surface = NULL; - cairo_surface_attributes_t attrs; - cairo_xlib_display_t *display; - GC gc; - int i; - - _cairo_pattern_init_solid (&solid, color); - - status = _cairo_xlib_display_acquire (surface->base.device, &display); - if (unlikely (status)) - return status; - - status = _cairo_xlib_surface_get_gc (display, surface, &gc); - if (unlikely (status)) - return status; - - X_DEBUG ((display->display, "solid_fill_rectangles (dst=%x)", (unsigned int) surface->drawable)); - - status = _cairo_pattern_acquire_surface (&solid.base, &surface->base, - 0, 0, - ARRAY_LENGTH (dither_pattern[0]), - ARRAY_LENGTH (dither_pattern), - CAIRO_PATTERN_ACQUIRE_NONE, - &solid_surface, - &attrs); - if (unlikely (status)) { - _cairo_xlib_surface_put_gc (display, surface, gc); - cairo_device_release (&display->base); - return status; - } - - assert (_cairo_surface_is_xlib (solid_surface)); - - XSetTSOrigin (display->display, gc, - - (surface->base.device_transform.x0 + attrs.x_offset), - - (surface->base.device_transform.y0 + attrs.y_offset)); - XSetTile (display->display, gc, - ((cairo_xlib_surface_t *) solid_surface)->drawable); - - for (i = 0; i < num_rects; i++) { - XFillRectangle (display->display, surface->drawable, gc, - rects[i].x, rects[i].y, - rects[i].width, rects[i].height); - } - - _cairo_xlib_surface_put_gc (display, surface, gc); - - _cairo_pattern_release_surface (&solid.base, solid_surface, &attrs); - - cairo_device_release (&display->base); - - return CAIRO_STATUS_SUCCESS; +_cairo_xlib_surface_stroke (void *_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_xlib_surface_t *surface = _surface; + return _cairo_compositor_stroke (surface->compositor, + &surface->base, op, source, + path, style, ctm, ctm_inverse, + tolerance, antialias, + clip); } static cairo_int_status_t -_cairo_xlib_surface_fill_rectangles (void *abstract_surface, - cairo_operator_t op, - const cairo_color_t *color, - cairo_rectangle_int_t *rects, - int num_rects) -{ - cairo_xlib_surface_t *surface = abstract_surface; - cairo_xlib_display_t *display; - XRenderColor render_color; - cairo_status_t status; - int i; - - if (!CAIRO_SURFACE_RENDER_SUPPORTS_OPERATOR (surface, op)) - return CAIRO_INT_STATUS_UNSUPPORTED; - - if (!CAIRO_SURFACE_RENDER_HAS_FILL_RECTANGLES (surface)) { - if (op == CAIRO_OPERATOR_CLEAR || - ((op == CAIRO_OPERATOR_SOURCE || op == CAIRO_OPERATOR_OVER) && - CAIRO_COLOR_IS_OPAQUE (color))) - { - return _cairo_xlib_surface_solid_fill_rectangles (surface, color, - rects, num_rects); - } - - return UNSUPPORTED ("no support for FillRectangles with this op"); - } - - status = _cairo_xlib_display_acquire (surface->base.device, &display); - if (unlikely (status)) - return status; - - X_DEBUG ((display->display, "fill_rectangles (dst=%x)", (unsigned int) surface->drawable)); - - render_color.red = color->red_short; - render_color.green = color->green_short; - render_color.blue = color->blue_short; - render_color.alpha = color->alpha_short; - - status = _cairo_xlib_surface_set_clip_region (surface, NULL); - assert (status == CAIRO_STATUS_SUCCESS); - - _cairo_xlib_surface_ensure_dst_picture (display, surface); - if (num_rects == 1) { - /* Take advantage of the protocol compaction that libXrender performs - * to amalgamate sequences of XRenderFillRectangle(). - */ - XRenderFillRectangle (display->display, - _render_operator (op), - surface->dst_picture, - &render_color, - rects->x, - rects->y, - rects->width, - rects->height); - } else { - XRectangle static_xrects[CAIRO_STACK_ARRAY_LENGTH (XRectangle)]; - XRectangle *xrects = static_xrects; - - if (num_rects > ARRAY_LENGTH (static_xrects)) { - xrects = _cairo_malloc_ab (num_rects, sizeof (XRectangle)); - if (unlikely (xrects == NULL)) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto BAIL; - } - } - - for (i = 0; i < num_rects; i++) { - xrects[i].x = rects[i].x; - xrects[i].y = rects[i].y; - xrects[i].width = rects[i].width; - xrects[i].height = rects[i].height; - } - - XRenderFillRectangles (display->display, - _render_operator (op), - surface->dst_picture, - &render_color, xrects, num_rects); - - if (xrects != static_xrects) - free (xrects); - } - -BAIL: - cairo_device_release (&display->base); - return status; -} - -#define CAIRO_FIXED_16_16_MIN -32768 -#define CAIRO_FIXED_16_16_MAX 32767 - -static cairo_bool_t -_line_exceeds_16_16 (const cairo_line_t *line) -{ - return - line->p1.x < _cairo_fixed_from_int (CAIRO_FIXED_16_16_MIN) || - line->p1.x > _cairo_fixed_from_int (CAIRO_FIXED_16_16_MAX) || - line->p2.x < _cairo_fixed_from_int (CAIRO_FIXED_16_16_MIN) || - line->p2.x > _cairo_fixed_from_int (CAIRO_FIXED_16_16_MAX) || - line->p1.y < _cairo_fixed_from_int (CAIRO_FIXED_16_16_MIN) || - line->p1.y > _cairo_fixed_from_int (CAIRO_FIXED_16_16_MAX) || - line->p2.y < _cairo_fixed_from_int (CAIRO_FIXED_16_16_MIN) || - line->p2.y > _cairo_fixed_from_int (CAIRO_FIXED_16_16_MAX); -} - -static void -_project_line_x_onto_16_16 (const cairo_line_t *line, - cairo_fixed_t top, - cairo_fixed_t bottom, - XLineFixed *out) -{ - cairo_point_double_t p1, p2; - double m; - - p1.x = _cairo_fixed_to_double (line->p1.x); - p1.y = _cairo_fixed_to_double (line->p1.y); - - p2.x = _cairo_fixed_to_double (line->p2.x); - p2.y = _cairo_fixed_to_double (line->p2.y); - - m = (p2.x - p1.x) / (p2.y - p1.y); - out->p1.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (top - line->p1.y)); - out->p2.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (bottom - line->p1.y)); +_cairo_xlib_surface_fill (void *_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_xlib_surface_t *surface = _surface; + return _cairo_compositor_fill (surface->compositor, + &surface->base, op, source, + path, fill_rule, tolerance, antialias, + clip); } static cairo_int_status_t -_cairo_xlib_surface_composite_trapezoids (cairo_operator_t op, - const cairo_pattern_t *pattern, - void *abstract_dst, - cairo_antialias_t antialias, - int src_x, - int src_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_trapezoid_t *traps, - int num_traps, - cairo_region_t *clip_region) +_cairo_xlib_surface_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) { - cairo_surface_attributes_t attributes; - cairo_xlib_surface_t *dst = abstract_dst; - cairo_xlib_surface_t *src; - cairo_xlib_display_t *display; - cairo_int_status_t status; - composite_operation_t operation; - int render_reference_x, render_reference_y; - int render_src_x, render_src_y; - XRenderPictFormat *pict_format; - XTrapezoid xtraps_stack[CAIRO_STACK_ARRAY_LENGTH (XTrapezoid)]; - XTrapezoid *xtraps = xtraps_stack; - int i; - - if (! CAIRO_SURFACE_RENDER_HAS_TRAPEZOIDS (dst)) - return UNSUPPORTED ("XRender does not support CompositeTrapezoids"); - - operation = _categorize_composite_operation (dst, op, pattern, TRUE); - if (operation == DO_UNSUPPORTED) - return UNSUPPORTED ("unsupported operation"); - - status = _cairo_xlib_display_acquire (dst->base.device, &display); - if (unlikely (status)) - return status; - - X_DEBUG ((display->display, "composite_trapezoids (dst=%x)", (unsigned int) dst->drawable)); - - status = _cairo_xlib_surface_acquire_pattern_surface (display, - dst, - pattern, - src_x, src_y, - width, height, - &src, &attributes); - if (unlikely (status)) - goto BAIL0; - - operation = _recategorize_composite_operation (dst, op, src, - &attributes, TRUE); - if (operation == DO_UNSUPPORTED) { - status = UNSUPPORTED ("unsupported operation"); - goto BAIL; - } - - pict_format = - _cairo_xlib_display_get_xrender_format (display, - antialias == CAIRO_ANTIALIAS_NONE ? CAIRO_FORMAT_A1 : CAIRO_FORMAT_A8); - - status = _cairo_xlib_surface_set_clip_region (dst, clip_region); - if (unlikely (status)) - goto BAIL; - - _cairo_xlib_surface_ensure_dst_picture (display, dst); - _cairo_xlib_surface_set_precision (display, dst, antialias); - - status = _cairo_xlib_surface_set_attributes (display, - src, &attributes, - dst_x + width / 2., - dst_y + height / 2.); - if (unlikely (status)) - goto BAIL; - - if (num_traps > ARRAY_LENGTH (xtraps_stack)) { - xtraps = _cairo_malloc_ab (num_traps, sizeof (XTrapezoid)); - if (unlikely (xtraps == NULL)) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto BAIL; - } - } - - for (i = 0; i < num_traps; i++) { - /* top/bottom will be clamped to surface bounds */ - xtraps[i].top = _cairo_fixed_to_16_16(traps[i].top); - xtraps[i].bottom = _cairo_fixed_to_16_16(traps[i].bottom); - - /* However, all the other coordinates will have been left untouched so - * as not to introduce numerical error. Recompute them if they - * exceed the 16.16 limits. - */ - if (unlikely (_line_exceeds_16_16 (&traps[i].left))) { - _project_line_x_onto_16_16 (&traps[i].left, - traps[i].top, - traps[i].bottom, - &xtraps[i].left); - xtraps[i].left.p1.y = xtraps[i].top; - xtraps[i].left.p2.y = xtraps[i].bottom; - } else { - xtraps[i].left.p1.x = _cairo_fixed_to_16_16(traps[i].left.p1.x); - xtraps[i].left.p1.y = _cairo_fixed_to_16_16(traps[i].left.p1.y); - xtraps[i].left.p2.x = _cairo_fixed_to_16_16(traps[i].left.p2.x); - xtraps[i].left.p2.y = _cairo_fixed_to_16_16(traps[i].left.p2.y); - } - - if (unlikely (_line_exceeds_16_16 (&traps[i].right))) { - _project_line_x_onto_16_16 (&traps[i].right, - traps[i].top, - traps[i].bottom, - &xtraps[i].right); - xtraps[i].right.p1.y = xtraps[i].top; - xtraps[i].right.p2.y = xtraps[i].bottom; - } else { - xtraps[i].right.p1.x = _cairo_fixed_to_16_16(traps[i].right.p1.x); - xtraps[i].right.p1.y = _cairo_fixed_to_16_16(traps[i].right.p1.y); - xtraps[i].right.p2.x = _cairo_fixed_to_16_16(traps[i].right.p2.x); - xtraps[i].right.p2.y = _cairo_fixed_to_16_16(traps[i].right.p2.y); - } - } - - if (xtraps[0].left.p1.y < xtraps[0].left.p2.y) { - render_reference_x = _cairo_fixed_16_16_floor (xtraps[0].left.p1.x); - render_reference_y = _cairo_fixed_16_16_floor (xtraps[0].left.p1.y); - } else { - render_reference_x = _cairo_fixed_16_16_floor (xtraps[0].left.p2.x); - render_reference_y = _cairo_fixed_16_16_floor (xtraps[0].left.p2.y); - } - - render_src_x = src_x + render_reference_x - dst_x; - render_src_y = src_y + render_reference_y - dst_y; - - XRenderCompositeTrapezoids (display->display, - _render_operator (op), - src->src_picture, dst->dst_picture, - pict_format, - render_src_x + attributes.x_offset, - render_src_y + attributes.y_offset, - xtraps, num_traps); - - if (xtraps != xtraps_stack) - free (xtraps); - - if (! _cairo_operator_bounded_by_mask (op)) { - cairo_traps_t _traps; - cairo_box_t box; - cairo_rectangle_int_t extents; - - /* XRenderCompositeTrapezoids() creates a mask only large enough for the - * trapezoids themselves, but if the operator is unbounded, then we need - * to actually composite all the way out to the bounds. - */ - /* XXX: update the interface to pass composite rects */ - _traps.traps = traps; - _traps.num_traps = num_traps; - _cairo_traps_extents (&_traps, &box); - _cairo_box_round_to_rectangle (&box, &extents); - - status = _cairo_surface_composite_shape_fixup_unbounded (&dst->base, - &attributes, - src->width, src->height, - extents.width, extents.height, - src_x, src_y, - -extents.x + dst_x, -extents.y + dst_y, - dst_x, dst_y, - width, height, - clip_region); - } - - BAIL: - _cairo_pattern_release_surface (pattern, &src->base, &attributes); - BAIL0: - cairo_device_release (&display->base); - - return status; -} - -static cairo_bool_t -_cairo_xlib_surface_get_extents (void *abstract_surface, - cairo_rectangle_int_t *rectangle) -{ - cairo_xlib_surface_t *surface = abstract_surface; - - rectangle->x = 0; - rectangle->y = 0; - - rectangle->width = surface->width; - rectangle->height = surface->height; - - return TRUE; -} - -static void -_cairo_xlib_surface_get_font_options (void *abstract_surface, - cairo_font_options_t *options) -{ - cairo_xlib_surface_t *surface = abstract_surface; - - *options = *_cairo_xlib_screen_get_font_options (surface->screen); -} - -static void -_cairo_xlib_surface_scaled_font_fini (cairo_scaled_font_t *scaled_font); - -static void -_cairo_xlib_surface_scaled_glyph_fini (cairo_scaled_glyph_t *scaled_glyph, - cairo_scaled_font_t *scaled_font); - -static cairo_bool_t -_cairo_xlib_surface_is_similar (void *surface_a, - void *surface_b) -{ - return _cairo_xlib_surface_same_screen (surface_a, surface_b); + cairo_xlib_surface_t *surface = _surface; + return _cairo_compositor_glyphs (surface->compositor, + &surface->base, op, source, + glyphs, num_glyphs, scaled_font, + clip); } static const cairo_surface_backend_t cairo_xlib_surface_backend = { @@ -3140,38 +1384,23 @@ static const cairo_surface_backend_t cairo_xlib_surface_backend = { _cairo_xlib_surface_acquire_source_image, _cairo_xlib_surface_release_source_image, + _cairo_xlib_surface_snapshot, - _cairo_xlib_surface_acquire_dest_image, - _cairo_xlib_surface_release_dest_image, - _cairo_xlib_surface_clone_similar, - _cairo_xlib_surface_composite, - _cairo_xlib_surface_fill_rectangles, - _cairo_xlib_surface_composite_trapezoids, - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ NULL, /* copy_page */ NULL, /* show_page */ + _cairo_xlib_surface_get_extents, - NULL, /* old_show_glyphs */ _cairo_xlib_surface_get_font_options, + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ - _cairo_xlib_surface_scaled_font_fini, - _cairo_xlib_surface_scaled_glyph_fini, - NULL, /* paint */ - NULL, /* mask */ - NULL, /* stroke */ - NULL, /* fill */ - _cairo_xlib_surface_show_glyphs, - - _cairo_xlib_surface_snapshot, - _cairo_xlib_surface_is_similar, - - NULL, /* fill_stroke */ - - _cairo_xlib_surface_create_solid_pattern_surface, - _cairo_xlib_surface_can_repaint_solid_pattern_surface + _cairo_xlib_surface_paint, + _cairo_xlib_surface_mask, + _cairo_xlib_surface_stroke, + _cairo_xlib_surface_fill, + NULL, /* fill-stroke */ + _cairo_xlib_surface_glyphs, }; /** @@ -3188,36 +1417,6 @@ _cairo_surface_is_xlib (cairo_surface_t *surface) return surface->backend == &cairo_xlib_surface_backend; } -/* callback from CloseDisplay */ -static void -_cairo_xlib_surface_detach_display (cairo_xlib_display_t *display, void *data) -{ - cairo_xlib_surface_t *surface = cairo_container_of (data, - cairo_xlib_surface_t, - close_display_hook); - Display *dpy; - - dpy = display->display; - - X_DEBUG ((dpy, "detach (drawable=%x)", (unsigned int) surface->drawable)); - - if (surface->dst_picture != None) { - XRenderFreePicture (dpy, surface->dst_picture); - surface->dst_picture = None; - } - - if (surface->src_picture != None) { - XRenderFreePicture (dpy, surface->src_picture); - surface->src_picture = None; - } - - if (surface->owns_pixmap) { - XFreePixmap (dpy, surface->drawable); - surface->drawable = None; - surface->owns_pixmap = FALSE; - } -} - static cairo_surface_t * _cairo_xlib_surface_create_internal (cairo_xlib_screen_t *screen, Drawable drawable, @@ -3277,10 +1476,8 @@ found: return _cairo_surface_create_in_error (_cairo_error (status)); } - _cairo_xlib_display_get_xrender_version (display, - &surface->render_major, - &surface->render_minor); - if (CAIRO_SURFACE_RENDER_HAS_CREATE_PICTURE (surface)) { + surface->display = display; + if (CAIRO_RENDER_HAS_CREATE_PICTURE (display)) { if (!xrender_format) { if (visual) { xrender_format = XRenderFindVisualFormat (display->display, visual); @@ -3290,17 +1487,8 @@ found: CAIRO_FORMAT_A1); } } - } else { - /* we cannot use XRender for this surface, so ensure we don't try */ - surface->render_major = -1; - surface->render_minor = -1; } - /* initialize and hook into the CloseDisplay callback */ - surface->close_display_hook.func = _cairo_xlib_surface_detach_display; - _cairo_xlib_add_close_display_hook (display, - &surface->close_display_hook); - cairo_device_release (&display->base); _cairo_surface_init (&surface->base, @@ -3309,6 +1497,7 @@ found: _xrender_format_to_content (xrender_format)); surface->screen = screen; + surface->compositor = display->compositor; surface->drawable = drawable; surface->owns_pixmap = FALSE; @@ -3316,36 +1505,14 @@ found: surface->width = width; surface->height = height; - surface->buggy_repeat = ! _cairo_xlib_display_has_repeat (screen->device); - if (! CAIRO_SURFACE_RENDER_HAS_FILL_RECTANGLES (surface)) { - /* so we can use the XTile fallback */ - surface->buggy_repeat = TRUE; - } - - surface->buggy_pad_reflect = ! _cairo_xlib_display_has_reflect (screen->device); - if (! CAIRO_SURFACE_RENDER_HAS_EXTENDED_REPEAT (surface)) - surface->buggy_pad_reflect = TRUE; - - surface->buggy_gradients = ! _cairo_xlib_display_has_gradients (screen->device); - if (! CAIRO_SURFACE_RENDER_HAS_GRADIENTS (surface)) - surface->buggy_gradients = TRUE; + surface->picture = None; + surface->precision = PolyModePrecise; - surface->dst_picture = None; - surface->src_picture = None; + surface->embedded_source.picture = None; surface->visual = visual; surface->xrender_format = xrender_format; surface->depth = depth; - surface->filter = CAIRO_FILTER_NEAREST; - surface->extend = CAIRO_EXTEND_NONE; - surface->has_component_alpha = FALSE; - surface->precision = PolyModePrecise; - surface->xtransform = identity; - - surface->clip_region = NULL; - surface->clip_rects = surface->embedded_clip_rects; - surface->num_clip_rects = 0; - surface->clip_dirty = 0; /* * Compute the pixel format masks from either a XrenderFormat or @@ -3411,6 +1578,11 @@ _cairo_xlib_screen_from_visual (Display *dpy, Visual *visual) return NULL; } +static cairo_bool_t valid_size (int width, int height) +{ + return width > 0 && width <= XLIB_COORD_MAX && height > 0 && height <= XLIB_COORD_MAX; +} + /** * cairo_xlib_surface_create: * @dpy: an X Display @@ -3447,7 +1619,7 @@ cairo_xlib_surface_create (Display *dpy, cairo_xlib_screen_t *screen; cairo_status_t status; - if (width > XLIB_COORD_MAX || height > XLIB_COORD_MAX || width <= 0 || height <= 0) { + if (! valid_size (width, height)) { /* you're lying, and you know it! */ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE)); } @@ -3490,7 +1662,7 @@ cairo_xlib_surface_create_for_bitmap (Display *dpy, cairo_xlib_screen_t *screen; cairo_status_t status; - if (width > XLIB_COORD_MAX || height > XLIB_COORD_MAX || width <= 0 || height <= 0) + if (! valid_size (width, height)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE)); status = _cairo_xlib_screen_get (dpy, scr, &screen); @@ -3536,7 +1708,7 @@ cairo_xlib_surface_create_with_xrender_format (Display *dpy, cairo_xlib_screen_t *screen; cairo_status_t status; - if (width > XLIB_COORD_MAX || height > XLIB_COORD_MAX || width <= 0 || height <= 0) + if (! valid_size (width, height)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE)); status = _cairo_xlib_screen_get (dpy, scr, &screen); @@ -3602,25 +1774,24 @@ cairo_xlib_surface_set_size (cairo_surface_t *abstract_surface, int height) { cairo_xlib_surface_t *surface = (cairo_xlib_surface_t *) abstract_surface; - cairo_status_t status; if (unlikely (abstract_surface->status)) return; if (unlikely (abstract_surface->finished)) { - status = _cairo_surface_set_error (abstract_surface, - _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); + _cairo_surface_set_error (abstract_surface, + _cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); return; } if (! _cairo_surface_is_xlib (abstract_surface)) { - status = _cairo_surface_set_error (abstract_surface, - _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); + _cairo_surface_set_error (abstract_surface, + _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); return; } - if (width > XLIB_COORD_MAX || height > XLIB_COORD_MAX || width <= 0 || height <= 0) { - status = _cairo_surface_set_error (abstract_surface, - _cairo_error (CAIRO_STATUS_INVALID_SIZE)); + if (! valid_size (width, height)) { + _cairo_surface_set_error (abstract_surface, + _cairo_error (CAIRO_STATUS_INVALID_SIZE)); return; } @@ -3664,7 +1835,7 @@ cairo_xlib_surface_set_drawable (cairo_surface_t *abstract_surface, return; } - if (width > XLIB_COORD_MAX || height > XLIB_COORD_MAX || width <= 0 || height <= 0) { + if (! valid_size (width, height)) { status = _cairo_surface_set_error (abstract_surface, _cairo_error (CAIRO_STATUS_INVALID_SIZE)); return; @@ -3683,30 +1854,14 @@ cairo_xlib_surface_set_drawable (cairo_surface_t *abstract_surface, X_DEBUG ((display->display, "set_drawable (drawable=%x)", (unsigned int) drawable)); - if (surface->dst_picture != None) { - status = _cairo_xlib_display_queue_resource ( - display, - XRenderFreePicture, - surface->dst_picture); - if (unlikely (status)) { - status = _cairo_surface_set_error (&surface->base, status); - return; - } - - surface->dst_picture = None; - } - - if (surface->src_picture != None) { - status = _cairo_xlib_display_queue_resource ( - display, - XRenderFreePicture, - surface->src_picture); + if (surface->picture != None) { + XRenderFreePicture (display->display, surface->picture); if (unlikely (status)) { status = _cairo_surface_set_error (&surface->base, status); return; } - surface->src_picture = None; + surface->picture = None; } cairo_device_release (&display->base); @@ -3880,1013 +2035,4 @@ cairo_xlib_surface_get_height (cairo_surface_t *abstract_surface) return surface->height; } -enum { - GLYPHSET_INDEX_ARGB32, - GLYPHSET_INDEX_A8, - GLYPHSET_INDEX_A1, - NUM_GLYPHSETS -}; - -typedef struct _cairo_xlib_font_glyphset_free_glyphs { - GlyphSet glyphset; - int glyph_count; - unsigned long glyph_indices[128]; -} cairo_xlib_font_glyphset_free_glyphs_t; - -typedef struct _cairo_xlib_font_glyphset_info { - GlyphSet glyphset; - cairo_format_t format; - XRenderPictFormat *xrender_format; - cairo_xlib_font_glyphset_free_glyphs_t *pending_free_glyphs; -} cairo_xlib_font_glyphset_info_t; - -typedef struct _cairo_xlib_surface_font_private { - cairo_scaled_font_t *scaled_font; - cairo_xlib_hook_t close_display_hook; - cairo_device_t *device; - cairo_xlib_font_glyphset_info_t glyphset_info[NUM_GLYPHSETS]; -} cairo_xlib_surface_font_private_t; - -/* callback from CloseDisplay */ -static void -_cairo_xlib_surface_remove_scaled_font (cairo_xlib_display_t *display, - void *data) -{ - cairo_xlib_surface_font_private_t *font_private; - cairo_scaled_font_t *scaled_font; - - font_private = cairo_container_of (data, - cairo_xlib_surface_font_private_t, - close_display_hook); - scaled_font = font_private->scaled_font; - - CAIRO_MUTEX_LOCK (scaled_font->mutex); - font_private = scaled_font->surface_private; - scaled_font->surface_private = NULL; - - _cairo_scaled_font_reset_cache (scaled_font); - CAIRO_MUTEX_UNLOCK (scaled_font->mutex); - - if (font_private != NULL) { - int i; - - for (i = 0; i < NUM_GLYPHSETS; i++) { - cairo_xlib_font_glyphset_info_t *glyphset_info; - - glyphset_info = &font_private->glyphset_info[i]; - if (glyphset_info->glyphset) - XRenderFreeGlyphSet (display->display, glyphset_info->glyphset); - - free (glyphset_info->pending_free_glyphs); - } - - cairo_device_destroy (font_private->device); - free (font_private); - } -} - -static cairo_status_t -_cairo_xlib_surface_font_init (cairo_xlib_display_t *display, - cairo_scaled_font_t *scaled_font) -{ - cairo_xlib_surface_font_private_t *font_private; - int i; - - font_private = malloc (sizeof (cairo_xlib_surface_font_private_t)); - if (unlikely (font_private == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - - font_private->scaled_font = scaled_font; - font_private->device = cairo_device_reference (&display->base); - - /* initialize and hook into the CloseDisplay callback */ - font_private->close_display_hook.func = - _cairo_xlib_surface_remove_scaled_font; - _cairo_xlib_add_close_display_hook (display, - &font_private->close_display_hook); - - - for (i = 0; i < NUM_GLYPHSETS; i++) { - cairo_xlib_font_glyphset_info_t *glyphset_info = &font_private->glyphset_info[i]; - switch (i) { - case GLYPHSET_INDEX_ARGB32: glyphset_info->format = CAIRO_FORMAT_ARGB32; break; - case GLYPHSET_INDEX_A8: glyphset_info->format = CAIRO_FORMAT_A8; break; - case GLYPHSET_INDEX_A1: glyphset_info->format = CAIRO_FORMAT_A1; break; - default: ASSERT_NOT_REACHED; break; - } - glyphset_info->xrender_format = NULL; - glyphset_info->glyphset = None; - glyphset_info->pending_free_glyphs = NULL; - } - - scaled_font->surface_private = font_private; - scaled_font->surface_backend = &cairo_xlib_surface_backend; - - return CAIRO_STATUS_SUCCESS; -} - -static void -_cairo_xlib_surface_scaled_font_fini (cairo_scaled_font_t *scaled_font) -{ - cairo_xlib_surface_font_private_t *font_private; - cairo_status_t status; - - font_private = scaled_font->surface_private; - if (font_private != NULL) { - cairo_xlib_display_t *display; - int i; - - status = _cairo_xlib_display_acquire (font_private->device, &display); - if (status) - goto BAIL; - - _cairo_xlib_remove_close_display_hook (display, - &font_private->close_display_hook); - - for (i = 0; i < NUM_GLYPHSETS; i++) { - cairo_xlib_font_glyphset_info_t *glyphset_info; - - glyphset_info = &font_private->glyphset_info[i]; - - free (glyphset_info->pending_free_glyphs); - - if (glyphset_info->glyphset) { - status = _cairo_xlib_display_queue_resource (display, - XRenderFreeGlyphSet, - glyphset_info->glyphset); - (void) status; /* XXX cannot propagate failure */ - } - } - - cairo_device_release (&display->base); -BAIL: - cairo_device_destroy (&display->base); - free (font_private); - } -} - -static void -_cairo_xlib_render_free_glyphs (Display *dpy, - cairo_xlib_font_glyphset_free_glyphs_t *to_free) -{ - XRenderFreeGlyphs (dpy, - to_free->glyphset, - to_free->glyph_indices, - to_free->glyph_count); -} - -static cairo_xlib_font_glyphset_info_t * -_cairo_xlib_scaled_glyph_get_glyphset_info (cairo_scaled_glyph_t *scaled_glyph) -{ - return scaled_glyph->surface_private; -} - -static void -_cairo_xlib_scaled_glyph_set_glyphset_info (cairo_scaled_glyph_t *scaled_glyph, - cairo_xlib_font_glyphset_info_t *glyphset_info) -{ - scaled_glyph->surface_private = glyphset_info; -} - -static void -_cairo_xlib_surface_scaled_glyph_fini (cairo_scaled_glyph_t *scaled_glyph, - cairo_scaled_font_t *scaled_font) -{ - cairo_xlib_surface_font_private_t *font_private; - cairo_xlib_font_glyphset_info_t *glyphset_info; - - if (scaled_font->finished) - return; - - font_private = scaled_font->surface_private; - glyphset_info = _cairo_xlib_scaled_glyph_get_glyphset_info (scaled_glyph); - if (font_private != NULL && glyphset_info != NULL) { - cairo_xlib_font_glyphset_free_glyphs_t *to_free; - cairo_status_t status; - - to_free = glyphset_info->pending_free_glyphs; - if (to_free != NULL && - to_free->glyph_count == ARRAY_LENGTH (to_free->glyph_indices)) - { - cairo_xlib_display_t *display; - - status = _cairo_xlib_display_acquire (font_private->device, &display); - if (status == CAIRO_STATUS_SUCCESS) { - status = _cairo_xlib_display_queue_work (display, - (cairo_xlib_notify_func) _cairo_xlib_render_free_glyphs, - to_free, - free); - cairo_device_release (&display->base); - } - /* XXX cannot propagate failure */ - if (unlikely (status)) - free (to_free); - - to_free = glyphset_info->pending_free_glyphs = NULL; - } - - if (to_free == NULL) { - to_free = malloc (sizeof (cairo_xlib_font_glyphset_free_glyphs_t)); - if (unlikely (to_free == NULL)) { - _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); - return; /* XXX cannot propagate failure */ - } - - to_free->glyphset = glyphset_info->glyphset; - to_free->glyph_count = 0; - glyphset_info->pending_free_glyphs = to_free; - } - - to_free->glyph_indices[to_free->glyph_count++] = - _cairo_scaled_glyph_index (scaled_glyph); - } -} - -static int -_cairo_xlib_get_glyphset_index_for_format (cairo_format_t format) -{ - if (format == CAIRO_FORMAT_A8) - return GLYPHSET_INDEX_A8; - if (format == CAIRO_FORMAT_A1) - return GLYPHSET_INDEX_A1; - - assert (format == CAIRO_FORMAT_ARGB32); - return GLYPHSET_INDEX_ARGB32; -} - -static cairo_xlib_font_glyphset_info_t * -_cairo_xlib_scaled_font_get_glyphset_info_for_format (cairo_scaled_font_t *scaled_font, - cairo_format_t format) -{ - cairo_xlib_surface_font_private_t *font_private; - cairo_xlib_font_glyphset_info_t *glyphset_info; - int glyphset_index; - - glyphset_index = _cairo_xlib_get_glyphset_index_for_format (format); - font_private = scaled_font->surface_private; - glyphset_info = &font_private->glyphset_info[glyphset_index]; - if (glyphset_info->glyphset == None) { - cairo_xlib_display_t *display; - - if (_cairo_xlib_display_acquire (font_private->device, &display)) - return NULL; - - glyphset_info->xrender_format = - _cairo_xlib_display_get_xrender_format (display, - glyphset_info->format); - glyphset_info->glyphset = XRenderCreateGlyphSet (display->display, - glyphset_info->xrender_format); - - cairo_device_release (&display->base); - } - - return glyphset_info; -} - -static cairo_bool_t -_cairo_xlib_glyphset_info_has_pending_free_glyph ( - cairo_xlib_font_glyphset_info_t *glyphset_info, - unsigned long glyph_index) -{ - if (glyphset_info->pending_free_glyphs != NULL) { - cairo_xlib_font_glyphset_free_glyphs_t *to_free; - int i; - - to_free = glyphset_info->pending_free_glyphs; - for (i = 0; i < to_free->glyph_count; i++) { - if (to_free->glyph_indices[i] == glyph_index) { - to_free->glyph_count--; - memmove (&to_free->glyph_indices[i], - &to_free->glyph_indices[i+1], - (to_free->glyph_count - i) * sizeof (to_free->glyph_indices[0])); - return TRUE; - } - } - } - - return FALSE; -} - -static cairo_xlib_font_glyphset_info_t * -_cairo_xlib_scaled_font_get_glyphset_info_for_pending_free_glyph ( - cairo_scaled_font_t *scaled_font, - unsigned long glyph_index, - cairo_image_surface_t *surface) -{ - cairo_xlib_surface_font_private_t *font_private; - int i; - - font_private = scaled_font->surface_private; - if (font_private == NULL) - return NULL; - - if (surface != NULL) { - i = _cairo_xlib_get_glyphset_index_for_format (surface->format); - if (_cairo_xlib_glyphset_info_has_pending_free_glyph ( - &font_private->glyphset_info[i], - glyph_index)) - { - return &font_private->glyphset_info[i]; - } - } else { - for (i = 0; i < NUM_GLYPHSETS; i++) { - if (_cairo_xlib_glyphset_info_has_pending_free_glyph ( - &font_private->glyphset_info[i], - glyph_index)) - { - return &font_private->glyphset_info[i]; - } - } - } - - return NULL; -} - -static cairo_status_t -_cairo_xlib_surface_add_glyph (cairo_xlib_display_t *display, - cairo_scaled_font_t *scaled_font, - cairo_scaled_glyph_t **pscaled_glyph) -{ - XGlyphInfo glyph_info; - unsigned long glyph_index; - unsigned char *data; - cairo_status_t status = CAIRO_STATUS_SUCCESS; - cairo_scaled_glyph_t *scaled_glyph = *pscaled_glyph; - cairo_image_surface_t *glyph_surface = scaled_glyph->surface; - cairo_bool_t already_had_glyph_surface; - cairo_xlib_font_glyphset_info_t *glyphset_info; - - glyph_index = _cairo_scaled_glyph_index (scaled_glyph); - - /* check to see if we have a pending XRenderFreeGlyph for this glyph */ - glyphset_info = _cairo_xlib_scaled_font_get_glyphset_info_for_pending_free_glyph (scaled_font, glyph_index, glyph_surface); - if (glyphset_info != NULL) { - _cairo_xlib_scaled_glyph_set_glyphset_info (scaled_glyph, glyphset_info); - return CAIRO_STATUS_SUCCESS; - } - - if (!glyph_surface) { - status = _cairo_scaled_glyph_lookup (scaled_font, - glyph_index, - CAIRO_SCALED_GLYPH_INFO_METRICS | - CAIRO_SCALED_GLYPH_INFO_SURFACE, - pscaled_glyph); - if (unlikely (status)) - return status; - - scaled_glyph = *pscaled_glyph; - glyph_surface = scaled_glyph->surface; - already_had_glyph_surface = FALSE; - } else { - already_had_glyph_surface = TRUE; - } - - if (scaled_font->surface_private == NULL) { - status = _cairo_xlib_surface_font_init (display, scaled_font); - if (unlikely (status)) - return status; - } - - glyphset_info = _cairo_xlib_scaled_font_get_glyphset_info_for_format (scaled_font, - glyph_surface->format); - - /* XRenderAddGlyph does not handle a glyph surface larger than the extended maximum XRequest size. */ - { - int len = cairo_format_stride_for_width (glyphset_info->format, glyph_surface->width) * glyph_surface->height; - int max_request_size = (XExtendedMaxRequestSize (display->display) ? XExtendedMaxRequestSize (display->display) - : XMaxRequestSize (display->display)) * 4 - - sz_xRenderAddGlyphsReq - - sz_xGlyphInfo - - 8; - if (len >= max_request_size) - return UNSUPPORTED ("glyph too large for XRequest"); - } - - /* If the glyph surface has zero height or width, we create - * a clear 1x1 surface, to avoid various X server bugs. - */ - if (glyph_surface->width == 0 || glyph_surface->height == 0) { - cairo_surface_t *tmp_surface; - - tmp_surface = cairo_image_surface_create (glyphset_info->format, 1, 1); - status = tmp_surface->status; - if (unlikely (status)) - goto BAIL; - - tmp_surface->device_transform = glyph_surface->base.device_transform; - tmp_surface->device_transform_inverse = glyph_surface->base.device_transform_inverse; - - glyph_surface = (cairo_image_surface_t *) tmp_surface; - } - - /* If the glyph format does not match the font format, then we - * create a temporary surface for the glyph image with the font's - * format. - */ - if (glyph_surface->format != glyphset_info->format) { - cairo_surface_pattern_t pattern; - cairo_surface_t *tmp_surface; - - tmp_surface = cairo_image_surface_create (glyphset_info->format, - glyph_surface->width, - glyph_surface->height); - status = tmp_surface->status; - if (unlikely (status)) - goto BAIL; - - tmp_surface->device_transform = glyph_surface->base.device_transform; - tmp_surface->device_transform_inverse = glyph_surface->base.device_transform_inverse; - - _cairo_pattern_init_for_surface (&pattern, &glyph_surface->base); - status = _cairo_surface_paint (tmp_surface, - CAIRO_OPERATOR_SOURCE, &pattern.base, - NULL); - _cairo_pattern_fini (&pattern.base); - - glyph_surface = (cairo_image_surface_t *) tmp_surface; - - if (unlikely (status)) - goto BAIL; - } - - /* XXX: FRAGILE: We're ignore device_transform scaling here. A bug? */ - glyph_info.x = _cairo_lround (glyph_surface->base.device_transform.x0); - glyph_info.y = _cairo_lround (glyph_surface->base.device_transform.y0); - glyph_info.width = glyph_surface->width; - glyph_info.height = glyph_surface->height; - glyph_info.xOff = scaled_glyph->x_advance; - glyph_info.yOff = scaled_glyph->y_advance; - - data = glyph_surface->data; - - /* flip formats around */ - switch (_cairo_xlib_get_glyphset_index_for_format (scaled_glyph->surface->format)) { - case GLYPHSET_INDEX_A1: - /* local bitmaps are always stored with bit == byte */ - if (_cairo_is_little_endian() != (BitmapBitOrder (display->display) == LSBFirst)) { - int c = glyph_surface->stride * glyph_surface->height; - unsigned char *d; - unsigned char *new, *n; - - new = malloc (c); - if (!new) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto BAIL; - } - n = new; - d = data; - do { - char b = *d++; - b = ((b << 1) & 0xaa) | ((b >> 1) & 0x55); - b = ((b << 2) & 0xcc) | ((b >> 2) & 0x33); - b = ((b << 4) & 0xf0) | ((b >> 4) & 0x0f); - *n++ = b; - } while (--c); - data = new; - } - break; - case GLYPHSET_INDEX_A8: - break; - case GLYPHSET_INDEX_ARGB32: - if (_cairo_is_little_endian() != (ImageByteOrder (display->display) == LSBFirst)) { - unsigned int c = glyph_surface->stride * glyph_surface->height / 4; - const uint32_t *d; - uint32_t *new, *n; - - new = malloc (4 * c); - if (unlikely (new == NULL)) { - status = _cairo_error (CAIRO_STATUS_NO_MEMORY); - goto BAIL; - } - n = new; - d = (uint32_t *) data; - do { - *n++ = bswap_32 (*d); - d++; - } while (--c); - data = (uint8_t *) new; - } - break; - default: - ASSERT_NOT_REACHED; - break; - } - /* XXX assume X server wants pixman padding. Xft assumes this as well */ - - XRenderAddGlyphs (display->display, glyphset_info->glyphset, - &glyph_index, &glyph_info, 1, - (char *) data, - glyph_surface->stride * glyph_surface->height); - - if (data != glyph_surface->data) - free (data); - - _cairo_xlib_scaled_glyph_set_glyphset_info (scaled_glyph, glyphset_info); - - BAIL: - if (glyph_surface != scaled_glyph->surface) - cairo_surface_destroy (&glyph_surface->base); - - /* if the scaled glyph didn't already have a surface attached - * to it, release the created surface now that we have it - * uploaded to the X server. If the surface has already been - * there (eg. because image backend requested it), leave it in - * the cache - */ - if (!already_had_glyph_surface) - _cairo_scaled_glyph_set_surface (scaled_glyph, scaled_font, NULL); - - return status; -} - -typedef void (*cairo_xrender_composite_text_func_t) - (Display *dpy, - int op, - Picture src, - Picture dst, - _Xconst XRenderPictFormat *maskFormat, - int xSrc, - int ySrc, - int xDst, - int yDst, - _Xconst XGlyphElt8 *elts, - int nelt); - -/* Build a struct of the same size of #cairo_glyph_t that can be used both as - * an input glyph with double coordinates, and as "working" glyph with - * integer from-current-point offsets. */ -typedef union { - cairo_glyph_t d; - unsigned long index; - struct { - unsigned long index; - int x; - int y; - } i; -} cairo_xlib_glyph_t; - -/* compile-time assert that #cairo_xlib_glyph_t is the same size as #cairo_glyph_t */ -COMPILE_TIME_ASSERT (sizeof (cairo_xlib_glyph_t) == sizeof (cairo_glyph_t)); - -/* Start a new element for the first glyph, - * or for any glyph that has unexpected position, - * or if current element has too many glyphs - * (Xrender limits each element to 252 glyphs, we limit them to 128) - * - * These same conditions need to be mirrored between - * _cairo_xlib_surface_emit_glyphs and _emit_glyph_chunks - */ -#define _start_new_glyph_elt(count, glyph) \ - (((count) & 127) == 0 || (glyph)->i.x || (glyph)->i.y) - -static cairo_status_t -_emit_glyphs_chunk (cairo_xlib_display_t *display, - cairo_xlib_surface_t *dst, - cairo_xlib_glyph_t *glyphs, - int num_glyphs, - cairo_scaled_font_t *scaled_font, - cairo_operator_t op, - cairo_xlib_surface_t *src, - cairo_surface_attributes_t *attributes, - /* info for this chunk */ - int num_elts, - int width, - cairo_xlib_font_glyphset_info_t *glyphset_info) -{ - /* Which XRenderCompositeText function to use */ - cairo_xrender_composite_text_func_t composite_text_func; - int size; - - /* Element buffer stuff */ - XGlyphElt8 *elts; - XGlyphElt8 stack_elts[CAIRO_STACK_ARRAY_LENGTH (XGlyphElt8)]; - - /* Reuse the input glyph array for output char generation */ - char *char8 = (char *) glyphs; - unsigned short *char16 = (unsigned short *) glyphs; - unsigned int *char32 = (unsigned int *) glyphs; - - int i; - int nelt; /* Element index */ - int n; /* Num output glyphs in current element */ - int j; /* Num output glyphs so far */ - - switch (width) { - case 1: - /* don't cast the 8-variant, to catch possible mismatches */ - composite_text_func = XRenderCompositeText8; - size = sizeof (char); - break; - case 2: - composite_text_func = (cairo_xrender_composite_text_func_t) XRenderCompositeText16; - size = sizeof (unsigned short); - break; - default: - case 4: - composite_text_func = (cairo_xrender_composite_text_func_t) XRenderCompositeText32; - size = sizeof (unsigned int); - } - - /* Allocate element array */ - if (num_elts <= ARRAY_LENGTH (stack_elts)) { - elts = stack_elts; - } else { - elts = _cairo_malloc_ab (num_elts, sizeof (XGlyphElt8)); - if (unlikely (elts == NULL)) - return _cairo_error (CAIRO_STATUS_NO_MEMORY); - } - - /* Fill them in */ - nelt = 0; - n = 0; - j = 0; - for (i = 0; i < num_glyphs; i++) { - - /* Start a new element for first output glyph, - * or for any glyph that has unexpected position, - * or if current element has too many glyphs. - * - * These same conditions are mirrored in _cairo_xlib_surface_emit_glyphs() - */ - if (_start_new_glyph_elt (j, &glyphs[i])) { - if (j) { - elts[nelt].nchars = n; - nelt++; - n = 0; - } - elts[nelt].chars = char8 + size * j; - elts[nelt].glyphset = glyphset_info->glyphset; - elts[nelt].xOff = glyphs[i].i.x; - elts[nelt].yOff = glyphs[i].i.y; - } - - switch (width) { - case 1: char8 [j] = (char) glyphs[i].index; break; - case 2: char16[j] = (unsigned short) glyphs[i].index; break; - default: - case 4: char32[j] = (unsigned int) glyphs[i].index; break; - } - - n++; - j++; - } - - if (n) { - elts[nelt].nchars = n; - nelt++; - } - - /* Check that we agree with _cairo_xlib_surface_emit_glyphs() on the - * expected number of xGlyphElts. */ - assert (nelt == num_elts); - - composite_text_func (display->display, - _render_operator (op), - src->src_picture, - dst->dst_picture, - glyphset_info->xrender_format, - attributes->x_offset + elts[0].xOff, - attributes->y_offset + elts[0].yOff, - elts[0].xOff, elts[0].yOff, - (XGlyphElt8 *) elts, nelt); - - if (elts != stack_elts) - free (elts); - - return CAIRO_STATUS_SUCCESS; -} - - -/* sz_xGlyphtElt required alignment to a 32-bit boundary, so ensure we have - * enough room for padding */ -#define _cairo_sz_xGlyphElt (sz_xGlyphElt + 4) - -static cairo_status_t -_cairo_xlib_surface_emit_glyphs (cairo_xlib_display_t *display, - cairo_xlib_surface_t *dst, - cairo_xlib_glyph_t *glyphs, - int num_glyphs, - cairo_scaled_font_t *scaled_font, - cairo_operator_t op, - cairo_xlib_surface_t *src, - cairo_surface_attributes_t *attributes, - int *remaining_glyphs) -{ - int i; - cairo_int_status_t status = CAIRO_INT_STATUS_SUCCESS; - cairo_scaled_glyph_t *scaled_glyph; - cairo_fixed_t x = 0, y = 0; - cairo_xlib_font_glyphset_info_t *glyphset_info = NULL, *this_glyphset_info; - - unsigned long max_index = 0; - int width = 1; - int num_elts = 0; - int num_out_glyphs = 0; - - int max_request_size = XMaxRequestSize (display->display) * 4 - - MAX (sz_xRenderCompositeGlyphs8Req, - MAX(sz_xRenderCompositeGlyphs16Req, - sz_xRenderCompositeGlyphs32Req)); - int request_size = 0; - - _cairo_xlib_surface_ensure_dst_picture (display, dst); - - for (i = 0; i < num_glyphs; i++) { - int this_x, this_y; - int old_width; - - status = _cairo_scaled_glyph_lookup (scaled_font, - glyphs[i].index, - CAIRO_SCALED_GLYPH_INFO_METRICS, - &scaled_glyph); - if (unlikely (status)) - return status; - - /* The glyph coordinates must be representable in an int16_t. - * When possible, they will be expressed as an offset from the - * previous glyph, otherwise they will be an offset from the - * surface origin. If we can't guarantee this to be possible, - * fallback. - */ - if (glyphs[i].d.x > INT16_MAX || glyphs[i].d.y > INT16_MAX || - glyphs[i].d.x < INT16_MIN || glyphs[i].d.y < INT16_MIN) - { - break; - } - - this_x = _cairo_lround (glyphs[i].d.x); - this_y = _cairo_lround (glyphs[i].d.y); - - /* Send unsent glyphs to the server */ - if (_cairo_xlib_scaled_glyph_get_glyphset_info (scaled_glyph) == NULL) { - status = _cairo_xlib_surface_add_glyph (display, - scaled_font, - &scaled_glyph); - if (unlikely (status)) { - if (status == CAIRO_INT_STATUS_UNSUPPORTED) - /* Break so we flush glyphs so far and let fallback code - * handle the rest */ - break; - - return status; - } - } - - this_glyphset_info = _cairo_xlib_scaled_glyph_get_glyphset_info (scaled_glyph); - if (!glyphset_info) - glyphset_info = this_glyphset_info; - - /* The invariant here is that we can always flush the glyphs - * accumulated before this one, using old_width, and they - * would fit in the request. - */ - old_width = width; - - /* Update max glyph index */ - if (glyphs[i].index > max_index) { - max_index = glyphs[i].index; - if (max_index >= 65536) - width = 4; - else if (max_index >= 256) - width = 2; - if (width != old_width) - request_size += (width - old_width) * num_out_glyphs; - } - - /* If we will pass the max request size by adding this glyph, - * flush current glyphs. Note that we account for a - * possible element being added below. - * - * Also flush if changing glyphsets, as Xrender limits one mask - * format per request, so we can either break up, or use a - * wide-enough mask format. We do the former. One reason to - * prefer the latter is the fact that Xserver ADDs all glyphs - * to the mask first, and then composes that to final surface, - * though it's not a big deal. - * - * If the glyph has a coordinate which cannot be represented - * as a 16-bit offset from the previous glyph, flush the - * current chunk. The current glyph will be the first one in - * the next chunk, thus its coordinates will be an offset from - * the destination origin. This offset is guaranteed to be - * representable as 16-bit offset (otherwise we would have - * fallen back). - */ - if (request_size + width > max_request_size - _cairo_sz_xGlyphElt || - this_x - x > INT16_MAX || this_x - x < INT16_MIN || - this_y - y > INT16_MAX || this_y - y < INT16_MIN || - (this_glyphset_info != glyphset_info)) { - status = _emit_glyphs_chunk (display, dst, glyphs, i, - scaled_font, op, src, attributes, - num_elts, old_width, glyphset_info); - if (unlikely (status)) - return status; - - glyphs += i; - num_glyphs -= i; - i = 0; - max_index = glyphs[i].index; - width = max_index < 256 ? 1 : max_index < 65536 ? 2 : 4; - request_size = 0; - num_elts = 0; - num_out_glyphs = 0; - x = y = 0; - glyphset_info = this_glyphset_info; - } - - /* Convert absolute glyph position to relative-to-current-point - * position */ - glyphs[i].i.x = this_x - x; - glyphs[i].i.y = this_y - y; - - /* Start a new element for the first glyph, - * or for any glyph that has unexpected position, - * or if current element has too many glyphs. - * - * These same conditions are mirrored in _emit_glyphs_chunk(). - */ - if (_start_new_glyph_elt (num_out_glyphs, &glyphs[i])) { - num_elts++; - request_size += _cairo_sz_xGlyphElt; - } - - /* adjust current-position */ - x = this_x + scaled_glyph->x_advance; - y = this_y + scaled_glyph->y_advance; - - num_out_glyphs++; - request_size += width; - } - - if (num_elts) { - status = _emit_glyphs_chunk (display, dst, glyphs, i, - scaled_font, op, src, attributes, - num_elts, width, glyphset_info); - } - - *remaining_glyphs = num_glyphs - i; - if (*remaining_glyphs != 0 && status == CAIRO_INT_STATUS_SUCCESS) - status = CAIRO_INT_STATUS_UNSUPPORTED; - - return status; -} - -static cairo_bool_t -_cairo_xlib_surface_owns_font (cairo_xlib_surface_t *dst, - cairo_scaled_font_t *scaled_font) -{ - cairo_xlib_surface_font_private_t *font_private; - - font_private = scaled_font->surface_private; - if ((scaled_font->surface_backend != NULL && - scaled_font->surface_backend != &cairo_xlib_surface_backend) || - (font_private != NULL && font_private->device != dst->base.device)) - { - return FALSE; - } - - return TRUE; -} - -static cairo_int_status_t -_cairo_xlib_surface_show_glyphs (void *abstract_dst, - cairo_operator_t op, - const cairo_pattern_t *src_pattern, - cairo_glyph_t *glyphs, - int num_glyphs, - cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip, - int *remaining_glyphs) -{ - cairo_int_status_t status = CAIRO_STATUS_SUCCESS; - cairo_xlib_surface_t *dst = (cairo_xlib_surface_t*) abstract_dst; - composite_operation_t operation; - cairo_surface_attributes_t attributes; - cairo_xlib_surface_t *src = NULL; - cairo_xlib_display_t *display; - - if (! CAIRO_SURFACE_RENDER_HAS_COMPOSITE_TEXT (dst)) - return UNSUPPORTED ("XRender does not support CompositeText"); - - /* Just let unbounded operators go through the fallback code - * instead of trying to do the fixups here */ - if (! _cairo_operator_bounded_by_mask (op)) - return UNSUPPORTED ("unsupported unbounded op"); - - /* Render <= 0.10 seems to have a bug with PictOpSrc and glyphs -- - * the solid source seems to be multiplied by the glyph mask, and - * then the entire thing is copied to the destination surface, - * including the fully transparent "background" of the rectangular - * glyph surface. */ - if (op == CAIRO_OPERATOR_SOURCE) - return UNSUPPORTED ("known bug in Render"); - - /* We can only use our code if we either have no clip or - * have a real native clip region set. If we're using - * fallback clip masking, we have to go through the full - * fallback path. - */ - if (!_cairo_clip_is_region (clip)) - return UNSUPPORTED ("clip mask required"); - - operation = _categorize_composite_operation (dst, op, src_pattern, TRUE); - if (operation == DO_UNSUPPORTED) - return UNSUPPORTED ("unsupported op"); - - if (! _cairo_xlib_surface_owns_font (dst, scaled_font)) - return UNSUPPORTED ("unowned font"); - - status = _cairo_xlib_display_acquire (dst->base.device, &display); - if (unlikely (status)) - return status; - - X_DEBUG ((display->display, "show_glyphs (dst=%x)", (unsigned int) dst->drawable)); - - status = _cairo_xlib_surface_set_clip_region (dst, - _cairo_clip_get_region (clip)); - if (unlikely (status)) - goto BAIL0; - - /* After passing all those tests, we're now committed to rendering - * these glyphs or to fail trying. We first upload any glyphs to - * the X server that it doesn't have already, then we draw - * them. - */ - - /* PictOpClear doesn't seem to work with CompositeText; it seems to ignore - * the mask (the glyphs). This code below was executed as a side effect - * of going through the _clip_and_composite fallback code for old_show_glyphs, - * so PictOpClear was never used with CompositeText before. - */ - if (op == CAIRO_OPERATOR_CLEAR) { - src_pattern = &_cairo_pattern_white.base; - op = CAIRO_OPERATOR_DEST_OUT; - } - - if (src_pattern->type == CAIRO_PATTERN_TYPE_SOLID) { - status = _cairo_pattern_acquire_surface (src_pattern, &dst->base, - 0, 0, 1, 1, - CAIRO_PATTERN_ACQUIRE_NONE, - (cairo_surface_t **) &src, - &attributes); - if (unlikely (status)) - goto BAIL0; - } else { - cairo_rectangle_int_t glyph_extents; - - status = _cairo_scaled_font_glyph_device_extents (scaled_font, - glyphs, - num_glyphs, - &glyph_extents, - NULL); - if (unlikely (status)) - goto BAIL0; - - status = _cairo_xlib_surface_acquire_pattern_surface (display, - dst, src_pattern, - glyph_extents.x, - glyph_extents.y, - glyph_extents.width, - glyph_extents.height, - &src, &attributes); - if (unlikely (status)) - goto BAIL0; - } - - operation = _recategorize_composite_operation (dst, op, src, - &attributes, TRUE); - if (operation == DO_UNSUPPORTED) { - status = UNSUPPORTED ("unsupported op"); - goto BAIL1; - } - - status = _cairo_xlib_surface_set_attributes (display, src, &attributes, 0, 0); - if (unlikely (status)) - goto BAIL1; - - _cairo_scaled_font_freeze_cache (scaled_font); - if (_cairo_xlib_surface_owns_font (dst, scaled_font)) { - status = _cairo_xlib_surface_emit_glyphs (display, - dst, - (cairo_xlib_glyph_t *) glyphs, - num_glyphs, - scaled_font, - op, - src, - &attributes, - remaining_glyphs); - } else { - status = UNSUPPORTED ("unowned font"); - } - _cairo_scaled_font_thaw_cache (scaled_font); - - BAIL1: - if (src) - _cairo_pattern_release_surface (src_pattern, &src->base, &attributes); - BAIL0: - cairo_device_release (&display->base); - - return status; -} - #endif /* !CAIRO_HAS_XLIB_XCB_FUNCTIONS */ diff --git a/src/cairo.c b/src/cairo.c index 6f6d00e6..cbc39745 100644 --- a/src/cairo.c +++ b/src/cairo.c @@ -46,6 +46,7 @@ #include "cairo-path-private.h" #include "cairo-pattern-private.h" #include "cairo-surface-private.h" +#include "cairo-surface-backend-private.h" #include <assert.h> diff --git a/src/cairo.h b/src/cairo.h index 710d9978..f5450fec 100644 --- a/src/cairo.h +++ b/src/cairo.h @@ -2123,7 +2123,7 @@ cairo_surface_create_similar_image (cairo_surface_t *other, cairo_public cairo_surface_t * cairo_surface_map_to_image (cairo_surface_t *surface, - const cairo_rectangle_t *extents); + const cairo_rectangle_int_t *extents); cairo_public void cairo_surface_unmap_image (cairo_surface_t *surface, @@ -2145,6 +2145,45 @@ cairo_public cairo_surface_t * cairo_surface_create_observer (cairo_surface_t *target, cairo_surface_observer_mode_t mode); +typedef void (*cairo_surface_observer_callback_t) (cairo_surface_t *observer, + cairo_surface_t *target, + void *data); + +cairo_public cairo_status_t +cairo_surface_observer_add_paint_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data); + +cairo_public cairo_status_t +cairo_surface_observer_add_mask_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data); + +cairo_public cairo_status_t +cairo_surface_observer_add_fill_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data); + +cairo_public cairo_status_t +cairo_surface_observer_add_stroke_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data); + +cairo_public cairo_status_t +cairo_surface_observer_add_glyphs_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data); + +cairo_public cairo_status_t +cairo_surface_observer_add_flush_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data); + +cairo_public cairo_status_t +cairo_surface_observer_add_finish_callback (cairo_surface_t *abstract_surface, + cairo_surface_observer_callback_t func, + void *data); + cairo_public void cairo_surface_observer_print (cairo_surface_t *surface, cairo_write_func_t write_func, @@ -2426,6 +2465,10 @@ cairo_recording_surface_ink_extents (cairo_surface_t *surface, double *width, double *height); +cairo_public cairo_bool_t +cairo_recording_surface_get_extents (cairo_surface_t *surface, + cairo_rectangle_t *extents); + /* Mime-surface (callback) functions */ typedef cairo_surface_t *(*cairo_mime_surface_acquire_t) (cairo_surface_t *mime_surface, diff --git a/src/cairoint.h b/src/cairoint.h index 5ae8b7a5..28f3e9f3 100644 --- a/src/cairoint.h +++ b/src/cairoint.h @@ -287,16 +287,14 @@ _cairo_boxes_get_extents (const cairo_box_t *boxes, int num_boxes, cairo_box_t *extents); +cairo_private extern const cairo_rectangle_int_t _cairo_empty_rectangle; +cairo_private extern const cairo_rectangle_int_t _cairo_unbounded_rectangle; + static inline void _cairo_unbounded_rectangle_init (cairo_rectangle_int_t *rect) { - rect->x = CAIRO_RECT_INT_MIN; - rect->y = CAIRO_RECT_INT_MIN; - rect->width = CAIRO_RECT_INT_MAX - CAIRO_RECT_INT_MIN; - rect->height = CAIRO_RECT_INT_MAX - CAIRO_RECT_INT_MIN; + *rect = _cairo_unbounded_rectangle; } -cairo_private extern const cairo_rectangle_int_t _cairo_empty_rectangle; -cairo_private extern const cairo_rectangle_int_t _cairo_unbounded_rectangle; cairo_private_no_warn cairo_bool_t _cairo_rectangle_intersect (cairo_rectangle_int_t *dst, @@ -327,47 +325,12 @@ cairo_private cairo_bool_t _cairo_box_intersects_line_segment (cairo_box_t *box, cairo_line_t *line) cairo_pure; -/* cairo-array.c structures and functions */ - -cairo_private void -_cairo_array_init (cairo_array_t *array, unsigned int element_size); - -cairo_private void -_cairo_array_fini (cairo_array_t *array); - -cairo_private cairo_status_t -_cairo_array_grow_by (cairo_array_t *array, unsigned int additional); - -cairo_private void -_cairo_array_truncate (cairo_array_t *array, unsigned int num_elements); - -cairo_private cairo_status_t -_cairo_array_append (cairo_array_t *array, const void *element); - -cairo_private cairo_status_t -_cairo_array_append_multiple (cairo_array_t *array, - const void *elements, - unsigned int num_elements); - -cairo_private cairo_status_t -_cairo_array_allocate (cairo_array_t *array, - unsigned int num_elements, - void **elements); - -cairo_private void * -_cairo_array_index (cairo_array_t *array, unsigned int index); - -cairo_private const void * -_cairo_array_index_const (const cairo_array_t *array, unsigned int index); - -cairo_private void -_cairo_array_copy_element (const cairo_array_t *array, unsigned int index, void *dst); - -cairo_private unsigned int -_cairo_array_num_elements (const cairo_array_t *array); - -cairo_private unsigned int -_cairo_array_size (const cairo_array_t *array); +cairo_private cairo_bool_t +_cairo_spline_intersects (const cairo_point_t *a, + const cairo_point_t *b, + const cairo_point_t *c, + const cairo_point_t *d, + const cairo_box_t *box) cairo_pure; typedef struct { const cairo_user_data_key_t *key; @@ -407,10 +370,6 @@ _cairo_user_data_array_foreach (cairo_user_data_array_t *array, cairo_private unsigned long _cairo_hash_string (const char *c); -cairo_private void -_cairo_pattern_get_ink_extents (const cairo_pattern_t *pattern, - cairo_rectangle_int_t *extents); - cairo_private unsigned long _cairo_hash_bytes (unsigned long hash, const void *bytes, @@ -518,21 +477,6 @@ struct _cairo_scaled_font_backend { unsigned long (*ucs4_to_index) (void *scaled_font, uint32_t ucs4); - cairo_warn cairo_int_status_t - (*show_glyphs) (void *scaled_font, - cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_surface_t *surface, - int source_x, - int source_y, - int dest_x, - int dest_y, - unsigned int width, - unsigned int height, - cairo_glyph_t *glyphs, - int num_glyphs, - cairo_region_t *clip_region, - int *remaining_glyphs); /* Read data from a sfnt font table. * @scaled_font: font @@ -657,301 +601,6 @@ extern const cairo_private struct _cairo_font_face_backend _cairo_quartz_font_fa #endif -struct _cairo_surface_backend { - cairo_surface_type_t type; - - cairo_warn cairo_status_t - (*finish) (void *surface); - - cairo_t * - (*create_context) (void *surface); - - cairo_surface_t * - (*create_similar) (void *surface, - cairo_content_t content, - int width, - int height); - cairo_surface_t * - (*create_similar_image) (void *surface, - cairo_format_t format, - int width, - int height); - - cairo_surface_t * - (*map_to_image) (void *surface, - const cairo_rectangle_int_t *extents); - cairo_int_status_t - (*unmap_image) (void *surface, - cairo_image_surface_t *image); - - cairo_warn cairo_status_t - (*acquire_source_image) (void *abstract_surface, - cairo_image_surface_t **image_out, - void **image_extra); - - void - (*release_source_image) (void *abstract_surface, - cairo_image_surface_t *image, - void *image_extra); - - cairo_warn cairo_status_t - (*acquire_dest_image) (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t **image_out, - cairo_rectangle_int_t *image_rect, - void **image_extra); - - void - (*release_dest_image) (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t *image, - cairo_rectangle_int_t *image_rect, - void *image_extra); - - /* Create a new surface (@clone_out) with the following - * characteristics: - * - * 1. It is as compatible as possible with @surface (in terms of - * efficiency) - * - * 2. It has the same contents as @src within the given rectangle. - * - * 3. The offset of the similar surface with respect to the original - * surface is returned in the clone_offset vector. - * - if you clone the entire surface, this vector is zero. - * - if you clone (src_x, src_y)x(w, h) the vector is (src_x, src_y); - */ - cairo_warn cairo_status_t - (*clone_similar) (void *surface, - cairo_surface_t *src, - int src_x, - int src_y, - int width, - int height, - int *clone_offset_x, - int *clone_offset_y, - cairo_surface_t **clone_out); - - /* XXX remove to a separate cairo_surface_compositor_t */ - /* XXX: dst should be the first argument for consistency */ - cairo_warn cairo_int_status_t - (*composite) (cairo_operator_t op, - const cairo_pattern_t *src, - const cairo_pattern_t *mask, - void *dst, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region); - - cairo_warn cairo_int_status_t - (*fill_rectangles) (void *surface, - cairo_operator_t op, - const cairo_color_t *color, - cairo_rectangle_int_t *rects, - int num_rects); - - /* XXX: dst should be the first argument for consistency */ - cairo_warn cairo_int_status_t - (*composite_trapezoids) (cairo_operator_t op, - const cairo_pattern_t *pattern, - void *dst, - cairo_antialias_t antialias, - int src_x, - int src_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_trapezoid_t *traps, - int num_traps, - cairo_region_t *region); - - cairo_warn cairo_span_renderer_t * - (*create_span_renderer) (cairo_operator_t op, - const cairo_pattern_t *pattern, - void *dst, - cairo_antialias_t antialias, - const cairo_composite_rectangles_t *rects, - cairo_region_t *clip_region); - - - cairo_warn cairo_bool_t - (*check_span_renderer) (cairo_operator_t op, - const cairo_pattern_t *pattern, - void *dst, - cairo_antialias_t antialias); - - cairo_warn cairo_int_status_t - (*copy_page) (void *surface); - - cairo_warn cairo_int_status_t - (*show_page) (void *surface); - - /* Get the extents of the current surface. For many surface types - * this will be as simple as { x=0, y=0, width=surface->width, - * height=surface->height}. - * - * If this function is not implemented, or if it returns - * FALSE the surface is considered to be - * boundless and infinite bounds are used for it. - */ - cairo_bool_t - (*get_extents) (void *surface, - cairo_rectangle_int_t *extents); - - /* - * This is an optional entry to let the surface manage its own glyph - * resources. If null, render against this surface, using image - * surfaces as glyphs. - */ - cairo_warn cairo_int_status_t - (*old_show_glyphs) (cairo_scaled_font_t *font, - cairo_operator_t op, - const cairo_pattern_t *pattern, - void *surface, - int source_x, - int source_y, - int dest_x, - int dest_y, - unsigned int width, - unsigned int height, - cairo_glyph_t *glyphs, - int num_glyphs, - cairo_region_t *clip_region); - - void - (*get_font_options) (void *surface, - cairo_font_options_t *options); - - cairo_warn cairo_status_t - (*flush) (void *surface); - - cairo_warn cairo_status_t - (*mark_dirty_rectangle) (void *surface, - int x, - int y, - int width, - int height); - - void - (*scaled_font_fini) (cairo_scaled_font_t *scaled_font); - - void - (*scaled_glyph_fini) (cairo_scaled_glyph_t *scaled_glyph, - cairo_scaled_font_t *scaled_font); - - /* OK, I'm starting over somewhat by defining the 5 top-level - * drawing operators for the surface backend here with consistent - * naming and argument-order conventions. */ - cairo_warn cairo_int_status_t - (*paint) (void *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_clip_t *clip); - - cairo_warn cairo_int_status_t - (*mask) (void *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_pattern_t *mask, - const cairo_clip_t *clip); - - cairo_warn cairo_int_status_t - (*stroke) (void *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_warn cairo_int_status_t - (*fill) (void *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_warn cairo_int_status_t - (*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, - int *remaining_glyphs); - - cairo_surface_t * - (*snapshot) (void *surface); - - cairo_bool_t - (*is_similar) (void *surface_a, - void *surface_b); - - cairo_warn cairo_int_status_t - (*fill_stroke) (void *surface, - cairo_operator_t fill_op, - const cairo_pattern_t *fill_source, - cairo_fill_rule_t fill_rule, - double fill_tolerance, - cairo_antialias_t fill_antialias, - const cairo_path_fixed_t*path, - cairo_operator_t stroke_op, - const cairo_pattern_t *stroke_source, - const cairo_stroke_style_t *stroke_style, - const cairo_matrix_t *stroke_ctm, - const cairo_matrix_t *stroke_ctm_inverse, - double stroke_tolerance, - cairo_antialias_t stroke_antialias, - const cairo_clip_t *clip); - - cairo_surface_t * - (*create_solid_pattern_surface) - (void *surface, - const cairo_solid_pattern_t *solid_pattern); - - cairo_bool_t - (*can_repaint_solid_pattern_surface) - (void *surface, - const cairo_solid_pattern_t *solid_pattern); - - cairo_bool_t - (*has_show_text_glyphs) (void *surface); - - cairo_warn cairo_int_status_t - (*show_text_glyphs) (void *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const char *utf8, - int utf8_len, - cairo_glyph_t *glyphs, - int num_glyphs, - const cairo_text_cluster_t *clusters, - int num_clusters, - cairo_text_cluster_flags_t cluster_flags, - cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip); - - cairo_warn cairo_status_t - (*acquire_source_image_transformed) (void *abstract_surface, - cairo_matrix_t *device_transform, - cairo_image_surface_t **image_out, - void **image_extra); -}; - #define CAIRO_EXTEND_SURFACE_DEFAULT CAIRO_EXTEND_NONE #define CAIRO_EXTEND_GRADIENT_DEFAULT CAIRO_EXTEND_PAD #define CAIRO_FILTER_DEFAULT CAIRO_FILTER_GOOD @@ -970,23 +619,6 @@ struct _cairo_surface_attributes { void *extra; }; -typedef struct _cairo_traps { - cairo_status_t status; - - const cairo_box_t *limits; - int num_limits; - - unsigned int maybe_region : 1; /* hint: 0 implies that it cannot be */ - unsigned int has_intersections : 1; - unsigned int is_rectilinear : 1; - unsigned int is_rectangular : 1; - - int num_traps; - int traps_size; - cairo_trapezoid_t *traps; - cairo_trapezoid_t traps_embedded[16]; -} cairo_traps_t; - #define CAIRO_FONT_SLANT_DEFAULT CAIRO_FONT_SLANT_NORMAL #define CAIRO_FONT_WEIGHT_DEFAULT CAIRO_FONT_WEIGHT_NORMAL @@ -1403,6 +1035,14 @@ _cairo_path_fixed_stroke_to_polygon (const cairo_path_fixed_t *path, double tolerance, cairo_polygon_t *polygon); +cairo_private cairo_int_status_t +_cairo_path_fixed_stroke_to_tristrip (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_tristrip_t *strip); + cairo_private cairo_status_t _cairo_path_fixed_stroke_dashed_to_polygon (const cairo_path_fixed_t *path, const cairo_stroke_style_t *stroke_style, @@ -1569,6 +1209,7 @@ _cairo_stroke_style_fini (cairo_stroke_style_t *style); cairo_private void _cairo_stroke_style_max_distance_from_path (const cairo_stroke_style_t *style, + const cairo_path_fixed_t *path, const cairo_matrix_t *ctm, double *dx, double *dy); @@ -1601,7 +1242,7 @@ cairo_private cairo_status_t _cairo_surface_copy_mime_data (cairo_surface_t *dst, cairo_surface_t *src); -cairo_private cairo_int_status_t +cairo_private_no_warn cairo_int_status_t _cairo_surface_set_error (cairo_surface_t *surface, cairo_int_status_t status); @@ -1625,17 +1266,7 @@ _cairo_surface_create_similar_solid (cairo_surface_t *other, cairo_content_t content, int width, int height, - const cairo_color_t *color, - cairo_bool_t allow_fallback); - -cairo_private cairo_surface_t * -_cairo_surface_create_solid_pattern_surface (cairo_surface_t *other, - const cairo_solid_pattern_t *solid_pattern); - -cairo_private cairo_int_status_t -_cairo_surface_repaint_solid_pattern_surface (cairo_surface_t *other, - cairo_surface_t *solid_surface, - const cairo_solid_pattern_t *solid_pattern); + const cairo_color_t *color); cairo_private void _cairo_surface_init (cairo_surface_t *surface, @@ -1648,34 +1279,6 @@ _cairo_surface_set_font_options (cairo_surface_t *surface, cairo_font_options_t *options); cairo_private cairo_status_t -_cairo_surface_composite (cairo_operator_t op, - const cairo_pattern_t *src, - const cairo_pattern_t *mask, - cairo_surface_t *dst, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region); - -cairo_private cairo_status_t -_cairo_surface_fill_region (cairo_surface_t *surface, - cairo_operator_t op, - const cairo_color_t *color, - cairo_region_t *region); - -cairo_private cairo_status_t -_cairo_surface_fill_rectangles (cairo_surface_t *surface, - cairo_operator_t op, - const cairo_color_t *color, - cairo_rectangle_int_t *rects, - int num_rects); - -cairo_private cairo_status_t _cairo_surface_paint (cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, @@ -1742,75 +1345,15 @@ _cairo_surface_show_text_glyphs (cairo_surface_t *surface, const cairo_clip_t *clip); cairo_private cairo_status_t -_cairo_surface_composite_trapezoids (cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_surface_t *dst, - cairo_antialias_t antialias, - int src_x, - int src_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_trapezoid_t *traps, - int ntraps, - cairo_region_t *clip_region); - -cairo_private cairo_span_renderer_t * -_cairo_surface_create_span_renderer (cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_surface_t *dst, - cairo_antialias_t antialias, - const cairo_composite_rectangles_t *rects, - cairo_region_t *clip_region); - -cairo_private cairo_bool_t -_cairo_surface_check_span_renderer (cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_surface_t *dst, - cairo_antialias_t antialias); - -cairo_private cairo_status_t _cairo_surface_acquire_source_image (cairo_surface_t *surface, cairo_image_surface_t **image_out, void **image_extra); -cairo_private cairo_status_t -_cairo_surface_acquire_source_image_transformed (cairo_surface_t *surface, - cairo_matrix_t *device_trasnform, - cairo_image_surface_t **image_out, - void **image_extra); - cairo_private void _cairo_surface_release_source_image (cairo_surface_t *surface, cairo_image_surface_t *image, void *image_extra); -cairo_private cairo_status_t -_cairo_surface_acquire_dest_image (cairo_surface_t *surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t **image_out, - cairo_rectangle_int_t *image_rect, - void **image_extra); - -cairo_private void -_cairo_surface_release_dest_image (cairo_surface_t *surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t *image, - cairo_rectangle_int_t *image_rect, - void *image_extra); - -cairo_private cairo_status_t -_cairo_surface_clone_similar (cairo_surface_t *surface, - cairo_surface_t *src, - int src_x, - int src_y, - int width, - int height, - int *clone_offset_x, - int *clone_offset_y, - cairo_surface_t **clone_out); - cairo_private cairo_surface_t * _cairo_surface_snapshot (cairo_surface_t *surface); @@ -1826,67 +1369,10 @@ _cairo_surface_has_snapshot (cairo_surface_t *surface, cairo_private void _cairo_surface_detach_snapshot (cairo_surface_t *snapshot); -cairo_private cairo_bool_t -_cairo_surface_is_similar (cairo_surface_t *surface_a, - cairo_surface_t *surface_b); - cairo_private_no_warn cairo_bool_t _cairo_surface_get_extents (cairo_surface_t *surface, cairo_rectangle_int_t *extents); -cairo_private cairo_status_t -_cairo_surface_old_show_glyphs (cairo_scaled_font_t *scaled_font, - cairo_operator_t op, - const cairo_pattern_t *pattern, - cairo_surface_t *surface, - int source_x, - int source_y, - int dest_x, - int dest_y, - unsigned int width, - unsigned int height, - cairo_glyph_t *glyphs, - int num_glyphs, - cairo_region_t *clip_region); - -cairo_private cairo_status_t -_cairo_surface_composite_fixup_unbounded (cairo_surface_t *dst, - cairo_surface_attributes_t *src_attr, - int src_width, - int src_height, - cairo_surface_attributes_t *mask_attr, - int mask_width, - int mask_height, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region); - -cairo_private cairo_status_t -_cairo_surface_composite_shape_fixup_unbounded (cairo_surface_t *dst, - cairo_surface_attributes_t *src_attr, - int src_width, - int src_height, - int mask_width, - int mask_height, - int src_x, - int src_y, - int mask_x, - int mask_y, - int dst_x, - int dst_y, - unsigned int width, - unsigned int height, - cairo_region_t *clip_region); - -cairo_private cairo_bool_t -_cairo_surface_is_opaque (const cairo_surface_t *surface); - cairo_private void _cairo_surface_set_device_scale (cairo_surface_t *surface, double sx, @@ -1999,22 +1485,12 @@ cairo_private cairo_image_surface_t * _cairo_image_surface_coerce_to_format (cairo_image_surface_t *surface, cairo_format_t format); -cairo_private void -_cairo_image_surface_span_render_row (int y, - const cairo_half_open_span_t *spans, - unsigned num_spans, - uint8_t *data, - uint32_t stride); - cairo_private cairo_image_transparency_t _cairo_image_analyze_transparency (cairo_image_surface_t *image); cairo_private cairo_image_color_t _cairo_image_analyze_color (cairo_image_surface_t *image); -cairo_private cairo_bool_t -_cairo_surface_is_image (const cairo_surface_t *surface) cairo_pure; - /* cairo-pen.c */ cairo_private cairo_status_t _cairo_pen_init (cairo_pen_t *pen, @@ -2079,6 +1555,9 @@ cairo_private cairo_status_t _cairo_polygon_add_contour (cairo_polygon_t *polygon, const cairo_contour_t *contour); +cairo_private void +_cairo_polygon_translate (cairo_polygon_t *polygon, int dx, int dy); + cairo_private cairo_status_t _cairo_polygon_reduce (cairo_polygon_t *polygon, cairo_fill_rule_t fill_rule); @@ -2087,6 +1566,12 @@ cairo_private cairo_status_t _cairo_polygon_intersect (cairo_polygon_t *a, int winding_a, cairo_polygon_t *b, int winding_b); +cairo_private cairo_status_t +_cairo_polygon_intersect_with_boxes (cairo_polygon_t *polygon, + cairo_fill_rule_t *winding, + cairo_box_t *boxes, + int num_boxes); + static inline cairo_bool_t _cairo_polygon_is_empty (const cairo_polygon_t *polygon) { @@ -2180,44 +1665,6 @@ _cairo_matrix_to_pixman_matrix_offset (const cairo_matrix_t *matrix, int *out_x_offset, int *out_y_offset); -/* cairo-traps.c */ -cairo_private void -_cairo_traps_init (cairo_traps_t *traps); - -cairo_private void -_cairo_traps_init_with_clip (cairo_traps_t *traps, - const cairo_clip_t *clip); - -cairo_private void -_cairo_traps_limit (cairo_traps_t *traps, - const cairo_box_t *boxes, - int num_boxes); - -cairo_private cairo_status_t -_cairo_traps_init_boxes (cairo_traps_t *traps, - const cairo_boxes_t *boxes); - -cairo_private void -_cairo_traps_clear (cairo_traps_t *traps); - -cairo_private void -_cairo_traps_fini (cairo_traps_t *traps); - -#define _cairo_traps_status(T) (T)->status - -cairo_private void -_cairo_traps_translate (cairo_traps_t *traps, int x, int y); - -cairo_private cairo_status_t -_cairo_traps_tessellate_rectangle (cairo_traps_t *traps, - const cairo_point_t *top_left, - const cairo_point_t *bottom_right); - -cairo_private void -_cairo_traps_add_trap (cairo_traps_t *traps, - cairo_fixed_t top, cairo_fixed_t bottom, - cairo_line_t *left, cairo_line_t *right); - cairo_private cairo_status_t _cairo_bentley_ottmann_tessellate_rectilinear_polygon (cairo_traps_t *traps, const cairo_polygon_t *polygon, @@ -2250,23 +1697,6 @@ _cairo_bentley_ottmann_tessellate_rectilinear_polygon_to_boxes (const cairo_poly cairo_fill_rule_t fill_rule, cairo_boxes_t *boxes); -cairo_private int -_cairo_traps_contain (const cairo_traps_t *traps, - double x, double y); - -cairo_private void -_cairo_traps_extents (const cairo_traps_t *traps, - cairo_box_t *extents); - -cairo_private cairo_int_status_t -_cairo_traps_extract_region (cairo_traps_t *traps, - cairo_antialias_t antialias, - cairo_region_t **region); - -cairo_private cairo_status_t -_cairo_traps_path (const cairo_traps_t *traps, - cairo_path_fixed_t *path); - cairo_private void _cairo_trapezoid_array_translate_and_scale (cairo_trapezoid_t *offset_traps, cairo_trapezoid_t *src_traps, @@ -2422,6 +1852,7 @@ slim_hidden_proto (cairo_status); slim_hidden_proto (cairo_stroke); slim_hidden_proto (cairo_stroke_preserve); slim_hidden_proto (cairo_surface_copy_page); +slim_hidden_proto (cairo_surface_create_similar_image); slim_hidden_proto (cairo_surface_destroy); slim_hidden_proto (cairo_surface_finish); slim_hidden_proto (cairo_surface_flush); diff --git a/src/skia/cairo-skia-context.cpp b/src/skia/cairo-skia-context.cpp index 828f6e59..e5d48280 100644 --- a/src/skia/cairo-skia-context.cpp +++ b/src/skia/cairo-skia-context.cpp @@ -50,6 +50,7 @@ #include "cairo-path-private.h" #include "cairo-pattern-private.h" #include "cairo-skia-private.h" +#include "cairo-surface-backend-private.h" #include <SkShader.h> #include <SkColorShader.h> diff --git a/src/skia/cairo-skia-surface.cpp b/src/skia/cairo-skia-surface.cpp index 4c10625a..56b4dca1 100644 --- a/src/skia/cairo-skia-surface.cpp +++ b/src/skia/cairo-skia-surface.cpp @@ -41,6 +41,8 @@ #include "cairo-composite-rectangles-private.h" #include "cairo-error-private.h" +#include "cairo-surface-backend-private.h" +#include "cairo-surface-fallback-private.h" static cairo_skia_surface_t * _cairo_skia_surface_create_internal (SkBitmap::Config config, @@ -161,198 +163,6 @@ _cairo_skia_surface_get_font_options (void *abstract_surface, _cairo_font_options_set_round_glyph_positions (options, CAIRO_ROUND_GLYPH_POS_ON); } -static cairo_rectangle_t * -to_rectangle (cairo_rectangle_t *rf, - cairo_rectangle_int_t *ri) -{ - rf->x = ri->x; - rf->y = ri->y; - rf->width = ri->width; - rf->height = ri->height; - return rf; -} - -static cairo_int_status_t -_cairo_foreign_surface_paint (void *abstract_surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_clip_t *clip) -{ - cairo_surface_t *surface = (cairo_surface_t *) abstract_surface; - cairo_surface_t *image; - cairo_rectangle_int_t extents; - cairo_rectangle_t rect; - cairo_composite_rectangles_t composite; - cairo_int_status_t status; - - _cairo_surface_get_extents (surface, &extents); - status = _cairo_composite_rectangles_init_for_paint (&composite, &extents, - op, source, - clip); - if (unlikely (status)) - return status; - - image = cairo_surface_map_to_image (surface, - to_rectangle(&rect, &composite.unbounded)); - status = (cairo_int_status_t) - _cairo_surface_paint (image, op, source, clip); - cairo_surface_unmap_image (surface, image); - - _cairo_composite_rectangles_fini (&composite); - - return status; -} - -static cairo_int_status_t -_cairo_foreign_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_surface_t *surface =(cairo_surface_t *) abstract_surface; - cairo_surface_t *image; - cairo_rectangle_int_t extents; - cairo_rectangle_t rect; - cairo_composite_rectangles_t composite; - cairo_int_status_t status; - - _cairo_surface_get_extents (surface, &extents); - status = _cairo_composite_rectangles_init_for_mask (&composite, &extents, - op, source, mask, - clip); - if (unlikely (status)) - return status; - - image = cairo_surface_map_to_image (surface, - to_rectangle(&rect, &composite.unbounded)); - status = (cairo_int_status_t) - _cairo_surface_mask (image, op, source, mask, clip); - cairo_surface_unmap_image (surface, image); - - _cairo_composite_rectangles_fini (&composite); - - return status; -} - -static cairo_int_status_t -_cairo_foreign_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_surface_t *surface =(cairo_surface_t *) abstract_surface; - cairo_surface_t *image; - cairo_composite_rectangles_t composite; - cairo_rectangle_int_t extents; - cairo_rectangle_t rect; - cairo_int_status_t status; - - _cairo_surface_get_extents (surface, &extents); - status = _cairo_composite_rectangles_init_for_stroke (&composite, &extents, - op, source, - path, style, ctm, - clip); - if (unlikely (status)) - return status; - - image = cairo_surface_map_to_image (surface, - to_rectangle(&rect, &composite.unbounded)); - status = (cairo_int_status_t) - _cairo_surface_stroke (image, op, source, path, style, ctm, ctm_inverse, tolerance, antialias, clip); - cairo_surface_unmap_image (surface, image); - - _cairo_composite_rectangles_fini (&composite); - - return status; -} - -static cairo_int_status_t -_cairo_foreign_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_surface_t *surface =(cairo_surface_t *) abstract_surface; - cairo_surface_t *image; - cairo_composite_rectangles_t composite; - cairo_rectangle_int_t extents; - cairo_rectangle_t rect; - cairo_int_status_t status; - - _cairo_surface_get_extents (surface, &extents); - status = _cairo_composite_rectangles_init_for_fill (&composite, &extents, - op, source, path, - clip); - if (unlikely (status)) - return status; - - image = cairo_surface_map_to_image (surface, - to_rectangle(&rect, &composite.unbounded)); - status = (cairo_int_status_t) - _cairo_surface_fill (image, op, source, path, fill_rule, tolerance, antialias, clip); - cairo_surface_unmap_image (surface, image); - - _cairo_composite_rectangles_fini (&composite); - - return status; -} - -static cairo_int_status_t -_cairo_foreign_surface_glyphs (void *abstract_surface, - cairo_operator_t op, - const cairo_pattern_t *source, - cairo_glyph_t *glyphs, - int num_glyphs, - cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip, - int *num_remaining) -{ - cairo_surface_t *surface =(cairo_surface_t *) abstract_surface; - cairo_surface_t *image; - cairo_composite_rectangles_t composite; - cairo_rectangle_int_t extents; - cairo_rectangle_t rect; - cairo_int_status_t status; - cairo_bool_t overlap; - - _cairo_surface_get_extents (surface, &extents); - status = _cairo_composite_rectangles_init_for_glyphs (&composite, &extents, - op, source, - scaled_font, - glyphs, num_glyphs, - clip, - &overlap); - if (unlikely (status)) - return status; - - image = cairo_surface_map_to_image (surface, - to_rectangle(&rect, &composite.unbounded)); - status = (cairo_int_status_t) - _cairo_surface_show_text_glyphs (image, - op, source, - NULL, 0, - glyphs, num_glyphs, - NULL, 0, (cairo_text_cluster_flags_t)0, - scaled_font, - clip); - cairo_surface_unmap_image (surface, image); - _cairo_composite_rectangles_fini (&composite); - - *num_remaining = 0; - return status; -} - static const struct _cairo_surface_backend cairo_skia_surface_backend = { CAIRO_SURFACE_TYPE_SKIA, @@ -366,33 +176,26 @@ cairo_skia_surface_backend = { _cairo_skia_surface_unmap_image, _cairo_skia_surface_acquire_source_image, + NULL, /* acquire transformed */ _cairo_skia_surface_release_source_image, - - NULL, NULL, - NULL, /* clone similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + NULL, /* snapshot */ NULL, /* copy_page */ NULL, /* show_page */ _cairo_skia_surface_get_extents, - NULL, /* old_show_glyphs */ _cairo_skia_surface_get_font_options, + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ /* XXX native surface functions? */ - _cairo_foreign_surface_paint, - _cairo_foreign_surface_mask, - _cairo_foreign_surface_stroke, - _cairo_foreign_surface_fill, - _cairo_foreign_surface_glyphs + _cairo_surface_fallback_paint, + _cairo_surface_fallback_mask, + _cairo_surface_fallback_stroke, + _cairo_surface_fallback_fill, + NULL, /* fill/stroke */ + _cairo_surface_fallback_glyphs }; /* @@ -426,6 +229,7 @@ sk_config_to_pixman_format_code (SkBitmap::Config config, return (pixman_format_code_t) -1; } } + static cairo_skia_surface_t * _cairo_skia_surface_create_internal (SkBitmap::Config config, bool opaque, diff --git a/src/test-base-compositor-surface.c b/src/test-base-compositor-surface.c new file mode 100644 index 00000000..9d957a45 --- /dev/null +++ b/src/test-base-compositor-surface.c @@ -0,0 +1,942 @@ +/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ +/* cairo - a vector graphics library with display and print output + * + * Copyright © 2002 University of Southern California + * Copyright © 2005 Red Hat, Inc. + * 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is University of Southern + * California. + * + * Contributor(s): + * Carl D. Worth <cworth@cworth.org> + * Joonas Pihlaja <jpihlaja@cc.helsinki.fi> + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#include "cairoint.h" + +#include "test-compositor-surface-private.h" + +#include "cairo-clip-private.h" +#include "cairo-composite-rectangles-private.h" +#include "cairo-compositor-private.h" +#include "cairo-error-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-region-private.h" +#include "cairo-traps-private.h" + +/* The intention is that this is a surface that just works, and most + * important of all does not try to be clever! + */ + +typedef cairo_int_status_t +(*draw_func_t) (cairo_image_surface_t *dst, + void *closure, + cairo_operator_t op, + const cairo_pattern_t *pattern, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents); + +static pixman_op_t +_pixman_operator (cairo_operator_t op) +{ + switch ((int) op) { + case CAIRO_OPERATOR_CLEAR: + return PIXMAN_OP_CLEAR; + + case CAIRO_OPERATOR_SOURCE: + return PIXMAN_OP_SRC; + case CAIRO_OPERATOR_OVER: + return PIXMAN_OP_OVER; + case CAIRO_OPERATOR_IN: + return PIXMAN_OP_IN; + case CAIRO_OPERATOR_OUT: + return PIXMAN_OP_OUT; + case CAIRO_OPERATOR_ATOP: + return PIXMAN_OP_ATOP; + + case CAIRO_OPERATOR_DEST: + return PIXMAN_OP_DST; + case CAIRO_OPERATOR_DEST_OVER: + return PIXMAN_OP_OVER_REVERSE; + case CAIRO_OPERATOR_DEST_IN: + return PIXMAN_OP_IN_REVERSE; + case CAIRO_OPERATOR_DEST_OUT: + return PIXMAN_OP_OUT_REVERSE; + case CAIRO_OPERATOR_DEST_ATOP: + return PIXMAN_OP_ATOP_REVERSE; + + case CAIRO_OPERATOR_XOR: + return PIXMAN_OP_XOR; + case CAIRO_OPERATOR_ADD: + return PIXMAN_OP_ADD; + case CAIRO_OPERATOR_SATURATE: + return PIXMAN_OP_SATURATE; + + case CAIRO_OPERATOR_MULTIPLY: + return PIXMAN_OP_MULTIPLY; + case CAIRO_OPERATOR_SCREEN: + return PIXMAN_OP_SCREEN; + case CAIRO_OPERATOR_OVERLAY: + return PIXMAN_OP_OVERLAY; + case CAIRO_OPERATOR_DARKEN: + return PIXMAN_OP_DARKEN; + case CAIRO_OPERATOR_LIGHTEN: + return PIXMAN_OP_LIGHTEN; + case CAIRO_OPERATOR_COLOR_DODGE: + return PIXMAN_OP_COLOR_DODGE; + case CAIRO_OPERATOR_COLOR_BURN: + return PIXMAN_OP_COLOR_BURN; + case CAIRO_OPERATOR_HARD_LIGHT: + return PIXMAN_OP_HARD_LIGHT; + case CAIRO_OPERATOR_SOFT_LIGHT: + return PIXMAN_OP_SOFT_LIGHT; + case CAIRO_OPERATOR_DIFFERENCE: + return PIXMAN_OP_DIFFERENCE; + case CAIRO_OPERATOR_EXCLUSION: + return PIXMAN_OP_EXCLUSION; + case CAIRO_OPERATOR_HSL_HUE: + return PIXMAN_OP_HSL_HUE; + case CAIRO_OPERATOR_HSL_SATURATION: + return PIXMAN_OP_HSL_SATURATION; + case CAIRO_OPERATOR_HSL_COLOR: + return PIXMAN_OP_HSL_COLOR; + case CAIRO_OPERATOR_HSL_LUMINOSITY: + return PIXMAN_OP_HSL_LUMINOSITY; + + default: + ASSERT_NOT_REACHED; + return PIXMAN_OP_OVER; + } +} + +static void +_pixman_image_add_boxes (pixman_image_t *image, + int dst_x, int dst_y, + cairo_box_t *box, + int count) +{ + while (count--) { + pixman_trapezoid_t trap; + + trap.top = _cairo_fixed_to_16_16 (box->p1.y); + trap.bottom = _cairo_fixed_to_16_16 (box->p2.y); + + trap.left.p1.x = _cairo_fixed_to_16_16 (box->p1.x); + trap.left.p1.y = _cairo_fixed_to_16_16 (box->p1.y); + trap.left.p2.x = _cairo_fixed_to_16_16 (box->p1.x); + trap.left.p2.y = _cairo_fixed_to_16_16 (box->p2.y); + + trap.right.p1.x = _cairo_fixed_to_16_16 (box->p2.x); + trap.right.p1.y = _cairo_fixed_to_16_16 (box->p1.y); + trap.right.p2.x = _cairo_fixed_to_16_16 (box->p2.x); + trap.right.p2.y = _cairo_fixed_to_16_16 (box->p2.y); + + pixman_rasterize_trapezoid (image, &trap, -dst_x, -dst_y); + box++; + } +} + +static cairo_status_t +combine_in_boxes (cairo_image_surface_t *dst, + cairo_box_t *box, int count, + const cairo_rectangle_int_t *extents) +{ + pixman_image_t *mask; + + mask = pixman_image_create_bits (PIXMAN_a8, + extents->width, extents->height, + NULL, 0); + if (unlikely (mask == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + _pixman_image_add_boxes (mask, extents->x, extents->y, box, count); + pixman_image_composite32 (PIXMAN_OP_IN, + mask, NULL, dst->pixman_image, + 0, 0, + 0, 0, + 0, 0, + extents->width, extents->height); + pixman_image_unref (mask); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_image_surface_t * +create_composite_mask (cairo_image_surface_t *dst, + void *draw_closure, + draw_func_t draw_func, + const cairo_composite_rectangles_t *extents) +{ + cairo_image_surface_t *surface; + cairo_int_status_t status; + + surface = (cairo_image_surface_t *) + _cairo_surface_create_similar_solid (&dst->base, + CAIRO_CONTENT_ALPHA, + extents->bounded.width, + extents->bounded.height, + CAIRO_COLOR_TRANSPARENT); + if (unlikely (surface->base.status)) + return surface; + + status = draw_func (surface, draw_closure, + CAIRO_OPERATOR_ADD, &_cairo_pattern_white.base, + extents->bounded.x, extents->bounded.y, + &extents->bounded); + if (unlikely (status)) + goto error; + + if (extents->clip->boxes) { + status = combine_in_boxes (surface, + extents->clip->boxes, + extents->clip->num_boxes, + &extents->bounded); + if (unlikely (status)) + goto error; + } + + if (extents->clip->path) { + status = _cairo_clip_combine_with_surface (extents->clip, + &surface->base, + extents->bounded.x, + extents->bounded.y); + if (unlikely (status)) + goto error; + } + + return surface; + +error: + cairo_surface_destroy (&surface->base); + return (cairo_image_surface_t *)_cairo_surface_create_in_error (status); +} + +/* Handles compositing with a clip surface when the operator allows + * us to combine the clip with the mask + */ +static cairo_status_t +clip_and_composite_with_mask (const cairo_composite_rectangles_t*extents, + draw_func_t draw_func, + void *draw_closure) +{ + cairo_image_surface_t *dst = (cairo_image_surface_t *)extents->surface; + cairo_image_surface_t *mask; + pixman_image_t *src; + cairo_status_t status = CAIRO_STATUS_SUCCESS; + int src_x, src_y; + + mask = create_composite_mask (dst, draw_closure, draw_func, extents); + if (unlikely (mask->base.status)) + return mask->base.status; + + src = _pixman_image_for_pattern (dst, + &extents->source_pattern.base, FALSE, + &extents->bounded, + &extents->source_sample_area, + &src_x, &src_y); + if (unlikely (src == NULL)) { + status = _cairo_error (CAIRO_STATUS_NO_MEMORY); + goto error; + } + + pixman_image_composite32 (_pixman_operator (extents->op), + src, mask->pixman_image, dst->pixman_image, + extents->bounded.x + src_x, + extents->bounded.y + src_y, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + + pixman_image_unref (src); +error: + cairo_surface_destroy (&mask->base); + return status; +} + +/* Handles compositing with a clip surface when we have to do the operation + * in two pieces and combine them together. + */ +static cairo_status_t +clip_and_composite_combine (const cairo_composite_rectangles_t*extents, + draw_func_t draw_func, + void *draw_closure) +{ + cairo_image_surface_t *dst = (cairo_image_surface_t *)extents->surface; + cairo_image_surface_t *tmp, *clip; + int clip_x, clip_y; + cairo_status_t status; + + tmp = (cairo_image_surface_t *) + _cairo_surface_create_similar_solid (&dst->base, dst->base.content, + extents->bounded.width, + extents->bounded.height, + CAIRO_COLOR_TRANSPARENT); + if (unlikely (tmp->base.status)) + return tmp->base.status; + + pixman_image_composite32 (PIXMAN_OP_SRC, + dst->pixman_image, NULL, tmp->pixman_image, + extents->bounded.x, extents->bounded.y, + 0, 0, + 0, 0, + extents->bounded.width, extents->bounded.height); + + status = draw_func (tmp, draw_closure, + extents->op, &extents->source_pattern.base, + extents->bounded.x, extents->bounded.y, + &extents->bounded); + if (unlikely (status)) + goto error; + + clip = (cairo_image_surface_t *) + _cairo_clip_get_surface (extents->clip, &dst->base, &clip_x, &clip_y); + if (unlikely (clip->base.status)) + goto error; + + pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, + clip->pixman_image, NULL, dst->pixman_image, + extents->bounded.x - clip_x, extents->bounded.y - clip_y, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + pixman_image_composite32 (PIXMAN_OP_ADD, + tmp->pixman_image, clip->pixman_image, dst->pixman_image, + 0, 0, + extents->bounded.x - clip_x, extents->bounded.y - clip_y, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + + cairo_surface_destroy (&clip->base); + + error: + cairo_surface_destroy (&tmp->base); + + return status; +} + +/* Handles compositing for %CAIRO_OPERATOR_SOURCE, which is special; it's + * defined as (src IN mask IN clip) ADD (dst OUT (mask IN clip)) + */ +static cairo_status_t +clip_and_composite_source (const cairo_composite_rectangles_t *extents, + draw_func_t draw_func, + void *draw_closure) +{ + cairo_image_surface_t *dst = (cairo_image_surface_t *)extents->surface; + cairo_image_surface_t *mask; + pixman_image_t *src; + int src_x, src_y; + cairo_status_t status = CAIRO_STATUS_SUCCESS; + + mask = create_composite_mask (dst, draw_closure, draw_func, extents); + if (unlikely (mask->base.status)) + return mask->base.status; + + pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, + mask->pixman_image, NULL, dst->pixman_image, + 0, 0, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + + src = _pixman_image_for_pattern (dst, + &extents->source_pattern.base, FALSE, + &extents->bounded, + &extents->source_sample_area, + &src_x, &src_y); + if (unlikely (src == NULL)) { + status = _cairo_error (CAIRO_STATUS_NO_MEMORY); + goto error; + } + + pixman_image_composite32 (PIXMAN_OP_ADD, + src, mask->pixman_image, dst->pixman_image, + extents->bounded.x + src_x, extents->bounded.y + src_y, + 0, 0, + extents->bounded.x, extents->bounded.y, + extents->bounded.width, extents->bounded.height); + + pixman_image_unref (src); + +error: + cairo_surface_destroy (&mask->base); + return status; +} + +static cairo_status_t +fixup_unbounded (const cairo_composite_rectangles_t *extents) +{ + cairo_image_surface_t *dst = (cairo_image_surface_t *)extents->surface; + pixman_image_t *mask; + int mask_x, mask_y; + + if (! _cairo_clip_is_region (extents->clip)) { + cairo_surface_t *clip; + + clip = _cairo_clip_get_surface (extents->clip, &dst->base, + &mask_x, &mask_y); + if (unlikely (clip->status)) + return clip->status; + + mask = pixman_image_ref (((cairo_image_surface_t *)clip)->pixman_image); + cairo_surface_destroy (clip); + } else { + mask_x = mask_y = 0; + mask = _pixman_image_for_color (CAIRO_COLOR_WHITE); + if (unlikely (mask == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + /* top */ + if (extents->bounded.y != extents->unbounded.y) { + int x = extents->unbounded.x; + int y = extents->unbounded.y; + int width = extents->unbounded.width; + int height = extents->bounded.y - y; + + pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, + mask, NULL, dst->pixman_image, + x - mask_x, y - mask_y, + 0, 0, + x, y, + width, height); + } + + /* left */ + if (extents->bounded.x != extents->unbounded.x) { + int x = extents->unbounded.x; + int y = extents->bounded.y; + int width = extents->bounded.x - x; + int height = extents->bounded.height; + + pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, + mask, NULL, dst->pixman_image, + x - mask_x, y - mask_y, + 0, 0, + x, y, + width, height); + } + + /* right */ + if (extents->bounded.x + extents->bounded.width != extents->unbounded.x + extents->unbounded.width) { + int x = extents->bounded.x + extents->bounded.width; + int y = extents->bounded.y; + int width = extents->unbounded.x + extents->unbounded.width - x; + int height = extents->bounded.height; + + pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, + mask, NULL, dst->pixman_image, + x - mask_x, y - mask_y, + 0, 0, + x, y, + width, height); + } + + /* bottom */ + if (extents->bounded.y + extents->bounded.height != extents->unbounded.y + extents->unbounded.height) { + int x = extents->unbounded.x; + int y = extents->bounded.y + extents->bounded.height; + int width = extents->unbounded.width; + int height = extents->unbounded.y + extents->unbounded.height - y; + + pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, + mask, NULL, dst->pixman_image, + x - mask_x, y - mask_y, + 0, 0, + x, y, + width, height); + } + + pixman_image_unref (mask); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +set_clip_region (cairo_composite_rectangles_t *extents) +{ + cairo_image_surface_t *dst = (cairo_image_surface_t *) extents->surface; + cairo_region_t *region = _cairo_clip_get_region (extents->clip); + pixman_region32_t *rgn = region ? ®ion->rgn : NULL; + if (! pixman_image_set_clip_region32 (dst->pixman_image, rgn)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +clip_and_composite (cairo_composite_rectangles_t *extents, + draw_func_t draw_func, + void *draw_closure) +{ + cairo_status_t status; + + status = set_clip_region (extents); + if (unlikely (status)) + return status; + + if (extents->op == CAIRO_OPERATOR_SOURCE) { + status = clip_and_composite_source (extents, draw_func, draw_closure); + } else { + if (extents->op == CAIRO_OPERATOR_CLEAR) { + extents->source_pattern.solid = _cairo_pattern_white; + extents->op = CAIRO_OPERATOR_DEST_OUT; + } + if (! _cairo_clip_is_region (extents->clip)) { + if (extents->is_bounded) + status = clip_and_composite_with_mask (extents, draw_func, draw_closure); + else + status = clip_and_composite_combine (extents, draw_func, draw_closure); + } else { + status = draw_func ((cairo_image_surface_t *) extents->surface, + draw_closure, + extents->op, + &extents->source_pattern.base, + 0, 0, + &extents->bounded); + } + } + + if (status == CAIRO_STATUS_SUCCESS && ! extents->is_bounded) + status = fixup_unbounded (extents); + + return status; +} + +/* high-level compositor interface */ + +static cairo_int_status_t +composite_paint (cairo_image_surface_t *dst, + void *closure, + cairo_operator_t op, + const cairo_pattern_t *pattern, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents) +{ + cairo_rectangle_int_t sample; + pixman_image_t *src; + int src_x, src_y; + + _cairo_pattern_sampled_area (pattern, extents, &sample); + src = _pixman_image_for_pattern (dst, + pattern, FALSE, + extents, &sample, + &src_x, &src_y); + if (unlikely (src == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + pixman_image_composite32 (_pixman_operator (op), + src, NULL, dst->pixman_image, + extents->x + src_x, extents->y + src_y, + 0, 0, + extents->x - dst_x, extents->y - dst_y, + extents->width, extents->height); + + pixman_image_unref (src); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +base_compositor_paint (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents) +{ + return clip_and_composite (extents, composite_paint, NULL); +} + +static cairo_int_status_t +composite_mask (cairo_image_surface_t *dst, + void *closure, + cairo_operator_t op, + const cairo_pattern_t *pattern, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents) +{ + cairo_rectangle_int_t sample; + pixman_image_t *src, *mask; + int src_x, src_y; + int mask_x, mask_y; + + _cairo_pattern_sampled_area (pattern, extents, &sample); + src = _pixman_image_for_pattern (dst, pattern, FALSE, + extents, &sample, + &src_x, &src_y); + if (unlikely (src == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + _cairo_pattern_sampled_area (closure, extents, &sample); + mask = _pixman_image_for_pattern (dst, closure, TRUE, + extents, &sample, + &mask_x, &mask_y); + if (unlikely (mask == NULL)) { + pixman_image_unref (src); + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + pixman_image_composite32 (_pixman_operator (op), + src, mask, dst->pixman_image, + extents->x + src_x, extents->y + src_y, + extents->x + mask_x, extents->y + mask_y, + extents->x - dst_x, extents->y - dst_y, + extents->width, extents->height); + + pixman_image_unref (mask); + pixman_image_unref (src); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +base_compositor_mask (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents) +{ + return clip_and_composite (extents, composite_mask, &extents->mask_pattern.base); +} + +typedef struct { + cairo_traps_t traps; + cairo_antialias_t antialias; +} composite_traps_info_t; + +#define CAIRO_FIXED_16_16_MIN _cairo_fixed_from_int (-32768) +#define CAIRO_FIXED_16_16_MAX _cairo_fixed_from_int (32767) + +static cairo_bool_t +line_exceeds_16_16 (const cairo_line_t *line) +{ + return + line->p1.x <= CAIRO_FIXED_16_16_MIN || + line->p1.x >= CAIRO_FIXED_16_16_MAX || + + line->p2.x <= CAIRO_FIXED_16_16_MIN || + line->p2.x >= CAIRO_FIXED_16_16_MAX || + + line->p1.y <= CAIRO_FIXED_16_16_MIN || + line->p1.y >= CAIRO_FIXED_16_16_MAX || + + line->p2.y <= CAIRO_FIXED_16_16_MIN || + line->p2.y >= CAIRO_FIXED_16_16_MAX; +} + +static void +project_line_x_onto_16_16 (const cairo_line_t *line, + cairo_fixed_t top, + cairo_fixed_t bottom, + pixman_line_fixed_t *out) +{ + /* XXX use fixed-point arithmetic? */ + cairo_point_double_t p1, p2; + double m; + + p1.x = _cairo_fixed_to_double (line->p1.x); + p1.y = _cairo_fixed_to_double (line->p1.y); + + p2.x = _cairo_fixed_to_double (line->p2.x); + p2.y = _cairo_fixed_to_double (line->p2.y); + + m = (p2.x - p1.x) / (p2.y - p1.y); + out->p1.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (top - line->p1.y)); + out->p2.x = _cairo_fixed_16_16_from_double (p1.x + m * _cairo_fixed_to_double (bottom - line->p1.y)); +} + +static void +_pixman_image_add_traps (pixman_image_t *image, + int dst_x, int dst_y, + cairo_traps_t *traps) +{ + cairo_trapezoid_t *t = traps->traps; + int num_traps = traps->num_traps; + while (num_traps--) { + pixman_trapezoid_t trap; + + /* top/bottom will be clamped to surface bounds */ + trap.top = _cairo_fixed_to_16_16 (t->top); + trap.bottom = _cairo_fixed_to_16_16 (t->bottom); + + /* However, all the other coordinates will have been left untouched so + * as not to introduce numerical error. Recompute them if they + * exceed the 16.16 limits. + */ + if (unlikely (line_exceeds_16_16 (&t->left))) { + project_line_x_onto_16_16 (&t->left, t->top, t->bottom, &trap.left); + trap.left.p1.y = trap.top; + trap.left.p2.y = trap.bottom; + } else { + trap.left.p1.x = _cairo_fixed_to_16_16 (t->left.p1.x); + trap.left.p1.y = _cairo_fixed_to_16_16 (t->left.p1.y); + trap.left.p2.x = _cairo_fixed_to_16_16 (t->left.p2.x); + trap.left.p2.y = _cairo_fixed_to_16_16 (t->left.p2.y); + } + + if (unlikely (line_exceeds_16_16 (&t->right))) { + project_line_x_onto_16_16 (&t->right, t->top, t->bottom, &trap.right); + trap.right.p1.y = trap.top; + trap.right.p2.y = trap.bottom; + } else { + trap.right.p1.x = _cairo_fixed_to_16_16 (t->right.p1.x); + trap.right.p1.y = _cairo_fixed_to_16_16 (t->right.p1.y); + trap.right.p2.x = _cairo_fixed_to_16_16 (t->right.p2.x); + trap.right.p2.y = _cairo_fixed_to_16_16 (t->right.p2.y); + } + + pixman_rasterize_trapezoid (image, &trap, -dst_x, -dst_y); + t++; + } +} + +static cairo_int_status_t +composite_traps (cairo_image_surface_t *dst, + void *closure, + cairo_operator_t op, + const cairo_pattern_t *pattern, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents) +{ + composite_traps_info_t *info = closure; + cairo_rectangle_int_t sample; + pixman_image_t *src, *mask; + int src_x, src_y; + + _cairo_pattern_sampled_area (pattern, extents, &sample); + src = _pixman_image_for_pattern (dst, pattern, FALSE, + extents, &sample, + &src_x, &src_y); + if (unlikely (src == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + mask = pixman_image_create_bits (info->antialias == CAIRO_ANTIALIAS_NONE ? PIXMAN_a1 : PIXMAN_a8, + extents->width, extents->height, + NULL, 0); + if (unlikely (mask == NULL)) { + pixman_image_unref (src); + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + + _pixman_image_add_traps (mask, extents->x, extents->y, &info->traps); + pixman_image_composite32 (_pixman_operator (op), + src, mask, dst->pixman_image, + extents->x + src_x - dst_x, extents->y + src_y - dst_y, + 0, 0, + extents->x - dst_x, extents->y - dst_y, + extents->width, extents->height); + + pixman_image_unref (mask); + pixman_image_unref (src); + + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +trim_extents_to_traps (cairo_composite_rectangles_t *extents, + cairo_traps_t *traps) +{ + cairo_box_t box; + + /* X trims the affected area to the extents of the trapezoids, so + * we need to compensate when fixing up the unbounded area. + */ + _cairo_traps_extents (traps, &box); + return _cairo_composite_rectangles_intersect_mask_extents (extents, &box); +} + +static cairo_int_status_t +base_compositor_stroke (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + 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) +{ + composite_traps_info_t info; + cairo_int_status_t status; + + info.antialias = antialias; + _cairo_traps_init_with_clip (&info.traps, extents->clip); + status = _cairo_path_fixed_stroke_to_traps (path, style, + ctm, ctm_inverse, + tolerance, + &info.traps); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = trim_extents_to_traps (extents, &info.traps); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = clip_and_composite (extents, composite_traps, &info); + _cairo_traps_fini (&info.traps); + + return status; +} + +static cairo_int_status_t +base_compositor_fill (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + const cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + cairo_antialias_t antialias) +{ + composite_traps_info_t info; + cairo_int_status_t status; + + info.antialias = antialias; + _cairo_traps_init_with_clip (&info.traps, extents->clip); + status = _cairo_path_fixed_fill_to_traps (path, + fill_rule, tolerance, + &info.traps); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = trim_extents_to_traps (extents, &info.traps); + if (likely (status == CAIRO_INT_STATUS_SUCCESS)) + status = clip_and_composite (extents, composite_traps, &info); + _cairo_traps_fini (&info.traps); + + return status; +} + +static cairo_int_status_t +composite_glyphs (cairo_image_surface_t *dst, + void *closure, + cairo_operator_t op, + const cairo_pattern_t *pattern, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents) +{ + cairo_composite_glyphs_info_t *info = closure; + pixman_image_t *mask; + cairo_status_t status; + int i; + + mask = pixman_image_create_bits (PIXMAN_a8, + extents->width, extents->height, + NULL, 0); + if (unlikely (mask == NULL)) + return _cairo_error (CAIRO_STATUS_NO_MEMORY); + + status = CAIRO_STATUS_SUCCESS; + _cairo_scaled_font_freeze_cache (info->font); + for (i = 0; i < info->num_glyphs; i++) { + cairo_image_surface_t *glyph_surface; + cairo_scaled_glyph_t *scaled_glyph; + unsigned long glyph_index = info->glyphs[i].index; + int x, y; + + status = _cairo_scaled_glyph_lookup (info->font, glyph_index, + CAIRO_SCALED_GLYPH_INFO_SURFACE, + &scaled_glyph); + + if (unlikely (status)) + break; + + glyph_surface = scaled_glyph->surface; + if (glyph_surface->width && glyph_surface->height) { + /* round glyph locations to the nearest pixel */ + /* XXX: FRAGILE: We're ignoring device_transform scaling here. A bug? */ + x = _cairo_lround (info->glyphs[i].x - + glyph_surface->base.device_transform.x0); + y = _cairo_lround (info->glyphs[i].y - + glyph_surface->base.device_transform.y0); + + pixman_image_composite32 (PIXMAN_OP_ADD, + glyph_surface->pixman_image, NULL, mask, + 0, 0, + 0, 0, + x - extents->x, y - extents->y, + glyph_surface->width, + glyph_surface->height); + } + } + _cairo_scaled_font_thaw_cache (info->font); + + if (status == CAIRO_STATUS_SUCCESS) { + cairo_rectangle_int_t sample; + pixman_image_t *src; + int src_x, src_y; + + _cairo_pattern_sampled_area (pattern, extents, &sample); + src = _pixman_image_for_pattern (dst, pattern, FALSE, + extents, &sample, + &src_x, &src_y); + if (src != NULL) { + dst_x = extents->x - dst_x; + dst_y = extents->y - dst_y; + pixman_image_composite32 (_pixman_operator (op), + src, mask, dst->pixman_image, + src_x + dst_x, src_y + dst_y, + 0, 0, + dst_x, dst_y, + extents->width, extents->height); + pixman_image_unref (src); + } else + status = _cairo_error (CAIRO_STATUS_NO_MEMORY); + } + pixman_image_unref (mask); + + return status; +} + +static cairo_int_status_t +base_compositor_glyphs (const cairo_compositor_t *_compositor, + cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *scaled_font, + cairo_glyph_t *glyphs, + int num_glyphs, + cairo_bool_t overlap) +{ + cairo_composite_glyphs_info_t info; + + info.font = scaled_font; + info.glyphs = glyphs; + info.num_glyphs = num_glyphs; + + return clip_and_composite (extents, composite_glyphs, &info); +} + +static const cairo_compositor_t base_compositor = { + &__cairo_no_compositor, + + base_compositor_paint, + base_compositor_mask, + base_compositor_stroke, + base_compositor_fill, + base_compositor_glyphs, +}; + +cairo_surface_t * +_cairo_test_base_compositor_surface_create (cairo_content_t content, + int width, + int height) +{ + return test_compositor_surface_create (&base_compositor, + content, width, height); +} diff --git a/src/test-wrapping-surface.h b/src/test-compositor-surface-private.h index 4c1e28d7..47e2a432 100644 --- a/src/test-wrapping-surface.h +++ b/src/test-compositor-surface-private.h @@ -1,7 +1,6 @@ /* cairo - a vector graphics library with display and print output * - * Copyright © 2005 Red Hat, Inc - * Copyright © 2009 Chris Wilson + * 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 @@ -28,24 +27,27 @@ * * The Original Code is the cairo graphics library. * - * The Initial Developer of the Original Code is Red Hat, Inc. + * The Initial Developer of the Original Code is Intel Corporation * * Contributor(s): - * Carl Worth <cworth@cworth.org> * Chris Wilson <chris@chris-wilson.co.uk> */ -#ifndef TEST_WRAPPING_SURFACE_H -#define TEST_WRAPPING_SURFACE_H +#ifndef TEST_COMPOSITOR_SURFACE_PRIVATE_H +#define TEST_COMPOSITOR_SURFACE_PRIVATE_H #include "cairo.h" +#include "test-compositor-surface.h" + CAIRO_BEGIN_DECLS -cairo_surface_t * -_cairo_test_wrapping_surface_create (cairo_surface_t *target); +cairo_private cairo_surface_t * +test_compositor_surface_create (const cairo_compositor_t *compositor, + cairo_content_t content, + int width, + int height); CAIRO_END_DECLS -#endif /* TEST_WRAPPING_SURFACE_H */ - +#endif /* TEST_COMPOSITOR_SURFACE_PRIVATE H */ diff --git a/src/test-compositor-surface.c b/src/test-compositor-surface.c new file mode 100644 index 00000000..356c16c6 --- /dev/null +++ b/src/test-compositor-surface.c @@ -0,0 +1,259 @@ +/* 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is Intel Corporation + * + * Contributor(s): + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#include "cairoint.h" + +#include "test-compositor-surface-private.h" + +#include "cairo-compositor-private.h" +#include "cairo-default-context-private.h" +#include "cairo-error-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-surface-backend-private.h" + +typedef struct _test_compositor_surface { + cairo_image_surface_t base; +} test_compositor_surface_t; + +static const cairo_surface_backend_t test_compositor_surface_backend; + +cairo_surface_t * +test_compositor_surface_create (const cairo_compositor_t *compositor, + cairo_content_t content, + int width, + int height) +{ + test_compositor_surface_t *surface; + pixman_image_t *pixman_image; + pixman_format_code_t pixman_format; + + switch (content) { + case CAIRO_CONTENT_ALPHA: + pixman_format = PIXMAN_a8; + break; + case CAIRO_CONTENT_COLOR: + pixman_format = PIXMAN_x8r8g8b8; + break; + case CAIRO_CONTENT_COLOR_ALPHA: + pixman_format = PIXMAN_a8r8g8b8; + break; + default: + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_CONTENT)); + } + + pixman_image = pixman_image_create_bits (pixman_format, width, height, + NULL, 0); + if (unlikely (pixman_image == NULL)) + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + + surface = malloc (sizeof (test_compositor_surface_t)); + if (unlikely (surface == NULL)) { + pixman_image_unref (pixman_image); + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + } + + _cairo_surface_init (&surface->base.base, + &test_compositor_surface_backend, + NULL, /* device */ + content); + _cairo_image_surface_init (&surface->base, pixman_image, pixman_format); + + surface->base.compositor = compositor; + + return &surface->base.base; +} + +static cairo_surface_t * +test_compositor_surface_create_similar (void *abstract_surface, + cairo_content_t content, + int width, + int height) +{ + test_compositor_surface_t *surface = abstract_surface; + + return test_compositor_surface_create (surface->base.compositor, + content, width, height); +} + +static cairo_int_status_t +test_compositor_surface_paint (void *_surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_clip_t *clip) +{ + test_compositor_surface_t *surface = _surface; + return _cairo_compositor_paint (surface->base.compositor, + _surface, op, source, + clip); +} + +static cairo_int_status_t +test_compositor_surface_mask (void *_surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_pattern_t *mask, + const cairo_clip_t *clip) +{ + test_compositor_surface_t *surface = _surface; + return _cairo_compositor_mask (surface->base.compositor, + _surface, op, source, mask, + clip); +} + +static cairo_int_status_t +test_compositor_surface_stroke (void *_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) +{ + test_compositor_surface_t *surface = _surface; + return _cairo_compositor_stroke (surface->base.compositor, + _surface, op, source, + path, style, ctm, ctm_inverse, + tolerance, antialias, + clip); +} + +static cairo_int_status_t +test_compositor_surface_fill (void *_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) +{ + test_compositor_surface_t *surface = _surface; + return _cairo_compositor_fill (surface->base.compositor, + _surface, op, source, + path, fill_rule, tolerance, antialias, + clip); +} + +static cairo_int_status_t +test_compositor_surface_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) +{ + test_compositor_surface_t *surface = _surface; + return _cairo_compositor_glyphs (surface->base.compositor, + _surface, op, source, + glyphs, num_glyphs, scaled_font, + clip); +} + +static const cairo_surface_backend_t test_compositor_surface_backend = { + CAIRO_SURFACE_TYPE_IMAGE, + _cairo_image_surface_finish, + _cairo_default_context_create, + + test_compositor_surface_create_similar, + NULL, /* create similar image */ + _cairo_image_surface_map_to_image, + _cairo_image_surface_unmap_image, + + _cairo_image_surface_acquire_source_image, + _cairo_image_surface_release_source_image, + _cairo_image_surface_snapshot, + + NULL, /* copy_page */ + NULL, /* show_page */ + + _cairo_image_surface_get_extents, + _cairo_image_surface_get_font_options, + + NULL, /* flush */ + NULL, /* mark_dirty_rectangle */ + + test_compositor_surface_paint, + test_compositor_surface_mask, + test_compositor_surface_stroke, + test_compositor_surface_fill, + NULL, /* fill/stroke */ + test_compositor_surface_glyphs, +}; + +static const cairo_compositor_t * +get_fallback_compositor (void) +{ + return &_cairo_fallback_compositor; +} + +cairo_surface_t * +_cairo_test_fallback_compositor_surface_create (cairo_content_t content, + int width, + int height) +{ + return test_compositor_surface_create (get_fallback_compositor(), + content, width, height); +} + +cairo_surface_t * +_cairo_test_mask_compositor_surface_create (cairo_content_t content, + int width, + int height) +{ + return test_compositor_surface_create (_cairo_image_mask_compositor_get(), + content, width, height); +} + +cairo_surface_t * +_cairo_test_traps_compositor_surface_create (cairo_content_t content, + int width, + int height) +{ + return test_compositor_surface_create (_cairo_image_traps_compositor_get(), + content, width, height); +} + +cairo_surface_t * +_cairo_test_spans_compositor_surface_create (cairo_content_t content, + int width, + int height) +{ + return test_compositor_surface_create (_cairo_image_spans_compositor_get(), + content, width, height); +} diff --git a/src/test-fallback-surface.h b/src/test-compositor-surface.h index e7071511..8d8af2d5 100644 --- a/src/test-fallback-surface.h +++ b/src/test-compositor-surface.h @@ -1,6 +1,6 @@ /* cairo - a vector graphics library with display and print output * - * Copyright © 2005 Red Hat, Inc + * 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 @@ -27,24 +27,45 @@ * * The Original Code is the cairo graphics library. * - * The Initial Developer of the Original Code is Red Hat, Inc. + * The Initial Developer of the Original Code is Intel Corporation * * Contributor(s): - * Carl Worth <cworth@cworth.org> + * Chris Wilson <chris@chris-wilson.co.uk> */ -#ifndef TEST_FALLBACK_SURFACE_H -#define TEST_FALLBACK_SURFACE_H +#ifndef TEST_COMPOSITOR_SURFACE_H +#define TEST_COMPOSITOR_SURFACE_H #include "cairo.h" CAIRO_BEGIN_DECLS cairo_surface_t * -_cairo_test_fallback_surface_create (cairo_content_t content, - int width, - int height); +_cairo_test_fallback_compositor_surface_create (cairo_content_t content, + int width, + int height); + + +cairo_surface_t * +_cairo_test_mask_compositor_surface_create (cairo_content_t content, + int width, + int height); + +cairo_surface_t * +_cairo_test_traps_compositor_surface_create (cairo_content_t content, + int width, + int height); + +cairo_surface_t * +_cairo_test_spans_compositor_surface_create (cairo_content_t content, + int width, + int height); + +cairo_surface_t * +_cairo_test_base_compositor_surface_create (cairo_content_t content, + int width, + int height); CAIRO_END_DECLS -#endif /* TEST_FALLBACK_SURFACE_H */ +#endif /* TEST_COMPOSITOR_SURFACE_H */ diff --git a/src/test-fallback-surface.c b/src/test-fallback-surface.c deleted file mode 100644 index 1dce221d..00000000 --- a/src/test-fallback-surface.c +++ /dev/null @@ -1,244 +0,0 @@ -/* cairo - a vector graphics library with display and print output - * - * Copyright © 2005 Red Hat, Inc - * - * This library is free software; you can redistribute it and/or - * modify it either under the terms of the GNU Lesser General Public - * License version 2.1 as published by the Free Software Foundation - * (the "LGPL") or, at your option, under the terms of the Mozilla - * Public License Version 1.1 (the "MPL"). If you do not alter this - * notice, a recipient may use your version of this file under either - * the MPL or the LGPL. - * - * You should have received a copy of the LGPL along with this library - * in the file COPYING-LGPL-2.1; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA - * You should have received a copy of the MPL along with this library - * in the file COPYING-MPL-1.1 - * - * The contents of this file are subject to the Mozilla Public License - * Version 1.1 (the "License"); you may not use this file except in - * compliance with the License. You may obtain a copy of the License at - * http://www.mozilla.org/MPL/ - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY - * OF ANY KIND, either express or implied. See the LGPL or the MPL for - * the specific language governing rights and limitations. - * - * The Original Code is the cairo graphics library. - * - * The Initial Developer of the Original Code is Red Hat, Inc. - * - * Contributor(s): - * Carl Worth <cworth@cworth.org> - */ - -/* This isn't a "real" surface, but just something to be used by the - * test suite to test a mythical backend that uses nothing but - * fallbacks. - * - * The defining feature of this backend is that it has as many %NULL - * backend function entries as possible. The ones that aren't %NULL are - * simply those that must be implemented to have working fallbacks. - * (Except for create_similar---fallbacks would work fine without - * that---I implemented it here in order to create as many surfaces as - * possible of type test_fallback_surface_t during the test suite - * run). - * - * It's possible that this code might serve as a good starting point - * for someone working on bringing up a new backend, starting with the - * minimal all-fallbacks approach and working up gradually from - * there. - */ - -#include "cairoint.h" - -#include "test-fallback-surface.h" -#include "cairo-default-context-private.h" -#include "cairo-error-private.h" - -typedef struct _test_fallback_surface { - cairo_surface_t base; - - /* This is a cairo_image_surface to hold the actual contents. */ - cairo_surface_t *backing; -} test_fallback_surface_t; - -static const cairo_surface_backend_t test_fallback_surface_backend; - -slim_hidden_proto (_cairo_test_fallback_surface_create); - -cairo_surface_t * -_cairo_test_fallback_surface_create (cairo_content_t content, - int width, - int height) -{ - test_fallback_surface_t *surface; - cairo_surface_t *backing; - - backing = _cairo_image_surface_create_with_content (content, width, height); - if (cairo_surface_status (backing)) - return backing; - - surface = malloc (sizeof (test_fallback_surface_t)); - if (unlikely (surface == NULL)) { - cairo_surface_destroy (backing); - return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); - } - - _cairo_surface_init (&surface->base, - &test_fallback_surface_backend, - NULL, /* device */ - content); - - surface->backing = backing; - - return &surface->base; -} -slim_hidden_def (_cairo_test_fallback_surface_create); - -static cairo_surface_t * -_test_fallback_surface_create_similar (void *abstract_surface, - cairo_content_t content, - int width, - int height) -{ - assert (CAIRO_CONTENT_VALID (content)); - - return _cairo_test_fallback_surface_create (content, - width, height); -} - -static cairo_status_t -_test_fallback_surface_finish (void *abstract_surface) -{ - test_fallback_surface_t *surface = abstract_surface; - - cairo_surface_destroy (surface->backing); - - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_test_fallback_surface_acquire_source_image (void *abstract_surface, - cairo_image_surface_t **image_out, - void **image_extra) -{ - test_fallback_surface_t *surface = abstract_surface; - - return _cairo_surface_acquire_source_image (surface->backing, - image_out, image_extra); -} - -static void -_test_fallback_surface_release_source_image (void *abstract_surface, - cairo_image_surface_t *image, - void *image_extra) -{ - test_fallback_surface_t *surface = abstract_surface; - - _cairo_surface_release_source_image (surface->backing, - image, image_extra); -} - -static cairo_status_t -_test_fallback_surface_acquire_dest_image (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t **image_out, - cairo_rectangle_int_t *image_rect_out, - void **image_extra) -{ - test_fallback_surface_t *surface = abstract_surface; - - return _cairo_surface_acquire_dest_image (surface->backing, - interest_rect, - image_out, - image_rect_out, - image_extra); -} - -static void -_test_fallback_surface_release_dest_image (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t *image, - cairo_rectangle_int_t *image_rect, - void *image_extra) -{ - test_fallback_surface_t *surface = abstract_surface; - - _cairo_surface_release_dest_image (surface->backing, - interest_rect, - image, - image_rect, - image_extra); -} - -static cairo_status_t -_test_fallback_surface_clone_similar (void *abstract_surface, - cairo_surface_t *src, - int src_x, - int src_y, - int width, - int height, - int *clone_offset_x, - int *clone_offset_y, - cairo_surface_t **clone_out) -{ - test_fallback_surface_t *surface = abstract_surface; - - if (src->backend == surface->base.backend) { - *clone_offset_x = 0; - *clone_offset_y = 0; - *clone_out = cairo_surface_reference (src); - - return CAIRO_STATUS_SUCCESS; - } - - return CAIRO_INT_STATUS_UNSUPPORTED; -} - -static cairo_bool_t -_test_fallback_surface_get_extents (void *abstract_surface, - cairo_rectangle_int_t *rectangle) -{ - test_fallback_surface_t *surface = abstract_surface; - - return _cairo_surface_get_extents (surface->backing, rectangle); -} - -static const cairo_surface_backend_t test_fallback_surface_backend = { - CAIRO_INTERNAL_SURFACE_TYPE_TEST_FALLBACK, - _test_fallback_surface_finish, - _cairo_default_context_create, - - _test_fallback_surface_create_similar, - NULL, /* create similar image */ - NULL, /* map_to_image */ - NULL, /* unmap_image */ - - _test_fallback_surface_acquire_source_image, - _test_fallback_surface_release_source_image, - _test_fallback_surface_acquire_dest_image, - _test_fallback_surface_release_dest_image, - _test_fallback_surface_clone_similar, - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ - NULL, /* copy_page */ - NULL, /* show_page */ - _test_fallback_surface_get_extents, - NULL, /* old_show_glyphs */ - NULL, /* get_font_options */ - NULL, /* flush */ - NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ - NULL, /* paint */ - NULL, /* mask */ - NULL, /* stroke */ - NULL, /* fill */ - NULL, /* show_glyphs */ - NULL /* snapshot */ -}; diff --git a/src/test-fallback16-surface.c b/src/test-fallback16-surface.c deleted file mode 100644 index 5ec501a0..00000000 --- a/src/test-fallback16-surface.c +++ /dev/null @@ -1,241 +0,0 @@ -/* cairo - a vector graphics library with display and print output - * - * Copyright © 2005 Red Hat, Inc - * Copyright © 2009 Chris Wilson - * - * This library is free software; you can redistribute it and/or - * modify it either under the terms of the GNU Lesser General Public - * License version 2.1 as published by the Free Software Foundation - * (the "LGPL") or, at your option, under the terms of the Mozilla - * Public License Version 1.1 (the "MPL"). If you do not alter this - * notice, a recipient may use your version of this file under either - * the MPL or the LGPL. - * - * You should have received a copy of the LGPL along with this library - * in the file COPYING-LGPL-2.1; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA - * You should have received a copy of the MPL along with this library - * in the file COPYING-MPL-1.1 - * - * The contents of this file are subject to the Mozilla Public License - * Version 1.1 (the "License"); you may not use this file except in - * compliance with the License. You may obtain a copy of the License at - * http://www.mozilla.org/MPL/ - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY - * OF ANY KIND, either express or implied. See the LGPL or the MPL for - * the specific language governing rights and limitations. - * - * The Original Code is the cairo graphics library. - * - * The Initial Developer of the Original Code is Red Hat, Inc. - * - * Contributor(s): - * Carl Worth <cworth@cworth.org> - * Chris Wilson <chris@chris-wilson.co.uk> - */ - -/* This isn't a "real" surface, but just something to be used by the - * test suite to force use of a non-standard pixman image fallback - as - * may be exposed by xlib fallbacks with weird xservers, for example. - */ - -#include "cairoint.h" - -#include "test-fallback16-surface.h" -#include "cairo-default-context-private.h" -#include "cairo-error-private.h" - -typedef struct _test_fallback16_surface { - cairo_surface_t base; - - /* This is a cairo_image_surface to hold the actual contents. */ - cairo_surface_t *backing; -} test_fallback16_surface_t; - -static const cairo_surface_backend_t test_fallback16_surface_backend; - -slim_hidden_proto (_cairo_test_fallback16_surface_create); - -cairo_surface_t * -_cairo_test_fallback16_surface_create (cairo_content_t content, - int width, - int height) -{ - test_fallback16_surface_t *surface; - cairo_surface_t *backing; - pixman_format_code_t format; - - format = content & CAIRO_CONTENT_ALPHA ? PIXMAN_a1r5g5b5: PIXMAN_r5g6b5; - - backing = _cairo_image_surface_create_with_pixman_format (NULL, format, - width, height, - -1); - if (cairo_surface_status (backing)) - return backing; - - surface = malloc (sizeof (test_fallback16_surface_t)); - if (unlikely (surface == NULL)) { - cairo_surface_destroy (backing); - return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); - } - - _cairo_surface_init (&surface->base, - &test_fallback16_surface_backend, - NULL, /* device */ - content); - - surface->backing = backing; - - return &surface->base; -} -slim_hidden_def (_cairo_test_fallback16_surface_create); - -static cairo_surface_t * -_test_fallback16_surface_create_similar (void *abstract_surface, - cairo_content_t content, - int width, - int height) -{ - assert (CAIRO_CONTENT_VALID (content)); - - return _cairo_test_fallback16_surface_create (content, width, height); -} - -static cairo_status_t -_test_fallback16_surface_finish (void *abstract_surface) -{ - test_fallback16_surface_t *surface = abstract_surface; - - cairo_surface_destroy (surface->backing); - - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_test_fallback16_surface_acquire_source_image (void *abstract_surface, - cairo_image_surface_t **image_out, - void **image_extra) -{ - test_fallback16_surface_t *surface = abstract_surface; - - return _cairo_surface_acquire_source_image (surface->backing, - image_out, image_extra); -} - -static void -_test_fallback16_surface_release_source_image (void *abstract_surface, - cairo_image_surface_t *image, - void *image_extra) -{ - test_fallback16_surface_t *surface = abstract_surface; - - _cairo_surface_release_source_image (surface->backing, - image, image_extra); -} - -static cairo_status_t -_test_fallback16_surface_acquire_dest_image (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t **image_out, - cairo_rectangle_int_t *image_rect_out, - void **image_extra) -{ - test_fallback16_surface_t *surface = abstract_surface; - - return _cairo_surface_acquire_dest_image (surface->backing, - interest_rect, - image_out, - image_rect_out, - image_extra); -} - -static void -_test_fallback16_surface_release_dest_image (void *abstract_surface, - cairo_rectangle_int_t *interest_rect, - cairo_image_surface_t *image, - cairo_rectangle_int_t *image_rect, - void *image_extra) -{ - test_fallback16_surface_t *surface = abstract_surface; - - _cairo_surface_release_dest_image (surface->backing, - interest_rect, - image, - image_rect, - image_extra); -} - -static cairo_status_t -_test_fallback16_surface_clone_similar (void *abstract_surface, - cairo_surface_t *src, - int src_x, - int src_y, - int width, - int height, - int *clone_offset_x, - int *clone_offset_y, - cairo_surface_t **clone_out) -{ - test_fallback16_surface_t *surface = abstract_surface; - - if (src->backend == surface->base.backend) { - *clone_offset_x = 0; - *clone_offset_y = 0; - *clone_out = cairo_surface_reference (src); - - return CAIRO_STATUS_SUCCESS; - } else { - return _cairo_surface_clone_similar (surface->backing, src, - src_x, src_y, - width, height, - clone_offset_x, clone_offset_y, - clone_out); - } -} - -static cairo_bool_t -_test_fallback16_surface_get_extents (void *abstract_surface, - cairo_rectangle_int_t *rectangle) -{ - test_fallback16_surface_t *surface = abstract_surface; - - return _cairo_surface_get_extents (surface->backing, rectangle); -} - -static const cairo_surface_backend_t test_fallback16_surface_backend = { - CAIRO_INTERNAL_SURFACE_TYPE_TEST_FALLBACK, - _test_fallback16_surface_finish, - _cairo_default_context_create, - - _test_fallback16_surface_create_similar, - NULL, /* create similar image */ - NULL, /* map to image */ - NULL, /* unmap image */ - - _test_fallback16_surface_acquire_source_image, - _test_fallback16_surface_release_source_image, - _test_fallback16_surface_acquire_dest_image, - _test_fallback16_surface_release_dest_image, - _test_fallback16_surface_clone_similar, - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ - NULL, /* copy_page */ - NULL, /* show_page */ - _test_fallback16_surface_get_extents, - NULL, /* old_show_glyphs */ - NULL, /* get_font_options */ - NULL, /* flush */ - NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ - NULL, /* paint */ - NULL, /* mask */ - NULL, /* stroke */ - NULL, /* fill */ - NULL, /* show_glyphs */ - NULL /* snapshot */ -}; diff --git a/src/test-null-compositor-surface.c b/src/test-null-compositor-surface.c new file mode 100644 index 00000000..021dfe75 --- /dev/null +++ b/src/test-null-compositor-surface.c @@ -0,0 +1,480 @@ +/* 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.org/MPL/ + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY + * OF ANY KIND, either express or implied. See the LGPL or the MPL for + * the specific language governing rights and limitations. + * + * The Original Code is the cairo graphics library. + * + * The Initial Developer of the Original Code is Intel Corporation + * + * Contributor(s): + * Chris Wilson <chris@chris-wilson.co.uk> + */ + + +#include "cairoint.h" + +#include "test-null-compositor-surface.h" + +#include "cairo-compositor-private.h" +#include "cairo-default-context-private.h" +#include "cairo-error-private.h" +#include "cairo-image-surface-private.h" +#include "cairo-surface-backend-private.h" +#include "cairo-spans-compositor-private.h" +#include "cairo-spans-private.h" + +typedef struct _test_compositor_surface { + cairo_image_surface_t base; +} test_compositor_surface_t; + +static const cairo_surface_backend_t test_compositor_surface_backend; + +static cairo_surface_t * +test_compositor_surface_create (const cairo_compositor_t *compositor, + cairo_content_t content, + int width, + int height) +{ + test_compositor_surface_t *surface; + pixman_image_t *pixman_image; + pixman_format_code_t pixman_format; + + switch (content) { + case CAIRO_CONTENT_ALPHA: + pixman_format = PIXMAN_a8; + break; + case CAIRO_CONTENT_COLOR: + pixman_format = PIXMAN_x8r8g8b8; + break; + case CAIRO_CONTENT_COLOR_ALPHA: + pixman_format = PIXMAN_a8r8g8b8; + break; + default: + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_CONTENT)); + } + + pixman_image = pixman_image_create_bits (pixman_format, width, height, + NULL, 0); + if (unlikely (pixman_image == NULL)) + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + + surface = malloc (sizeof (test_compositor_surface_t)); + if (unlikely (surface == NULL)) { + pixman_image_unref (pixman_image); + return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); + } + + _cairo_surface_init (&surface->base.base, + &test_compositor_surface_backend, + NULL, /* device */ + content); + _cairo_image_surface_init (&surface->base, pixman_image, pixman_format); + + surface->base.compositor = compositor; + + return &surface->base.base; +} + +static cairo_surface_t * +test_compositor_surface_create_similar (void *abstract_surface, + cairo_content_t content, + int width, + int height) +{ + test_compositor_surface_t *surface = abstract_surface; + + return test_compositor_surface_create (surface->base.compositor, + content, width, height); +} + +static cairo_int_status_t +test_compositor_surface_paint (void *_surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_clip_t *clip) +{ + test_compositor_surface_t *surface = _surface; + return _cairo_compositor_paint (surface->base.compositor, + _surface, op, source, + clip); +} + +static cairo_int_status_t +test_compositor_surface_mask (void *_surface, + cairo_operator_t op, + const cairo_pattern_t *source, + const cairo_pattern_t *mask, + const cairo_clip_t *clip) +{ + test_compositor_surface_t *surface = _surface; + return _cairo_compositor_mask (surface->base.compositor, + _surface, op, source, mask, + clip); +} + +static cairo_int_status_t +test_compositor_surface_stroke (void *_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) +{ + test_compositor_surface_t *surface = _surface; + return _cairo_compositor_stroke (surface->base.compositor, + _surface, op, source, + path, style, ctm, ctm_inverse, + tolerance, antialias, + clip); +} + +static cairo_int_status_t +test_compositor_surface_fill (void *_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) +{ + test_compositor_surface_t *surface = _surface; + return _cairo_compositor_fill (surface->base.compositor, + _surface, op, source, + path, fill_rule, tolerance, antialias, + clip); +} + +static cairo_int_status_t +test_compositor_surface_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) +{ + test_compositor_surface_t *surface = _surface; + return _cairo_compositor_glyphs (surface->base.compositor, + _surface, op, source, + glyphs, num_glyphs, scaled_font, + clip); +} + +static const cairo_surface_backend_t test_compositor_surface_backend = { + CAIRO_SURFACE_TYPE_IMAGE, + _cairo_image_surface_finish, + _cairo_default_context_create, + + test_compositor_surface_create_similar, + NULL, /* create similar image */ + _cairo_image_surface_map_to_image, + _cairo_image_surface_unmap_image, + + _cairo_image_surface_acquire_source_image, + _cairo_image_surface_release_source_image, + NULL, /* snapshot */ + + NULL, /* copy_page */ + NULL, /* show_page */ + + _cairo_image_surface_get_extents, + _cairo_image_surface_get_font_options, + + NULL, /* flush */ + NULL, /* mark_dirty_rectangle */ + + test_compositor_surface_paint, + test_compositor_surface_mask, + test_compositor_surface_stroke, + test_compositor_surface_fill, + NULL, /* fill/stroke */ + test_compositor_surface_glyphs, +}; + +static cairo_int_status_t +acquire (void *abstract_dst) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +release (void *abstract_dst) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +set_clip_region (void *_surface, + cairo_region_t *region) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_bool_t +has_snapshot (void *_dst, + const cairo_pattern_t *pattern) +{ + return FALSE; +} + +static cairo_surface_t * +pattern_to_surface (cairo_surface_t *dst, + const cairo_pattern_t *pattern, + cairo_bool_t is_mask, + const cairo_rectangle_int_t *extents, + const cairo_rectangle_int_t *sample, + int *src_x, int *src_y) +{ + return cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 0, 0); +} + +static cairo_int_status_t +fill_boxes (void *_dst, + cairo_operator_t op, + const cairo_color_t *color, + cairo_boxes_t *boxes) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +draw_image_boxes (void *_dst, + cairo_image_surface_t *image, + cairo_boxes_t *boxes, + int dx, int dy) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +lerp (void *_dst, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + unsigned int width, + unsigned int height) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_boxes (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + cairo_surface_t *abstract_mask, + int src_x, + int src_y, + int mask_x, + int mask_y, + int dst_x, + int dst_y, + cairo_boxes_t *boxes, + const cairo_rectangle_int_t *extents) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_traps (void *_dst, + cairo_operator_t op, + cairo_surface_t *abstract_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + const cairo_rectangle_int_t *extents, + cairo_antialias_t antialias, + cairo_traps_t *traps) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +check_composite_glyphs (const cairo_composite_rectangles_t *extents, + cairo_scaled_font_t *scaled_font, + cairo_glyph_t *glyphs, + int *num_glyphs) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +composite_glyphs (void *_dst, + cairo_operator_t op, + cairo_surface_t *_src, + int src_x, + int src_y, + int dst_x, + int dst_y, + cairo_composite_glyphs_info_t *info) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +spans (void *abstract_renderer, + int y, int height, + const cairo_half_open_span_t *spans, + unsigned num_spans) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_status_t +finish_spans (void *abstract_renderer) +{ + return CAIRO_STATUS_SUCCESS; +} + +static cairo_int_status_t +span_renderer_init (cairo_abstract_span_renderer_t *_r, + const cairo_composite_rectangles_t *composite, + cairo_bool_t needs_clip) +{ + cairo_span_renderer_t *r = (cairo_span_renderer_t *)_r; + r->render_rows = spans; + r->finish = finish_spans; + return CAIRO_STATUS_SUCCESS; +} + +static void +span_renderer_fini (cairo_abstract_span_renderer_t *_r, + cairo_int_status_t status) +{ +} + +static const cairo_compositor_t * +no_fallback_compositor_get (void) +{ + return &__cairo_no_compositor; +} + +static const cairo_compositor_t * +no_traps_compositor_get (void) +{ + static cairo_traps_compositor_t compositor; + + if (compositor.base.delegate == NULL) { + _cairo_traps_compositor_init (&compositor, + no_fallback_compositor_get ()); + + compositor.acquire = acquire; + compositor.release = release; + compositor.set_clip_region = set_clip_region; + compositor.pattern_to_surface = pattern_to_surface; + compositor.has_snapshot = has_snapshot; + compositor.draw_image_boxes = draw_image_boxes; + //compositor.copy_boxes = copy_boxes; + compositor.fill_boxes = fill_boxes; + //compositor.check_composite = check_composite; + compositor.composite = composite; + compositor.lerp = lerp; + //compositor.check_composite_boxes = check_composite_boxes; + compositor.composite_boxes = composite_boxes; + //compositor.check_composite_traps = check_composite_traps; + compositor.composite_traps = composite_traps; + compositor.check_composite_glyphs = check_composite_glyphs; + compositor.composite_glyphs = composite_glyphs; + } + + return &compositor.base; +} + +static const cairo_compositor_t * +no_spans_compositor_get (void) +{ + static cairo_spans_compositor_t compositor; + + if (compositor.base.delegate == NULL) { + _cairo_spans_compositor_init (&compositor, + no_traps_compositor_get()); + + //compositor.acquire = acquire; + //compositor.release = release; + compositor.fill_boxes = fill_boxes; + //compositor.check_composite_boxes = check_composite_boxes; + compositor.composite_boxes = composite_boxes; + //compositor.check_span_renderer = check_span_renderer; + compositor.renderer_init = span_renderer_init; + compositor.renderer_fini = span_renderer_fini; + } + + return &compositor.base; +} + +cairo_surface_t * +_cairo_test_no_fallback_compositor_surface_create (cairo_content_t content, + int width, + int height) +{ + return test_compositor_surface_create (no_fallback_compositor_get(), + content, width, height); +} + +cairo_surface_t * +_cairo_test_no_traps_compositor_surface_create (cairo_content_t content, + int width, + int height) +{ + return test_compositor_surface_create (no_traps_compositor_get(), + content, width, height); +} + +cairo_surface_t * +_cairo_test_no_spans_compositor_surface_create (cairo_content_t content, + int width, + int height) +{ + return test_compositor_surface_create (no_spans_compositor_get(), + content, width, height); +} diff --git a/src/test-fallback16-surface.h b/src/test-null-compositor-surface.h index 51a78d30..52d864b2 100644 --- a/src/test-fallback16-surface.h +++ b/src/test-null-compositor-surface.h @@ -1,7 +1,6 @@ /* cairo - a vector graphics library with display and print output * - * Copyright © 2005 Red Hat, Inc - * Copyright © 2009 Chris Wilson + * 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 @@ -28,25 +27,34 @@ * * The Original Code is the cairo graphics library. * - * The Initial Developer of the Original Code is Red Hat, Inc. + * The Initial Developer of the Original Code is Intel Corporation * * Contributor(s): - * Carl Worth <cworth@cworth.org> * Chris Wilson <chris@chris-wilson.co.uk> */ -#ifndef TEST_FALLBACK16_SURFACE_H -#define TEST_FALLBACK16_SURFACE_H +#ifndef TEST_NULL_COMPOSITOR_SURFACE_H +#define TEST_NULL_COMPOSITOR_SURFACE_H #include "cairo.h" CAIRO_BEGIN_DECLS cairo_surface_t * -_cairo_test_fallback16_surface_create (cairo_content_t content, - int width, - int height); +_cairo_test_no_fallback_compositor_surface_create (cairo_content_t content, + int width, + int height); + +cairo_surface_t * +_cairo_test_no_traps_compositor_surface_create (cairo_content_t content, + int width, + int height); + +cairo_surface_t * +_cairo_test_no_spans_compositor_surface_create (cairo_content_t content, + int width, + int height); CAIRO_END_DECLS -#endif /* TEST_FALLBACK16_SURFACE_H */ +#endif /* TEST_NULL_COMPOSITOR_SURFACE_H */ diff --git a/src/test-null-surface.c b/src/test-null-surface.c deleted file mode 100644 index 1eae89c1..00000000 --- a/src/test-null-surface.c +++ /dev/null @@ -1,195 +0,0 @@ -/* cairo - a vector graphics library with display and print output - * - * Copyright © 2009 Chris Wilson - * - * This library is free software; you can redistribute it and/or - * modify it either under the terms of the GNU Lesser General Public - * License version 2.1 as published by the Free Software Foundation - * (the "LGPL") or, at your option, under the terms of the Mozilla - * Public License Version 1.1 (the "MPL"). If you do not alter this - * notice, a recipient may use your version of this file under either - * the MPL or the LGPL. - * - * You should have received a copy of the LGPL along with this library - * in the file COPYING-LGPL-2.1; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA - * You should have received a copy of the MPL along with this library - * in the file COPYING-MPL-1.1 - * - * The contents of this file are subject to the Mozilla Public License - * Version 1.1 (the "License"); you may not use this file except in - * compliance with the License. You may obtain a copy of the License at - * http://www.mozilla.org/MPL/ - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY - * OF ANY KIND, either express or implied. See the LGPL or the MPL for - * the specific language governing rights and limitations. - * - * The Original Code is the cairo graphics library. - * - * Contributor(s): - * Chris Wilson <chris@chris-wilson.co.uk> - */ - -/* This isn't a "real" surface, but just something to be used by the - * test suite to test a mythical backend that does nothing, i.e. it - * solely useful for measuring the overhead of the cairo public API. - */ - -#include "cairoint.h" - -#include "test-null-surface.h" - -#include "cairo-default-context-private.h" -#include "cairo-error-private.h" - -slim_hidden_proto (_cairo_test_null_surface_create); - -static cairo_int_status_t -_return_success (void) -{ - return CAIRO_STATUS_SUCCESS; -} - -/* These typedefs are just to silence the compiler... */ -typedef cairo_int_status_t -(*_paint_func) (void *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_clip_t *clip); - -typedef cairo_int_status_t -(*_mask_func) (void *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_pattern_t *mask, - const cairo_clip_t *clip); - -typedef cairo_int_status_t -(*_stroke_func) (void *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); - -typedef cairo_int_status_t -(*_fill_func) (void *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); - -typedef cairo_int_status_t -(*_show_glyphs_func) (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, - int *remaining_glyphs); - -typedef cairo_int_status_t -(*_show_text_glyphs_func) (void *surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const char *utf8, - int utf8_len, - cairo_glyph_t *glyphs, - int num_glyphs, - const cairo_text_cluster_t *clusters, - int num_clusters, - cairo_text_cluster_flags_t cluster_flags, - cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip); - -static cairo_surface_t * -_cairo_null_surface_create_similar (void *other, - cairo_content_t content, - int width, int height) -{ - return _cairo_test_null_surface_create (content); -} - -static cairo_bool_t -_cairo_null_surface_get_extents (void *surface, - cairo_rectangle_int_t *extents) -{ - return FALSE; -} - -static cairo_bool_t -_cairo_null_surface_has_show_text_glyphs (void *surface) -{ - return TRUE; -} - -static const cairo_surface_backend_t null_surface_backend = { - CAIRO_INTERNAL_SURFACE_TYPE_NULL, - NULL, /* finish */ - _cairo_default_context_create, - - _cairo_null_surface_create_similar, - NULL, /* create similar image */ - NULL, /* map_to_image */ - NULL, /* unmap image */ - - NULL, /* acquire_source_image */ - NULL, /* release_source_image */ - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ - NULL, /* copy_page */ - NULL, /* show_page */ - _cairo_null_surface_get_extents, - NULL, /* old_show_glyphs */ - NULL, /* get_font_options */ - NULL, /* flush */ - NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ - (_paint_func) _return_success, /* paint */ - (_mask_func) _return_success, /* mask */ - (_stroke_func) _return_success, /* stroke */ - (_fill_func) _return_success, /* fill */ - (_show_glyphs_func) _return_success, /* show_glyphs */ - NULL, /* snapshot */ - NULL, /* is_similar */ - NULL, /* fill_stroke */ - NULL, /* create_solid_pattern_surface */ - NULL, /* can_repaint_solid_pattern_surface */ - _cairo_null_surface_has_show_text_glyphs, - (_show_text_glyphs_func) _return_success, /* show_text_glyphs */ -}; - -cairo_surface_t * -_cairo_test_null_surface_create (cairo_content_t content) -{ - cairo_surface_t *surface; - - surface = malloc (sizeof (cairo_surface_t)); - if (unlikely (surface == NULL)) { - return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); - } - - _cairo_surface_init (surface, - &null_surface_backend, - NULL, /* device */ - content); - - return surface; -} -slim_hidden_def (_cairo_test_null_surface_create); diff --git a/src/test-paginated-surface.c b/src/test-paginated-surface.c index 1e95c5fc..e3c8a917 100644 --- a/src/test-paginated-surface.c +++ b/src/test-paginated-surface.c @@ -52,6 +52,7 @@ #include "cairo-default-context-private.h" #include "cairo-error-private.h" #include "cairo-paginated-private.h" +#include "cairo-surface-backend-private.h" typedef struct _test_paginated_surface { cairo_surface_t base; @@ -254,23 +255,16 @@ static const cairo_surface_backend_t test_paginated_surface_backend = { NULL, /* acquire_source_image */ NULL, /* release_source_image */ - NULL, /* acquire_dest_image */ - NULL, /* release_dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ + NULL, /* snapshot */ + NULL, /* copy_page */ NULL, /* show_page */ + _test_paginated_surface_get_extents, - NULL, /* old_show_glyphs */ NULL, /* get_font_options */ + NULL, /* flush */ NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ /* Here is the more "modern" section of the surface backend * interface which is mostly just drawing functions */ @@ -279,14 +273,8 @@ static const cairo_surface_backend_t test_paginated_surface_backend = { _test_paginated_surface_mask, _test_paginated_surface_stroke, _test_paginated_surface_fill, + NULL, /* fill-stroke */ NULL, /* replaced by show_text_glyphs */ - - NULL, /* snapshot */ - NULL, /* is_similar */ - NULL, /* fill_stroke */ - NULL, /* create_solid_pattern_surface */ - NULL, /* can_repaint_solid_pattern_surface */ - _test_paginated_surface_has_show_text_glyphs, _test_paginated_surface_show_text_glyphs }; diff --git a/src/test-wrapping-surface.c b/src/test-wrapping-surface.c deleted file mode 100644 index 7552886b..00000000 --- a/src/test-wrapping-surface.c +++ /dev/null @@ -1,281 +0,0 @@ -/* cairo - a vector graphics library with display and print output - * - * Copyright © 2005 Red Hat, Inc - * Copyright © Chris Wilson - * - * This library is free software; you can redistribute it and/or - * modify it either under the terms of the GNU Lesser General Public - * License version 2.1 as published by the Free Software Foundation - * (the "LGPL") or, at your option, under the terms of the Mozilla - * Public License Version 1.1 (the "MPL"). If you do not alter this - * notice, a recipient may use your version of this file under either - * the MPL or the LGPL. - * - * You should have received a copy of the LGPL along with this library - * in the file COPYING-LGPL-2.1; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA - * You should have received a copy of the MPL along with this library - * in the file COPYING-MPL-1.1 - * - * The contents of this file are subject to the Mozilla Public License - * Version 1.1 (the "License"); you may not use this file except in - * compliance with the License. You may obtain a copy of the License at - * http://www.mozilla.org/MPL/ - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY - * OF ANY KIND, either express or implied. See the LGPL or the MPL for - * the specific language governing rights and limitations. - * - * The Original Code is the cairo graphics library. - * - * The Initial Developer of the Original Code is Red Hat, Inc. - * - * Contributor(s): - * Carl Worth <cworth@cworth.org> - * Chris Wilson <chris@chris-wilson.co.uk> - */ - -/* Another mythical surface that exists to simply wrap another - do nothing - * itself but forward the calls onto a target surface. - */ - -#include "cairoint.h" - -#include "test-wrapping-surface.h" - -#include "cairo-default-context-private.h" -#include "cairo-error-private.h" -#include "cairo-surface-wrapper-private.h" - -typedef struct _test_wrapping_surface { - cairo_surface_t base; - cairo_surface_wrapper_t wrapper; -} test_wrapping_surface_t; - -static const cairo_surface_backend_t test_wrapping_surface_backend; - -slim_hidden_proto (_cairo_test_wrapping_surface_create); - -cairo_surface_t * -_cairo_test_wrapping_surface_create (cairo_surface_t *target) -{ - test_wrapping_surface_t *surface; - - if (unlikely (target->status)) - return _cairo_surface_create_in_error (target->status); - - surface = malloc (sizeof (test_wrapping_surface_t)); - if (unlikely (surface == NULL)) - return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); - - _cairo_surface_init (&surface->base, - &test_wrapping_surface_backend, - NULL, /* device */ - target->content); - - _cairo_surface_wrapper_init (&surface->wrapper, target); - - return &surface->base; -} -slim_hidden_def (_cairo_test_wrapping_surface_create); - -static cairo_surface_t * -_test_wrapping_surface_create_similar (void *abstract_surface, - cairo_content_t content, - int width, - int height) -{ - - test_wrapping_surface_t *surface = abstract_surface; - - return _cairo_test_wrapping_surface_create ( - _cairo_surface_wrapper_create_similar (&surface->wrapper, - content, width, height)); -} - -static cairo_status_t -_test_wrapping_surface_finish (void *abstract_surface) -{ - test_wrapping_surface_t *surface = abstract_surface; - - _cairo_surface_wrapper_fini (&surface->wrapper); - - return CAIRO_STATUS_SUCCESS; -} - -static cairo_status_t -_test_wrapping_surface_acquire_source_image (void *abstract_surface, - cairo_image_surface_t **image_out, - void **image_extra) -{ - test_wrapping_surface_t *surface = abstract_surface; - - return _cairo_surface_wrapper_acquire_source_image (&surface->wrapper, - image_out, image_extra); -} - -static void -_test_wrapping_surface_release_source_image (void *abstract_surface, - cairo_image_surface_t *image, - void *image_extra) -{ - test_wrapping_surface_t *surface = abstract_surface; - - _cairo_surface_wrapper_release_source_image (&surface->wrapper, - image, image_extra); -} - -static cairo_bool_t -_test_wrapping_surface_get_extents (void *abstract_surface, - cairo_rectangle_int_t *rectangle) -{ - test_wrapping_surface_t *surface = abstract_surface; - - return _cairo_surface_wrapper_get_extents (&surface->wrapper, rectangle); -} - -static cairo_int_status_t -_test_wrapping_surface_paint (void *abstract_surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_clip_t *clip) -{ - test_wrapping_surface_t *surface = abstract_surface; - - return _cairo_surface_wrapper_paint (&surface->wrapper, op, source, clip); -} - -static cairo_int_status_t -_test_wrapping_surface_mask (void *abstract_surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const cairo_pattern_t *mask, - const cairo_clip_t *clip) -{ - test_wrapping_surface_t *surface = abstract_surface; - - return _cairo_surface_wrapper_mask (&surface->wrapper, - op, source, mask, clip); -} - -static cairo_int_status_t -_test_wrapping_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) -{ - test_wrapping_surface_t *surface = abstract_surface; - - return _cairo_surface_wrapper_stroke (&surface->wrapper, - op, source, - path, style, - ctm, ctm_inverse, - tolerance, antialias, - clip); -} - -static cairo_int_status_t -_test_wrapping_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) -{ - test_wrapping_surface_t *surface = abstract_surface; - - return _cairo_surface_wrapper_fill (&surface->wrapper, - op, source, - path, fill_rule, - tolerance, antialias, - clip); -} - -static cairo_bool_t -_test_wrapping_surface_has_show_text_glyphs (void *abstract_surface) -{ - test_wrapping_surface_t *surface = abstract_surface; - - return _cairo_surface_wrapper_has_show_text_glyphs (&surface->wrapper); -} - -static cairo_int_status_t -_test_wrapping_surface_show_text_glyphs (void *abstract_surface, - cairo_operator_t op, - const cairo_pattern_t *source, - const char *utf8, - int utf8_len, - cairo_glyph_t *glyphs, - int num_glyphs, - const cairo_text_cluster_t *clusters, - int num_clusters, - cairo_text_cluster_flags_t cluster_flags, - cairo_scaled_font_t *scaled_font, - const cairo_clip_t *clip) -{ - test_wrapping_surface_t *surface = abstract_surface; - - return _cairo_surface_wrapper_show_text_glyphs (&surface->wrapper, - op, source, - utf8, utf8_len, - glyphs, num_glyphs, - clusters, num_clusters, - cluster_flags, - scaled_font, - clip); -} - -static const cairo_surface_backend_t test_wrapping_surface_backend = { - CAIRO_INTERNAL_SURFACE_TYPE_TEST_WRAPPING, - _test_wrapping_surface_finish, - _cairo_default_context_create, - - _test_wrapping_surface_create_similar, - NULL, /* create similar image */ - NULL, /* map to image */ - NULL, /* unmap image */ - - _test_wrapping_surface_acquire_source_image, - _test_wrapping_surface_release_source_image, - NULL, NULL, /* dest_image */ - NULL, /* clone_similar */ - NULL, /* composite */ - NULL, /* fill_rectangles */ - NULL, /* composite_trapezoids */ - NULL, /* create_span_renderer */ - NULL, /* check_span_renderer */ - NULL, /* copy_page */ - NULL, /* show_page */ - _test_wrapping_surface_get_extents, - NULL, /* old_show_glyphs */ - NULL, /* get_font_options */ - NULL, /* flush */ - NULL, /* mark_dirty_rectangle */ - NULL, /* scaled_font_fini */ - NULL, /* scaled_glyph_fini */ - - _test_wrapping_surface_paint, - _test_wrapping_surface_mask, - _test_wrapping_surface_stroke, - _test_wrapping_surface_fill, - NULL, /* replaced by show_text_glyphs */ - - NULL, /* snapshot */ - NULL, /* is_similar */ - NULL, /* fill_stroke */ - NULL, /* create_solid_pattern_surface */ - NULL, /* can_repaint_solid_pattern_surface */ - - _test_wrapping_surface_has_show_text_glyphs, - _test_wrapping_surface_show_text_glyphs - - /* XXX wrap fill-stroke and show_glyphs */ -}; diff --git a/test/Makefile.refs b/test/Makefile.refs index b09f7810..68f721ac 100644 --- a/test/Makefile.refs +++ b/test/Makefile.refs @@ -6,6 +6,8 @@ REFERENCE_IMAGES = \ a1-bug.ref.png \ a1-bug.xlib.ref.png \ a1-clip-fill-equal.ref.png \ + a1-clip-fill-rule.argb32.ref.png \ + a1-clip-fill-rule.rgb24.ref.png \ a1-clip-fill.ref.png \ a1-clip-paint.ref.png \ a1-clip-stroke.ref.png \ @@ -18,6 +20,7 @@ REFERENCE_IMAGES = \ a1-rasterisation-rectangles.ref.png \ a1-rasterisation-triangles.quartz.xfail.png \ a1-rasterisation-triangles.ref.png \ + a1-rectilinear-grid.ref.png \ a1-sample.ref.png \ a1-traps-sample.quartz.xfail.png \ a1-traps-sample.ref.png \ @@ -885,6 +888,8 @@ REFERENCE_IMAGES = \ over-between-source.svg12.rgb24.xfail.png \ over-between-source.xlib.ref.png \ over-between-source.xlib.rgb24.ref.png \ + overlapping-boxes.argb32.ref.png \ + overlapping-boxes.rgb24.ref.png \ overlapping-dash-caps.ref.png \ overlapping-glyphs.argb32.ref.png \ overlapping-glyphs.pdf.argb32.xfail.png \ @@ -1155,6 +1160,7 @@ REFERENCE_IMAGES = \ set-source.ref.png \ set-source.rgb24.ref.png \ shape-general-convex.ref.png \ + shape-sierpinski.ref.png \ show-glyphs-advance.image16.ref.png \ show-glyphs-advance.ps.ref.png \ show-glyphs-advance.quartz.ref.png \ @@ -1299,9 +1305,6 @@ REFERENCE_IMAGES = \ svg-surface-source.rgb24.ref.png \ svg-surface-source.svg12.argb32.xfail.png \ svg-surface-source.svg12.rgb24.xfail.png \ - test-fallback16-surface-source.ps.ref.png \ - test-fallback16-surface-source.svg12.argb32.xfail.png \ - test-fallback16-surface-source.svg12.rgb24.xfail.png \ text-antialias-gray.image16.ref.png \ text-antialias-gray.quartz.ref.png \ text-antialias-gray.ref.png \ diff --git a/test/Makefile.sources b/test/Makefile.sources index 526ac8a8..05bcdd0c 100644 --- a/test/Makefile.sources +++ b/test/Makefile.sources @@ -211,6 +211,7 @@ test_sources = \ over-around-source.c \ over-below-source.c \ over-between-source.c \ + overlapping-boxes.c \ overlapping-glyphs.c \ overlapping-dash-caps.c \ paint.c \ @@ -273,6 +274,7 @@ test_sources = \ show-glyphs-many.c \ show-text-current-point.c \ shape-general-convex.c \ + shape-sierpinski.c \ skew-extreme.c \ smask.c \ smask-fill.c \ @@ -373,9 +375,6 @@ svg_surface_test_sources = \ svg-clip.c \ svg-surface-source.c -test_fallback16_surface_test_sources = \ - test-fallback16-surface-source.c - xcb_surface_test_sources = \ xcb-surface-source.c diff --git a/test/a1-clip-fill-rule.argb32.ref.png b/test/a1-clip-fill-rule.argb32.ref.png Binary files differnew file mode 100644 index 00000000..c3ba9dd5 --- /dev/null +++ b/test/a1-clip-fill-rule.argb32.ref.png diff --git a/test/a1-clip-fill-rule.rgb24.ref.png b/test/a1-clip-fill-rule.rgb24.ref.png Binary files differnew file mode 100644 index 00000000..6fe9346b --- /dev/null +++ b/test/a1-clip-fill-rule.rgb24.ref.png diff --git a/test/a1-rectilinear-grid.ref.png b/test/a1-rectilinear-grid.ref.png Binary files differnew file mode 100644 index 00000000..2dfb85e1 --- /dev/null +++ b/test/a1-rectilinear-grid.ref.png diff --git a/test/cairo-test-trace.c b/test/cairo-test-trace.c index 146ca6fe..296a229d 100644 --- a/test/cairo-test-trace.c +++ b/test/cairo-test-trace.c @@ -93,8 +93,10 @@ #define DEBUG 0 +#define ignore_image_differences 0 /* XXX make me a cmdline option! */ + #define DATA_SIZE (256 << 20) -#define SHM_PATH_XXX "/shmem-cairo-trace" +#define SHM_PATH_XXX "/.shmem-cairo-trace" typedef struct _test_trace { /* Options from command-line */ @@ -163,6 +165,8 @@ struct surface_tag { }; static const cairo_user_data_key_t surface_tag; +#define TARGET_NAME(T) ((T) ? (T)->name : "recording") + #if CAIRO_HAS_REAL_PTHREAD #define tr_die(t) t->is_recording ? pthread_exit(NULL) : exit(1) #else @@ -253,7 +257,7 @@ send_recording_surface (test_runner_t *tr, closure->end_line, -1, width, height, - cairo_surface_get_type (closure->surface) == CAIRO_SURFACE_TYPE_IMAGE ? 0 : (long) closure->surface, + (long) closure->surface, }; unsigned long offset; unsigned long serial; @@ -320,7 +324,8 @@ send_surface (test_runner_t *tr, unsigned long serial; if (DEBUG > 1) { - printf ("send-surface: '%s'\n", tr->name); + printf ("send-surface: '%s', is-recording? %d\n", + tr->name, tr->is_recording); } if (cairo_surface_get_type (source) == CAIRO_SURFACE_TYPE_IMAGE) { @@ -390,7 +395,8 @@ send_surface (test_runner_t *tr, static cairo_surface_t * _surface_create (void *closure, cairo_content_t content, - double width, double height) + double width, double height, + long uid) { test_runner_t *tr = closure; cairo_surface_t *surface; @@ -416,6 +422,13 @@ _context_create (void *closure, cairo_surface_t *surface) test_runner_t *tr = closure; struct context_closure *l; + if (DEBUG) { + fprintf (stderr, "%s: starting context %lu on line %d\n", + tr->name ? tr->name : "recording" , + tr->context_id + 1, + cairo_script_interpreter_get_line_number (tr->csi)); + } + l = xmalloc (sizeof (*l)); l->next = tr->contexts; l->start_line = cairo_script_interpreter_get_line_number (tr->csi); @@ -438,6 +451,12 @@ _context_destroy (void *closure, void *ptr) while ((l = *prev) != NULL) { if (l->context == ptr) { + if (DEBUG) { + fprintf (stderr, "%s: context %lu complete on line %d\n", + tr->name ? tr->name : "recording" , + tr->context_id, + cairo_script_interpreter_get_line_number (tr->csi)); + } l->end_line = cairo_script_interpreter_get_line_number (tr->csi); if (cairo_surface_status (l->surface) == CAIRO_STATUS_SUCCESS) { @@ -623,7 +642,7 @@ record (void *arg) * 2. Runs in the same process, but separate thread. */ static pid_t -spawn_recorder (const char *socket_path, const char *trace) +spawn_recorder (const char *socket_path, const char *trace, test_runner_t **out) { test_runner_t *tr; pthread_t id; @@ -652,7 +671,7 @@ spawn_recorder (const char *socket_path, const char *trace) tr->trace = trace; tr->surface = cairo_recording_surface_create (CAIRO_CONTENT_COLOR_ALPHA, - 0, 0); + NULL); if (tr->surface == NULL) { cleanup_recorder (tr); return -1; @@ -667,6 +686,8 @@ spawn_recorder (const char *socket_path, const char *trace) } pthread_attr_destroy (&attr); + + *out = tr; return pid; } #endif @@ -814,6 +835,11 @@ matches_reference (struct slave *slave) bb += stride; } break; + + case CAIRO_FORMAT_RGB30: + case CAIRO_FORMAT_RGB16_565: + case CAIRO_FORMAT_INVALID: + assert (0); } return TRUE; @@ -825,6 +851,9 @@ check_images (struct slave *slaves, int num_slaves) { int n; + if (ignore_image_differences) + return TRUE; + for (n = 0; n < num_slaves; n++) { if (slaves[n].reference == NULL) continue; @@ -861,29 +890,59 @@ write_images (const char *trace, struct slave *slave, int num_slaves) } static void +write_result (const char *trace, struct slave *slave) +{ + static int index; + char *filename; + + xasprintf (&filename, "%s-%s-pass-%d-%d-%d.png", + trace, slave->target->name, ++index, + slave->start_line, slave->end_line); + cairo_surface_write_to_png (slave->image, filename); + free (filename); +} + +static void write_trace (const char *trace, struct slave *slave) { #if CAIRO_HAS_SCRIPT_SURFACE - cairo_device_t *ctx, - cairo_surface_t *script; + cairo_device_t *script; char *filename; - cairo_t *cr; + + assert (slave->is_recording); xasprintf (&filename, "%s-fail.trace", trace); - ctx = cairo_script_create (filename); - script = cairo_script_surface_create (ctx, - cairo_surface_get_content (slave->image), - slave->width, - slave->height); - cairo_device_destroy (ctx); + + script = cairo_script_create (filename); + cairo_script_from_recording_surface (script, slave->image); + cairo_device_destroy (script); + free (filename); +#endif +} - cr = cairo_create (slave->image); - cairo_set_source_surface (cr, script, 0, 0); - cairo_paint (cr); - cairo_destroy (cr); +static void +dump_traces (test_runner_t *tr, + const char *trace, + const char *target, + const char *fail) +{ +#if CAIRO_HAS_SCRIPT_SURFACE + struct context_closure *c; + + for (c = tr->contexts; c; c = c->next) { + cairo_device_t *script; + char *filename; + + xasprintf (&filename, "%s-%s-%s.%lu.trace", + trace, target, fail, c->start_line); + + script = cairo_script_create (filename); + cairo_script_from_recording_surface (script, c->surface); + cairo_device_destroy (script); - cairo_surface_destroy (script); + free (filename); + } #endif } @@ -907,14 +966,16 @@ allocate_image_for_slave (uint8_t *base, slave->height = rq.height; if (DEBUG > 1) { - printf ("allocate-image-for-slave: %s %lu [%lu, %lu] %ldx%ld=> %lu\n", - slave->target->name, + printf ("allocate-image-for-slave: %s %lu [%lu, %lu] %ldx%ld stride=%lu => %lu, is-recording? %d\n", + TARGET_NAME (slave->target), slave->image_serial, slave->start_line, slave->end_line, slave->width, slave->height, - offset); + rq.stride, + offset, + slave->is_recording); } if (slave->is_recording) { @@ -1031,14 +1092,14 @@ test_run (void *base, offset = image, &slaves[i]); if (! writen (pfd[n].fd, &offset, sizeof (offset))) - goto out; + goto done; } else { readn (pfd[n].fd, &slaves[i].image_ready, sizeof (slaves[i].image_ready)); if (DEBUG) { printf ("slave '%s' reports completion on %lu (expecting %lu)\n", - slaves[i].target->name, + TARGET_NAME (slaves[i].target), slaves[i].image_ready, slaves[i].image_serial); } @@ -1062,7 +1123,8 @@ test_run (void *base, if (DEBUG > 1) { printf ("all saves report completion\n"); } - if (! check_images (slaves, num_slaves)) { + if (slaves[0].end_line >= slaves[0].start_line && + ! check_images (slaves, num_slaves)) { error->context_id = slaves[0].image_serial; error->start_line = slaves[0].start_line; error->end_line = slaves[0].end_line; @@ -1082,6 +1144,8 @@ test_run (void *base, goto out; } + if (0) write_result (trace, &slaves[1]); + /* ack */ for (i = 0; i < num_slaves; i++) { cairo_surface_destroy (slaves[i].image); @@ -1089,7 +1153,7 @@ test_run (void *base, if (DEBUG > 1) { printf ("sending continuation to '%s'\n", - slaves[i].target->name); + TARGET_NAME (slaves[i].target)); } if (! writen (slaves[i].fd, &slaves[i].image_serial, @@ -1129,7 +1193,6 @@ out: slaves[n].image_serial = 0; slaves[n].image_ready = 0; - ret = FALSE; } free (pfd); @@ -1137,51 +1200,6 @@ out: return ret; } -/* Paginated surfaces require finalization and external converters and so - * are not suitable for this basic technique. - */ -static cairo_bool_t -target_is_measurable (const cairo_boilerplate_target_t *target) -{ - if (target->content != CAIRO_CONTENT_COLOR_ALPHA) - return FALSE; - - switch (target->expected_type) { - case CAIRO_SURFACE_TYPE_IMAGE: - if (strcmp (target->name, "pdf") == 0 || - strcmp (target->name, "ps") == 0) - { - return FALSE; - } - else - { - return TRUE; - } - case CAIRO_SURFACE_TYPE_XLIB: - case CAIRO_SURFACE_TYPE_XCB: - case CAIRO_SURFACE_TYPE_GLITZ: - case CAIRO_SURFACE_TYPE_QUARTZ: - case CAIRO_SURFACE_TYPE_QUARTZ_IMAGE: - case CAIRO_SURFACE_TYPE_WIN32: - case CAIRO_SURFACE_TYPE_BEOS: - case CAIRO_SURFACE_TYPE_DIRECTFB: - case CAIRO_SURFACE_TYPE_OS2: - case CAIRO_SURFACE_TYPE_QT: - return TRUE; - - case CAIRO_SURFACE_TYPE_PDF: - case CAIRO_SURFACE_TYPE_PS: - case CAIRO_SURFACE_TYPE_SCRIPT: - case CAIRO_SURFACE_TYPE_SVG: - case CAIRO_SURFACE_TYPE_WIN32_PRINTING: - case CAIRO_SURFACE_TYPE_RECORDING: - default: - return FALSE; - } - - return TRUE; -} - static int server_socket (const char *socket_path) { @@ -1241,6 +1259,7 @@ _test_trace (test_trace_t *test, const char *shm_path = SHM_PATH_XXX; const cairo_boilerplate_target_t *target, *image; struct slave *slaves, *s; + test_runner_t *recorder = NULL; pid_t slave; char socket_dir[] = "/tmp/cairo-test-trace.XXXXXX"; char *socket_path; @@ -1249,6 +1268,9 @@ _test_trace (test_trace_t *test, void *base; cairo_bool_t ret = FALSE; + if (DEBUG) + printf ("setting up trace '%s'\n", trace); + /* create a socket to control the test runners */ if (mkdtemp (socket_dir) == NULL) { fprintf (stderr, "Unable to create temporary name for socket\n"); @@ -1265,8 +1287,8 @@ _test_trace (test_trace_t *test, /* allocate some shared memory */ fd = server_shm (shm_path); if (fd == -1) { - fprintf (stderr, "Unable to create shared memory '%s'\n", - shm_path); + fprintf (stderr, "Unable to create shared memory '%s': %s\n", + shm_path, strerror (errno)); goto cleanup_sk; } @@ -1277,7 +1299,7 @@ _test_trace (test_trace_t *test, #if CAIRO_HAS_REAL_PTHREAD /* set-up a recording-surface to reconstruct errors */ - slave = spawn_recorder (socket_path, trace); + slave = spawn_recorder (socket_path, trace, &recorder); if (slave < 0) { fprintf (stderr, "Unable to create recording surface\n"); goto cleanup_sk; @@ -1297,7 +1319,12 @@ _test_trace (test_trace_t *test, struct slave *master; target = test->targets[i]; - if (target == image || ! target_is_measurable (target)) + + if (DEBUG) + printf ("setting up target[%d]? '%s' (image? %d, measurable? %d)\n", + i, target->name, target == image, target->is_measurable); + + if (target == image || ! target->is_measurable) continue; /* find a matching slave to use as a reference for this target */ @@ -1356,14 +1383,22 @@ cleanup: while (s-- > slaves) { int status; + if (s->fd != -1) + close (s->fd); + + cairo_surface_destroy (s->image); + cairo_surface_destroy (s->difference); + if (s->is_recording) /* in-process */ continue; kill (s->pid, SIGKILL); waitpid (s->pid, &status, 0); - ret &= WIFEXITED (status) && WEXITSTATUS (status) == 0; - if (WIFSIGNALED (status) && WTERMSIG(status) != SIGKILL) + if (WIFSIGNALED (status) && WTERMSIG(status) != SIGKILL) { fprintf (stderr, "%s crashed\n", s->target->name); + if (recorder) + dump_traces (recorder, trace, s->target->name, "crash"); + } } free (slaves); shm_unlink (shm_path); @@ -1630,6 +1665,8 @@ main (int argc, char *argv[]) parse_options (&test, argc, argv); + shm_unlink (SHM_PATH_XXX); + if (getenv ("CAIRO_TRACE_DIR") != NULL) trace_dir = getenv ("CAIRO_TRACE_DIR"); diff --git a/test/clear-source.c b/test/clear-source.c index a4c3db2f..5410932f 100644 --- a/test/clear-source.c +++ b/test/clear-source.c @@ -128,7 +128,7 @@ static operation_t operations[] = { glyphs }; - static cairo_test_status_t +static cairo_test_status_t draw (cairo_t *cr, int width, int height) { cairo_content_t contents[] = { CAIRO_CONTENT_COLOR_ALPHA, CAIRO_CONTENT_COLOR, CAIRO_CONTENT_ALPHA }; diff --git a/test/clip-fill-rule.c b/test/clip-fill-rule.c index 8351d868..035b9a83 100644 --- a/test/clip-fill-rule.c +++ b/test/clip-fill-rule.c @@ -66,9 +66,22 @@ draw (cairo_t *cr, int width, int height) return CAIRO_TEST_SUCCESS; } +static cairo_test_status_t +a1_draw (cairo_t *cr, int width, int height) +{ + cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE); + return draw (cr, width, height); +} + CAIRO_TEST (clip_fill_rule, "Tests interaction of clipping with cairo_set_fill_rule", "clip", /* keywords */ NULL, /* requirements */ STAR_SIZE * 2 + 2, STAR_SIZE + 2, NULL, draw) +CAIRO_TEST (a1_clip_fill_rule, + "Tests interaction of clipping with cairo_set_fill_rule", + "clip", /* keywords */ + NULL, /* requirements */ + STAR_SIZE * 2 + 2, STAR_SIZE + 2, + NULL, a1_draw) diff --git a/test/map-to-image.c b/test/map-to-image.c index b7d6df8a..0262245a 100644 --- a/test/map-to-image.c +++ b/test/map-to-image.c @@ -89,7 +89,7 @@ static cairo_test_status_t bit (cairo_t *cr, int width, int height) { cairo_surface_t *surface; - cairo_rectangle_t extents; + cairo_rectangle_int_t extents; cairo_format_t format; uint8_t *data; @@ -117,7 +117,7 @@ static cairo_test_status_t fill (cairo_t *cr, int width, int height) { cairo_surface_t *surface; - cairo_rectangle_t extents; + cairo_rectangle_int_t extents; cairo_t *cr2; extents.x = extents.y = extents.width = extents.height = 1; diff --git a/test/overlapping-boxes.argb32.ref.png b/test/overlapping-boxes.argb32.ref.png Binary files differnew file mode 100644 index 00000000..278e62a8 --- /dev/null +++ b/test/overlapping-boxes.argb32.ref.png diff --git a/test/overlapping-boxes.c b/test/overlapping-boxes.c new file mode 100644 index 00000000..92211ee0 --- /dev/null +++ b/test/overlapping-boxes.c @@ -0,0 +1,96 @@ +/* + * Copyright © 2011 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * Author: Chris Wilson <chris@chris-wilson.co.uk> + */ + +/* Not strictly overlapping, but it does highlight the error in + * an optimisation of fill-box handling that I frequently am + * tempted to write. + */ + +#include "cairo-test.h" + +#define WIDTH (20) +#define HEIGHT (20) + +static void +border (cairo_t *cr) +{ + cairo_rectangle (cr, 1, 1, 8, 8); + cairo_rectangle (cr, 1.25, 1.25, 7.5, 7.5); + cairo_rectangle (cr, 1.75, 1.75, 6.5, 6.5); + cairo_rectangle (cr, 2, 2, 6, 6); +} + +static cairo_test_status_t +draw (cairo_t *cr, int width, int height) +{ + cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD); + + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_paint (cr); + + border (cr); + cairo_set_source_rgb (cr, 1, 0, 0); + cairo_set_operator (cr, CAIRO_OPERATOR_OVER); + cairo_fill (cr); + + cairo_translate (cr, 10, 0); + + border (cr); + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); + cairo_fill (cr); + + cairo_translate (cr, 0, 10); + + cairo_rectangle (cr, 0, 0, 10, 10); + cairo_clip (cr); + + border (cr); + cairo_set_source_rgb (cr, 0, 1, 0); + cairo_set_operator (cr, CAIRO_OPERATOR_IN); + cairo_fill (cr); + + cairo_reset_clip (cr); + + cairo_translate (cr, -10, 0); + + cairo_rectangle (cr, 0, 0, 10, 10); + cairo_clip (cr); + + border (cr); + cairo_set_source_rgb (cr, 0, 0, 1); + cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); + cairo_fill (cr); + + return CAIRO_TEST_SUCCESS; +} + +CAIRO_TEST (overlapping_boxes, + "A sub-pixel double border to highlight the danger in an easy optimisation", + "fill", /* keywords */ + NULL, /* requirements */ + WIDTH, HEIGHT, + NULL, draw) diff --git a/test/overlapping-boxes.rgb24.ref.png b/test/overlapping-boxes.rgb24.ref.png Binary files differnew file mode 100644 index 00000000..f35d0e6b --- /dev/null +++ b/test/overlapping-boxes.rgb24.ref.png diff --git a/test/rectilinear-grid.c b/test/rectilinear-grid.c index 1baadf73..8c6b7fca 100644 --- a/test/rectilinear-grid.c +++ b/test/rectilinear-grid.c @@ -70,9 +70,23 @@ draw (cairo_t *cr, int width, int height) return CAIRO_TEST_SUCCESS; } +static cairo_test_status_t +aligned (cairo_t *cr, int width, int height) +{ + cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE); + return draw (cr, width, height); +} + CAIRO_TEST (rectilinear_grid, "Test rectilinear rasterizer (covering partial pixels)", "rectilinear", /* keywords */ NULL, /* requirements */ SIZE, SIZE, NULL, draw) + +CAIRO_TEST (a1_rectilinear_grid, + "Test rectilinear rasterizer (covering whole pixels)", + "rectilinear", /* keywords */ + NULL, /* requirements */ + SIZE, SIZE, + NULL, aligned) diff --git a/test/shape-sierpinski.c b/test/shape-sierpinski.c new file mode 100644 index 00000000..9d201706 --- /dev/null +++ b/test/shape-sierpinski.c @@ -0,0 +1,85 @@ +/* + * Copyright © 2011 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * Author: Chris Wilson <chris@chris-wilson.co.uk> + */ + +/* I thought I spied a bug... */ + +#include "cairo-test.h" + +#define WIDTH (1024) +#define HEIGHT (600) + +static const double m_1_sqrt_3 = 0.577359269; + +static void +T (cairo_t *cr, int size) +{ + cairo_move_to (cr, 0, 0); + cairo_line_to (cr, size, 0); + cairo_line_to (cr, size/2, size*m_1_sqrt_3); + + size /= 2; + if (size >= 4) { + T (cr, size); + cairo_save (cr); { + cairo_translate (cr, size, 0); + T (cr, size); + } cairo_restore (cr); + cairo_save (cr); { + cairo_translate (cr, size/2, size*m_1_sqrt_3); + T (cr, size); + } cairo_restore (cr); + } +} + +static cairo_test_status_t +draw (cairo_t *cr, int width, int height) +{ + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_paint (cr); + + cairo_translate (cr, 0, 8); + + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_set_line_width (cr, 1.); + + T (cr, WIDTH); + + cairo_translate (cr, 0, 2*HEIGHT-16); + cairo_scale (cr, 1, -1); + + T (cr, WIDTH); + + cairo_stroke (cr); + + return CAIRO_TEST_SUCCESS; +} + +CAIRO_TEST (shape_sierpinski, + "A fractal triangle", + "stroke", /* keywords */ + NULL, /* requirements */ + WIDTH, 2*HEIGHT, + NULL, draw) diff --git a/test/shape-sierpinski.ref.png b/test/shape-sierpinski.ref.png Binary files differnew file mode 100644 index 00000000..69755d27 --- /dev/null +++ b/test/shape-sierpinski.ref.png diff --git a/test/test-fallback16-surface-source.c b/test/test-fallback16-surface-source.c deleted file mode 100644 index 7e9f920f..00000000 --- a/test/test-fallback16-surface-source.c +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright © 2009 Chris Wilson - * - * Permission to use, copy, modify, distribute, and sell this software - * and its documentation for any purpose is hereby granted without - * fee, provided that the above copyright notice appear in all copies - * and that both that copyright notice and this permission notice - * appear in supporting documentation, and that the name of - * Chris Wilson not be used in advertising or publicity pertaining to - * distribution of the software without specific, written prior - * permission. Chris Wilson makes no representations about the - * suitability of this software for any purpose. It is provided "as - * is" without express or implied warranty. - * - * CHRIS WILSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS - * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND - * FITNESS, IN NO EVENT SHALL CHRIS WILSON BE LIABLE FOR ANY SPECIAL, - * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER - * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION - * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR - * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * Author: Chris Wilson <chris@chris-wilson.co.uk> - */ - -#include "cairo-test.h" -#include <test-fallback16-surface.h> - -#include "surface-source.c" - -static cairo_surface_t * -create_source_surface (int size) -{ - return _cairo_test_fallback16_surface_create (CAIRO_CONTENT_COLOR_ALPHA, - size, size); -} - -CAIRO_TEST (test_fallback16_surface_source, - "Test using a 16-bit image (e.g. a low bit-depth XServer) surface as the source", - "source", /* keywords */ - NULL, /* requirements */ - SIZE, SIZE, - preamble, draw) diff --git a/test/test-fallback16-surface-source.ps.ref.png b/test/test-fallback16-surface-source.ps.ref.png Binary files differdeleted file mode 100644 index f686a068..00000000 --- a/test/test-fallback16-surface-source.ps.ref.png +++ /dev/null diff --git a/test/test-fallback16-surface-source.svg12.argb32.xfail.png b/test/test-fallback16-surface-source.svg12.argb32.xfail.png Binary files differdeleted file mode 100644 index 6ebcaf9a..00000000 --- a/test/test-fallback16-surface-source.svg12.argb32.xfail.png +++ /dev/null diff --git a/test/test-fallback16-surface-source.svg12.rgb24.xfail.png b/test/test-fallback16-surface-source.svg12.rgb24.xfail.png Binary files differdeleted file mode 100644 index 6ebcaf9a..00000000 --- a/test/test-fallback16-surface-source.svg12.rgb24.xfail.png +++ /dev/null diff --git a/test/zero-mask.c b/test/zero-mask.c index 29edd0a5..3d2f34d0 100644 --- a/test/zero-mask.c +++ b/test/zero-mask.c @@ -92,7 +92,7 @@ mask_with_alpha_surface (cairo_t *cr) cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REFLECT); cairo_mask (cr, pattern); - + cairo_pattern_destroy (pattern); cairo_surface_destroy (surface); } @@ -106,7 +106,7 @@ mask_with_nonclear_surface (cairo_t *cr) 16, 8, 4); cairo_mask_surface (cr, surface, 0, 0); - + cairo_surface_destroy (surface); } @@ -175,7 +175,7 @@ draw (cairo_t *cr, int width, int height) for (op = 0; op < ARRAY_LENGTH (operators); op++) { cairo_set_operator (cr, operators[op]); - + for (i = 0; i < ARRAY_LENGTH (mask_funcs); i++) { cairo_save (cr); cairo_translate (cr, i * (RECT + SPACE), op * (RECT + SPACE)); diff --git a/util/cairo-script/cairo-script-interpreter.c b/util/cairo-script/cairo-script-interpreter.c index a5c81255..bdd52554 100644 --- a/util/cairo-script/cairo-script-interpreter.c +++ b/util/cairo-script/cairo-script-interpreter.c @@ -396,6 +396,7 @@ _csi_init (csi_t *ctx) ctx->status = CSI_STATUS_SUCCESS; ctx->ref_count = 1; + ctx->scanner.line_number = -1; status = _csi_hash_table_init (&ctx->strings, _intern_string_equal); if (status) diff --git a/util/cairo-script/cairo-script-operators.c b/util/cairo-script/cairo-script-operators.c index 36dbbb90..ad1a2015 100644 --- a/util/cairo-script/cairo-script-operators.c +++ b/util/cairo-script/cairo-script-operators.c @@ -3630,8 +3630,7 @@ _map_to_image (csi_t *ctx) csi_object_t obj; csi_array_t *array; csi_status_t status; - cairo_rectangle_t extents; - cairo_rectangle_t *r; + cairo_rectangle_int_t extents, *r; cairo_surface_t *surface; check (2); @@ -3647,11 +3646,12 @@ _map_to_image (csi_t *ctx) switch (array->stack.len) { case 0: r = NULL; + break; case 4: - extents.x = _csi_object_as_real (&array->stack.objects[0]); - extents.y = _csi_object_as_real (&array->stack.objects[1]); - extents.width = _csi_object_as_real (&array->stack.objects[2]); - extents.height = _csi_object_as_real (&array->stack.objects[3]); + extents.x = floor (_csi_object_as_real (&array->stack.objects[0])); + extents.y = floor (_csi_object_as_real (&array->stack.objects[1])); + extents.width = ceil (_csi_object_as_real (&array->stack.objects[2])); + extents.height = ceil (_csi_object_as_real (&array->stack.objects[3])); r = &extents; break; default: diff --git a/util/cairo-trace/trace.c b/util/cairo-trace/trace.c index a6de76f1..65f8fbac 100644 --- a/util/cairo-trace/trace.c +++ b/util/cairo-trace/trace.c @@ -3625,7 +3625,7 @@ cairo_surface_create_similar_image (cairo_surface_t *other, cairo_surface_t * cairo_surface_map_to_image (cairo_surface_t *surface, - const cairo_rectangle_t *extents) + const cairo_rectangle_int_t *extents) { cairo_surface_t *ret; @@ -3638,18 +3638,14 @@ cairo_surface_map_to_image (cairo_surface_t *surface, Object *obj = _create_surface (ret); if (extents) { - _trace_printf ("[ %f %f %f %f ] map-to-image dup /s%ld exch def\n", + _trace_printf ("[%d %d %d %d] map-to-image\n", extents->x, extents->y, - extents->width, - extents->height, - obj->token); - obj->width = extents->width; + extents->width, extents->height); + obj->width = extents->width; obj->height = extents->height; } else { - _trace_printf ("[ ] map-to-image dup /s%ld exch def\n", - obj->token); + _trace_printf ("[ ] map-to-image\n"); } - obj->defined = TRUE; _push_object (obj); _write_unlock (); } @@ -3669,6 +3665,7 @@ cairo_surface_unmap_image (cairo_surface_t *surface, _trace_printf ("/s%ld /s%ld unmap-image\n", _get_surface_id (surface), _get_surface_id (image)); + _consume_operand (); _write_unlock (); } @@ -4892,24 +4889,52 @@ cairo_script_surface_create_for_target (cairo_device_t *device, #endif #if CAIRO_HAS_TEST_SURFACES -#include <test-fallback-surface.h> +#include <test-paginated-surface.h> +cairo_surface_t * +_cairo_test_paginated_surface_create (cairo_surface_t *surface) +{ + cairo_surface_t *ret; + + _enter_trace (); + + ret = DLCALL (_cairo_test_paginated_surface_create, surface); + + _emit_line_info (); + if (_write_lock ()) { + Object *obj = _create_surface (ret); + + /* XXX store initial data? */ + _trace_printf ("dict\n" + " /type /test-paginated set\n" + " /target s%ld set\n" + " surface dup /s%ld exch def\n", + _get_surface_id (surface), + obj->token); + _push_object (obj); + _write_unlock (); + } + + _exit_trace (); + return ret; +} + +#include <test-compositor-surface.h> + cairo_surface_t * -_cairo_test_fallback_surface_create (cairo_content_t content, - int width, - int height) +_cairo_test_fallback_compositor_surface_create (cairo_content_t content, int width, int height) { cairo_surface_t *ret; _enter_trace (); - ret = DLCALL (_cairo_test_fallback_surface_create, content, width, height); + ret = DLCALL (_cairo_test_fallback_compositor_surface_create, content, width, height); _emit_line_info (); if (_write_lock ()) { Object *obj = _create_surface (ret); _trace_printf ("dict\n" - " /type /test-fallback set\n" + " /type /test-fallback-compositor set\n" " /content //%s set\n" " /width %d set\n" " /height %d set\n" @@ -4917,8 +4942,6 @@ _cairo_test_fallback_surface_create (cairo_content_t content, _content_to_string (content), width, height, obj->token); - obj->width = width; - obj->height = height; obj->defined = TRUE; _push_object (obj); _write_unlock (); @@ -4928,27 +4951,29 @@ _cairo_test_fallback_surface_create (cairo_content_t content, return ret; } -#include <test-paginated-surface.h> cairo_surface_t * -_cairo_test_paginated_surface_create (cairo_surface_t *surface) +_cairo_test_mask_compositor_surface_create (cairo_content_t content, int width, int height) { cairo_surface_t *ret; _enter_trace (); - ret = DLCALL (_cairo_test_paginated_surface_create, surface); + ret = DLCALL (_cairo_test_mask_compositor_surface_create, content, width, height); _emit_line_info (); if (_write_lock ()) { Object *obj = _create_surface (ret); - /* XXX store initial data? */ _trace_printf ("dict\n" - " /type /test-paginated set\n" - " /target s%ld set\n" + " /type /test-mask-compositor set\n" + " /content //%s set\n" + " /width %d set\n" + " /height %d set\n" " surface dup /s%ld exch def\n", - _get_surface_id (surface), + _content_to_string (content), + width, height, obj->token); + obj->defined = TRUE; _push_object (obj); _write_unlock (); } @@ -4957,26 +4982,58 @@ _cairo_test_paginated_surface_create (cairo_surface_t *surface) return ret; } +cairo_surface_t * +_cairo_test_spans_compositor_surface_create (cairo_content_t content, int width, int height) +{ + cairo_surface_t *ret; + + _enter_trace (); + + ret = DLCALL (_cairo_test_spans_compositor_surface_create, content, width, height); + + _emit_line_info (); + if (_write_lock ()) { + Object *obj = _create_surface (ret); + + _trace_printf ("dict\n" + " /type /test-spans-compositor set\n" + " /content //%s set\n" + " /width %d set\n" + " /height %d set\n" + " surface dup /s%ld exch def\n", + _content_to_string (content), + width, height, + obj->token); + obj->defined = TRUE; + _push_object (obj); + _write_unlock (); + } + + _exit_trace (); + return ret; +} -#include <test-null-surface.h> cairo_surface_t * -_cairo_test_null_surface_create (cairo_content_t content) +_cairo_test_traps_compositor_surface_create (cairo_content_t content, int width, int height) { cairo_surface_t *ret; _enter_trace (); - ret = DLCALL (_cairo_test_null_surface_create, content); + ret = DLCALL (_cairo_test_traps_compositor_surface_create, content, width, height); _emit_line_info (); if (_write_lock ()) { Object *obj = _create_surface (ret); _trace_printf ("dict\n" - " /type /test-null set\n" + " /type /test-traps-compositor set\n" " /content //%s set\n" + " /width %d set\n" + " /height %d set\n" " surface dup /s%ld exch def\n", _content_to_string (content), + width, height, obj->token); obj->defined = TRUE; _push_object (obj); @@ -4986,6 +5043,7 @@ _cairo_test_null_surface_create (cairo_content_t content) _exit_trace (); return ret; } + #endif cairo_surface_t * diff --git a/util/show-polygon.c b/util/show-polygon.c index 9571363b..fc1444db 100644 --- a/util/show-polygon.c +++ b/util/show-polygon.c @@ -49,6 +49,8 @@ typedef struct _PolygonViewClass { G_DEFINE_TYPE (PolygonView, polygon_view, GTK_TYPE_WIDGET) +double highlight = -1; + static void draw_edges (cairo_t *cr, polygon_t *p, gdouble sf, int dir) { int n; @@ -59,8 +61,8 @@ static void draw_edges (cairo_t *cr, polygon_t *p, gdouble sf, int dir) if (e->dir != dir) continue; - cairo_arc (cr, e->p1.x, e->p1.y, 3/sf, 0, 2*M_PI); - cairo_arc (cr, e->p2.x, e->p2.y, 3/sf, 0, 2*M_PI); + cairo_arc (cr, e->p1.x, e->p1.y, 2/sf, 0, 2*M_PI); + cairo_arc (cr, e->p2.x, e->p2.y, 2/sf, 0, 2*M_PI); cairo_fill (cr); } @@ -140,6 +142,17 @@ pixmap_create (PolygonView *self, cairo_surface_t *target) draw_polygon (cr, polygon, sf); } + + if (highlight != -1) { + cairo_move_to (cr, extents.p1.x, highlight); + cairo_line_to (cr, extents.p2.x, highlight); + cairo_set_source_rgb (cr, 0, .7, 0); + cairo_save (cr); + cairo_identity_matrix (cr); + cairo_set_line_width (cr, 1.); + cairo_stroke (cr); + cairo_restore (cr); + } } cairo_restore (cr); cairo_destroy (cr); @@ -228,6 +241,17 @@ polygon_view_draw (PolygonView *self, cairo_t *cr) draw_polygon (cr, polygon, zoom); } + + if (highlight != -1) { + cairo_move_to (cr, extents.p1.x, highlight); + cairo_line_to (cr, extents.p2.x, highlight); + cairo_set_source_rgb (cr, 0, .7, 0); + cairo_save (cr); + cairo_identity_matrix (cr); + cairo_set_line_width (cr, 1.); + cairo_stroke (cr); + cairo_restore (cr); + } } cairo_restore (cr); /* grid */ @@ -563,6 +587,9 @@ main (int argc, char **argv) fclose (file); } + if (argc > 2) + highlight = atof (argv[2]); + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "delete-event", G_CALLBACK (gtk_main_quit), NULL); |
