1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/gfx/cairo/win32-raster.patch Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,262 @@
1.4 +changeset: 29338:f2a10f325734
1.5 +tag: qtip
1.6 +tag: tip
1.7 +tag: win32-raster-mask2.patch
1.8 +tag: qbase
1.9 +user: Jeff Muizelaar <jmuizelaar@mozilla.com>
1.10 +date: Mon Jun 22 14:26:07 2009 -0400
1.11 +summary: imported patch win32-raster-mask2.patch
1.12 +
1.13 +diff --git a/gfx/cairo/cairo/src/cairo-image-surface.c b/gfx/cairo/cairo/src/cairo-image-surface.c
1.14 +--- a/gfx/cairo/cairo/src/cairo-image-surface.c
1.15 ++++ b/gfx/cairo/cairo/src/cairo-image-surface.c
1.16 +@@ -1232,27 +1232,27 @@ typedef struct _cairo_image_surface_span
1.17 + cairo_composite_rectangles_t composite_rectangles;
1.18 + } cairo_image_surface_span_renderer_t;
1.19 +
1.20 +-static cairo_status_t
1.21 +-_cairo_image_surface_span_renderer_render_row (
1.22 +- void *abstract_renderer,
1.23 ++void
1.24 ++_cairo_image_surface_span_render_row (
1.25 + int y,
1.26 + const cairo_half_open_span_t *spans,
1.27 +- unsigned num_spans)
1.28 ++ unsigned num_spans,
1.29 ++ cairo_image_surface_t *mask,
1.30 ++ const cairo_composite_rectangles_t *rects)
1.31 + {
1.32 +- cairo_image_surface_span_renderer_t *renderer = abstract_renderer;
1.33 +- int xmin = renderer->composite_rectangles.mask.x;
1.34 +- int xmax = xmin + renderer->composite_rectangles.width;
1.35 ++ int xmin = rects->mask.x;
1.36 ++ int xmax = xmin + rects->width;
1.37 + uint8_t *row;
1.38 + int prev_x = xmin;
1.39 + int prev_alpha = 0;
1.40 + unsigned i;
1.41 +
1.42 + /* Make sure we're within y-range. */
1.43 +- y -= renderer->composite_rectangles.mask.y;
1.44 +- if (y < 0 || y >= renderer->composite_rectangles.height)
1.45 ++ y -= rects->mask.y;
1.46 ++ if (y < 0 || y >= rects->height)
1.47 + return CAIRO_STATUS_SUCCESS;
1.48 +
1.49 +- row = (uint8_t*)(renderer->mask->data) + y*(size_t)renderer->mask->stride - xmin;
1.50 ++ row = (uint8_t*)(mask->data) + y*(size_t)mask->stride - xmin;
1.51 +
1.52 + /* Find the first span within x-range. */
1.53 + for (i=0; i < num_spans && spans[i].x < xmin; i++) {}
1.54 +@@ -1286,7 +1286,17 @@ _cairo_image_surface_span_renderer_rende
1.55 + if (prev_alpha != 0 && prev_x < xmax) {
1.56 + memset(row + prev_x, prev_alpha, xmax - prev_x);
1.57 + }
1.58 ++}
1.59 +
1.60 ++static cairo_status_t
1.61 ++_cairo_image_surface_span_renderer_render_row (
1.62 ++ void *abstract_renderer,
1.63 ++ int y,
1.64 ++ const cairo_half_open_span_t *spans,
1.65 ++ unsigned num_spans)
1.66 ++{
1.67 ++ cairo_image_surface_span_renderer_t *renderer = abstract_renderer;
1.68 ++ _cairo_image_surface_span_render_row (y, spans, num_spans, renderer->mask, &renderer->composite_rectangles);
1.69 + return CAIRO_STATUS_SUCCESS;
1.70 + }
1.71 +
1.72 +diff --git a/gfx/cairo/cairo/src/cairo-tor-scan-converter.c b/gfx/cairo/cairo/src/cairo-tor-scan-converter.c
1.73 +--- a/gfx/cairo/cairo/src/cairo-tor-scan-converter.c
1.74 ++++ b/gfx/cairo/cairo/src/cairo-tor-scan-converter.c
1.75 +@@ -295,9 +295,9 @@ typedef int grid_area_t;
1.76 + #elif GRID_XY == 15
1.77 + # define GRID_AREA_TO_ALPHA(c) (((c) << 4) + (c))
1.78 + #elif GRID_XY == 2*256*15
1.79 +-# define GRID_AREA_TO_ALPHA(c) (((c) + ((c)<<4)) >> 9)
1.80 ++# define GRID_AREA_TO_ALPHA(c) (((c) + ((c)<<4) + 256) >> 9)
1.81 + #else
1.82 +-# define GRID_AREA_TO_ALPHA(c) ((c)*255 / GRID_XY) /* tweak me for rounding */
1.83 ++# define GRID_AREA_TO_ALPHA(c) (((c)*255 + GRID_XY/2) / GRID_XY)
1.84 + #endif
1.85 +
1.86 + #define UNROLL3(x) x x x
1.87 +diff --git a/gfx/cairo/cairo/src/cairo-win32-surface.c b/gfx/cairo/cairo/src/cairo-win32-surface.c
1.88 +--- a/gfx/cairo/cairo/src/cairo-win32-surface.c
1.89 ++++ b/gfx/cairo/cairo/src/cairo-win32-surface.c
1.90 +@@ -2048,6 +2048,148 @@ _cairo_win32_surface_reset (void *abstra
1.91 + return CAIRO_STATUS_SUCCESS;
1.92 + }
1.93 +
1.94 ++typedef struct _cairo_win32_surface_span_renderer {
1.95 ++ cairo_span_renderer_t base;
1.96 ++
1.97 ++ cairo_operator_t op;
1.98 ++ const cairo_pattern_t *pattern;
1.99 ++ cairo_antialias_t antialias;
1.100 ++
1.101 ++ cairo_image_surface_t *mask;
1.102 ++ cairo_win32_surface_t *dst;
1.103 ++
1.104 ++ cairo_composite_rectangles_t composite_rectangles;
1.105 ++} cairo_win32_surface_span_renderer_t;
1.106 ++
1.107 ++static cairo_status_t
1.108 ++_cairo_win32_surface_span_renderer_render_row (
1.109 ++ void *abstract_renderer,
1.110 ++ int y,
1.111 ++ const cairo_half_open_span_t *spans,
1.112 ++ unsigned num_spans)
1.113 ++{
1.114 ++ cairo_win32_surface_span_renderer_t *renderer = abstract_renderer;
1.115 ++ _cairo_image_surface_span_render_row (y, spans, num_spans, renderer->mask, &renderer->composite_rectangles);
1.116 ++ return CAIRO_STATUS_SUCCESS;
1.117 ++}
1.118 ++
1.119 ++static void
1.120 ++_cairo_win32_surface_span_renderer_destroy (void *abstract_renderer)
1.121 ++{
1.122 ++ cairo_win32_surface_span_renderer_t *renderer = abstract_renderer;
1.123 ++ if (!renderer) return;
1.124 ++
1.125 ++ if (renderer->mask != NULL)
1.126 ++ cairo_surface_destroy (&renderer->mask->base);
1.127 ++
1.128 ++ free (renderer);
1.129 ++}
1.130 ++
1.131 ++static cairo_status_t
1.132 ++_cairo_win32_surface_span_renderer_finish (void *abstract_renderer)
1.133 ++{
1.134 ++ cairo_win32_surface_span_renderer_t *renderer = abstract_renderer;
1.135 ++ cairo_status_t status = CAIRO_STATUS_SUCCESS;
1.136 ++
1.137 ++ if (renderer->pattern == NULL || renderer->mask == NULL)
1.138 ++ return CAIRO_STATUS_SUCCESS;
1.139 ++
1.140 ++ status = cairo_surface_status (&renderer->mask->base);
1.141 ++ if (status == CAIRO_STATUS_SUCCESS) {
1.142 ++ cairo_composite_rectangles_t *rects = &renderer->composite_rectangles;
1.143 ++ cairo_win32_surface_t *dst = renderer->dst;
1.144 ++ cairo_pattern_t *mask_pattern = cairo_pattern_create_for_surface (&renderer->mask->base);
1.145 ++ /* composite onto the image surface directly if we can */
1.146 ++ if (dst->image) {
1.147 ++ GdiFlush();
1.148 ++
1.149 ++ status = dst->image->backend->composite (renderer->op,
1.150 ++ renderer->pattern, mask_pattern, dst->image,
1.151 ++ rects->src.x,
1.152 ++ rects->src.y,
1.153 ++ 0, 0, /* mask.x, mask.y */
1.154 ++ rects->dst.x, rects->dst.y,
1.155 ++ rects->width, rects->height);
1.156 ++ } else {
1.157 ++ /* otherwise go through the fallback_composite path which
1.158 ++ * will do the appropriate surface acquisition */
1.159 ++ status = _cairo_surface_fallback_composite (
1.160 ++ renderer->op,
1.161 ++ renderer->pattern, mask_pattern, dst,
1.162 ++ rects->src.x,
1.163 ++ rects->src.y,
1.164 ++ 0, 0, /* mask.x, mask.y */
1.165 ++ rects->dst.x, rects->dst.y,
1.166 ++ rects->width, rects->height);
1.167 ++ }
1.168 ++ cairo_pattern_destroy (mask_pattern);
1.169 ++
1.170 ++ }
1.171 ++ if (status != CAIRO_STATUS_SUCCESS)
1.172 ++ return _cairo_span_renderer_set_error (abstract_renderer,
1.173 ++ status);
1.174 ++ return CAIRO_STATUS_SUCCESS;
1.175 ++}
1.176 ++
1.177 ++static cairo_bool_t
1.178 ++_cairo_win32_surface_check_span_renderer (cairo_operator_t op,
1.179 ++ const cairo_pattern_t *pattern,
1.180 ++ void *abstract_dst,
1.181 ++ cairo_antialias_t antialias,
1.182 ++ const cairo_composite_rectangles_t *rects)
1.183 ++{
1.184 ++ (void) op;
1.185 ++ (void) pattern;
1.186 ++ (void) abstract_dst;
1.187 ++ (void) antialias;
1.188 ++ (void) rects;
1.189 ++ return TRUE;
1.190 ++}
1.191 ++
1.192 ++static cairo_span_renderer_t *
1.193 ++_cairo_win32_surface_create_span_renderer (cairo_operator_t op,
1.194 ++ const cairo_pattern_t *pattern,
1.195 ++ void *abstract_dst,
1.196 ++ cairo_antialias_t antialias,
1.197 ++ const cairo_composite_rectangles_t *rects)
1.198 ++{
1.199 ++ cairo_win32_surface_t *dst = abstract_dst;
1.200 ++ cairo_win32_surface_span_renderer_t *renderer
1.201 ++ = calloc(1, sizeof(*renderer));
1.202 ++ cairo_status_t status;
1.203 ++ int width = rects->width;
1.204 ++ int height = rects->height;
1.205 ++
1.206 ++ if (renderer == NULL)
1.207 ++ return _cairo_span_renderer_create_in_error (CAIRO_STATUS_NO_MEMORY);
1.208 ++
1.209 ++ renderer->base.destroy = _cairo_win32_surface_span_renderer_destroy;
1.210 ++ renderer->base.finish = _cairo_win32_surface_span_renderer_finish;
1.211 ++ renderer->base.render_row =
1.212 ++ _cairo_win32_surface_span_renderer_render_row;
1.213 ++ renderer->op = op;
1.214 ++ renderer->pattern = pattern;
1.215 ++ renderer->antialias = antialias;
1.216 ++ renderer->dst = dst;
1.217 ++
1.218 ++ renderer->composite_rectangles = *rects;
1.219 ++
1.220 ++ /* TODO: support rendering to A1 surfaces (or: go add span
1.221 ++ * compositing to pixman.) */
1.222 ++ renderer->mask = (cairo_image_surface_t *)
1.223 ++ cairo_image_surface_create (CAIRO_FORMAT_A8,
1.224 ++ width, height);
1.225 ++
1.226 ++ status = cairo_surface_status (&renderer->mask->base);
1.227 ++
1.228 ++ if (status != CAIRO_STATUS_SUCCESS) {
1.229 ++ _cairo_win32_surface_span_renderer_destroy (renderer);
1.230 ++ return _cairo_span_renderer_create_in_error (status);
1.231 ++ }
1.232 ++ return &renderer->base;
1.233 ++}
1.234 ++
1.235 ++
1.236 + static const cairo_surface_backend_t cairo_win32_surface_backend = {
1.237 + CAIRO_SURFACE_TYPE_WIN32,
1.238 + _cairo_win32_surface_create_similar,
1.239 +@@ -2060,8 +2202,8 @@ static const cairo_surface_backend_t cai
1.240 + _cairo_win32_surface_composite,
1.241 + _cairo_win32_surface_fill_rectangles,
1.242 + NULL, /* composite_trapezoids */
1.243 +- NULL, /* create_span_renderer */
1.244 +- NULL, /* check_span_renderer */
1.245 ++ _cairo_win32_surface_create_span_renderer,
1.246 ++ _cairo_win32_surface_check_span_renderer,
1.247 + NULL, /* copy_page */
1.248 + NULL, /* show_page */
1.249 + _cairo_win32_surface_set_clip_region,
1.250 +diff --git a/gfx/cairo/cairo/src/cairoint.h b/gfx/cairo/cairo/src/cairoint.h
1.251 +--- a/gfx/cairo/cairo/src/cairoint.h
1.252 ++++ b/gfx/cairo/cairo/src/cairoint.h
1.253 +@@ -2193,6 +2193,12 @@ _cairo_image_surface_set_clip_region (vo
1.254 + cairo_private cairo_image_surface_t *
1.255 + _cairo_image_surface_coerce (cairo_image_surface_t *surface,
1.256 + cairo_format_t format);
1.257 ++cairo_private void
1.258 ++_cairo_image_surface_span_render_row (int y,
1.259 ++ const cairo_half_open_span_t *spans,
1.260 ++ unsigned num_spans,
1.261 ++ cairo_image_surface_t *mask,
1.262 ++ const cairo_composite_rectangles_t *rects);
1.263 +
1.264 + cairo_private cairo_image_transparency_t
1.265 + _cairo_image_analyze_transparency (cairo_image_surface_t *image);
