diff --git a/src/cairo-gl-surface.c b/src/cairo-gl-surface.c index 2acc8b5..019249e 100644 --- a/src/cairo-gl-surface.c +++ b/src/cairo-gl-surface.c @@ -2012,13 +2012,14 @@ typedef struct _cairo_gl_surface_span_renderer { cairo_gl_composite_setup_t setup; + int xmin, xmax; + cairo_operator_t op; cairo_antialias_t antialias; cairo_gl_surface_t *dst; cairo_region_t *clip; - cairo_composite_rectangles_t composite_rectangles; GLuint vbo; void *vbo_base; unsigned int vbo_size; @@ -2049,11 +2050,11 @@ _cairo_gl_span_renderer_flush (cairo_gl_surface_span_renderer_t *renderer) cairo_region_get_rectangle (renderer->clip, i, &rect); glScissor (rect.x, rect.y, rect.width, rect.height); - glDrawArrays (GL_LINES, 0, count); + glDrawArrays (GL_QUADS, 0, count); } glDisable (GL_SCISSOR_TEST); } else { - glDrawArrays (GL_LINES, 0, count); + glDrawArrays (GL_QUADS, 0, count); } } @@ -2134,72 +2135,87 @@ _cairo_gl_emit_span_vertex (cairo_gl_surface_span_renderer_t *renderer, static void _cairo_gl_emit_span (cairo_gl_surface_span_renderer_t *renderer, - int x1, int x2, int y, uint8_t alpha) + int x, int y1, int y2, + uint8_t alpha) { float *vertices = _cairo_gl_span_renderer_get_vbo (renderer, 2); - _cairo_gl_emit_span_vertex (renderer, x1, y, alpha, vertices); - _cairo_gl_emit_span_vertex (renderer, x2, y, alpha, + _cairo_gl_emit_span_vertex (renderer, x, y1, alpha, vertices); + _cairo_gl_emit_span_vertex (renderer, x, y2, alpha, vertices + renderer->vertex_size / 4); } -/* Emits the contents of the span renderer rows as GL_LINES with the span's - * alpha. - * - * Unlike the image surface, which is compositing into a temporary, we emit - * coverage even for alpha == 0, in case we're using an unbounded operator. - * But it means we avoid having to do the fixup. - */ +static void +_cairo_gl_emit_rectangle (cairo_gl_surface_span_renderer_t *renderer, + int x1, int y1, + int x2, int y2, + int coverage) +{ + _cairo_gl_emit_span (renderer, x1, y1, y2, coverage); + _cairo_gl_emit_span (renderer, x2, y2, y1, coverage); +} + static cairo_status_t -_cairo_gl_surface_span_renderer_render_row ( - void *abstract_renderer, - int y, - const cairo_half_open_span_t *spans, - unsigned num_spans) +_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; - int xmin = renderer->composite_rectangles.mask.x; - int xmax = xmin + renderer->composite_rectangles.width; - int prev_x = xmin; - int prev_alpha = 0; - unsigned i; - int x_translate; - - /* Make sure we're within y-range. */ - if (y < renderer->composite_rectangles.mask.y || - y >= renderer->composite_rectangles.mask.y + - renderer->composite_rectangles.height) + + if (num_spans == 0) return CAIRO_STATUS_SUCCESS; - x_translate = renderer->composite_rectangles.dst.x - - renderer->composite_rectangles.mask.x; - y += renderer->composite_rectangles.dst.y - - renderer->composite_rectangles.mask.y; + do { + if (spans[0].coverage) { + _cairo_gl_emit_rectangle (renderer, + spans[0].x, y, + spans[1].x, y + height, + spans[0].coverage); + } - /* Find the first span within x-range. */ - for (i=0; i < num_spans && spans[i].x < xmin; i++) {} - if (i>0) - prev_alpha = spans[i-1].coverage; + spans++; + } while (--num_spans > 1); - /* Set the intermediate spans. */ - for (; i < num_spans; i++) { - int x = spans[i].x; + return CAIRO_STATUS_SUCCESS; +} - if (x >= xmax) - break; +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; - _cairo_gl_emit_span (renderer, - prev_x + x_translate, x + x_translate, y, - prev_alpha); + if (num_spans == 0) { + _cairo_gl_emit_rectangle (renderer, + renderer->xmin, y, + renderer->xmax, y + height, + 0); + return CAIRO_STATUS_SUCCESS; + } - prev_x = x; - prev_alpha = spans[i].coverage; + if (spans[0].x != renderer->xmin) { + _cairo_gl_emit_rectangle (renderer, + renderer->xmin, y, + spans[0].x, y + height, + 0); } - if (prev_x < xmax) { - _cairo_gl_emit_span (renderer, - prev_x + x_translate, xmax + x_translate, y, - prev_alpha); + do { + _cairo_gl_emit_rectangle (renderer, + 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_emit_rectangle (renderer, + spans[0].x, y, + renderer->xmax, y + height, + 0); } return CAIRO_STATUS_SUCCESS; @@ -2274,8 +2290,6 @@ _cairo_gl_surface_create_span_renderer (cairo_operator_t op, cairo_gl_surface_t *dst = abstract_dst; cairo_gl_surface_span_renderer_t *renderer; cairo_status_t status; - int width = rects->width; - int height = rects->height; cairo_surface_attributes_t *src_attributes; GLenum err; diff --git a/src/cairo-image-surface.c b/src/cairo-image-surface.c index 48d8013..d52979d 100644 --- a/src/cairo-image-surface.c +++ b/src/cairo-image-surface.c @@ -1390,11 +1390,13 @@ typedef struct _cairo_image_surface_span_renderer { const cairo_pattern_t *pattern; cairo_antialias_t antialias; + uint8_t *mask_data; + uint32_t mask_stride; + cairo_image_surface_t *src; cairo_surface_attributes_t src_attributes; cairo_image_surface_t *mask; cairo_image_surface_t *dst; - cairo_composite_rectangles_t composite_rectangles; } cairo_image_surface_span_renderer_t; @@ -1403,66 +1405,46 @@ _cairo_image_surface_span_render_row ( int y, const cairo_half_open_span_t *spans, unsigned num_spans, - cairo_image_surface_t *mask, - const cairo_composite_rectangles_t *rects) + uint8_t *data, + uint32_t stride) { - int xmin = rects->mask.x; - int xmax = xmin + rects->width; uint8_t *row; - int prev_x = xmin; - int prev_alpha = 0; unsigned i; - /* Make sure we're within y-range. */ - y -= rects->mask.y; - if (y < 0 || y >= rects->height) + if (num_spans == 0) return; - row = (uint8_t*)(mask->data) + y*(size_t)mask->stride - xmin; - - /* Find the first span within x-range. */ - for (i=0; i < num_spans && spans[i].x < xmin; i++) {} - if (i>0) - prev_alpha = spans[i-1].coverage; - - /* Set the intermediate spans. */ - for (; i < num_spans; i++) { - int x = spans[i].x; - - if (x >= xmax) - break; - - if (prev_alpha != 0) { - /* 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 (x == prev_x + 1) { - row[prev_x] = prev_alpha; - } - else { - memset(row + prev_x, prev_alpha, x - prev_x); - } + 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); } - - prev_x = x; - prev_alpha = spans[i].coverage; - } - - if (prev_alpha != 0 && prev_x < xmax) { - memset(row + prev_x, prev_alpha, xmax - prev_x); } } static cairo_status_t -_cairo_image_surface_span_renderer_render_row ( +_cairo_image_surface_span_renderer_render_rows ( 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; - _cairo_image_surface_span_render_row (y, spans, num_spans, renderer->mask, &renderer->composite_rectangles); + while (height--) + _cairo_image_surface_span_render_row (y++, spans, num_spans, renderer->mask_data, renderer->mask_stride); return CAIRO_STATUS_SUCCESS; } @@ -1517,11 +1499,11 @@ _cairo_image_surface_span_renderer_finish (void *abstract_renderer) &dst->base, src_attributes, src->width, src->height, - rects->width, rects->height, + width, height, rects->src.x, rects->src.y, 0, 0, /* mask.x, mask.y */ rects->dst.x, rects->dst.y, - rects->width, rects->height, + width, height, dst->clip_region); } } @@ -1567,7 +1549,7 @@ _cairo_image_surface_create_span_renderer (cairo_operator_t op, renderer->base.destroy = _cairo_image_surface_span_renderer_destroy; renderer->base.finish = _cairo_image_surface_span_renderer_finish; - renderer->base.render_row = _cairo_image_surface_span_renderer_render_row; + renderer->base.render_rows = _cairo_image_surface_span_renderer_render_rows; renderer->op = op; renderer->pattern = pattern; renderer->antialias = antialias; @@ -1604,6 +1586,9 @@ _cairo_image_surface_create_span_renderer (cairo_operator_t op, _cairo_image_surface_span_renderer_destroy (renderer); return _cairo_span_renderer_create_in_error (status); } + + renderer->mask_data = renderer->mask->data - rects->mask.x - rects->mask.y * renderer->mask->stride; + renderer->mask_stride = renderer->mask->stride; return &renderer->base; } diff --git a/src/cairo-spans-private.h b/src/cairo-spans-private.h index e29a567..af3b38c 100644 --- a/src/cairo-spans-private.h +++ b/src/cairo-spans-private.h @@ -47,26 +47,24 @@ typedef struct _cairo_half_open_span { * surfaces if they want to composite spans instead of trapezoids. */ typedef struct _cairo_span_renderer cairo_span_renderer_t; struct _cairo_span_renderer { + /* Private status variable. */ + cairo_status_t status; + /* Called to destroy the renderer. */ cairo_destroy_func_t destroy; - /* Render the spans on row y of the source by whatever compositing - * method is required. The function should ignore spans outside - * the bounding box set by the init() function. */ - cairo_status_t (*render_row)( - void *abstract_renderer, - int y, - const cairo_half_open_span_t *coverages, - unsigned num_coverages); + /* Render the spans on row y of the destination by whatever compositing + * method is required. */ + cairo_warn cairo_status_t + (*render_rows) (void *abstract_renderer, + int y, int height, + const cairo_half_open_span_t *coverages, + unsigned num_coverages); /* Called after all rows have been rendered to perform whatever * final rendering step is required. This function is called just * once before the renderer is destroyed. */ - cairo_status_t (*finish)( - void *abstract_renderer); - - /* Private status variable. */ - cairo_status_t status; + cairo_status_t (*finish) (void *abstract_renderer); }; /* Scan converter interface. */ diff --git a/src/cairo-spans.c b/src/cairo-spans.c index af3b85f..69894c1 100644 --- a/src/cairo-spans.c +++ b/src/cairo-spans.c @@ -275,13 +275,15 @@ _cairo_scan_converter_create_in_error (cairo_status_t status) } static cairo_status_t -_cairo_nil_span_renderer_render_row ( +_cairo_nil_span_renderer_render_rows ( void *abstract_renderer, int y, + int height, const cairo_half_open_span_t *coverages, unsigned num_coverages) { (void) y; + (void) height; (void) coverages; (void) num_coverages; return _cairo_span_renderer_status (abstract_renderer); @@ -310,7 +312,7 @@ _cairo_span_renderer_set_error ( ASSERT_NOT_REACHED; } if (renderer->status == CAIRO_STATUS_SUCCESS) { - renderer->render_row = _cairo_nil_span_renderer_render_row; + renderer->render_rows = _cairo_nil_span_renderer_render_rows; renderer->finish = _cairo_nil_span_renderer_finish; renderer->status = error; } diff --git a/src/cairo-tor-scan-converter.c b/src/cairo-tor-scan-converter.c index 29262c2..2b9fb1b 100644 --- a/src/cairo-tor-scan-converter.c +++ b/src/cairo-tor-scan-converter.c @@ -128,27 +128,29 @@ blit_with_span_renderer( cairo_span_renderer_t *span_renderer, struct pool *span_pool, int y, + int height, int xmin, int xmax); static glitter_status_t -blit_empty_with_span_renderer (cairo_span_renderer_t *renderer, int y); +blit_empty_with_span_renderer (cairo_span_renderer_t *renderer, int y, int height); #define GLITTER_BLIT_COVERAGES_ARGS \ cairo_span_renderer_t *span_renderer, \ struct pool *span_pool -#define GLITTER_BLIT_COVERAGES(cells, y, xmin, xmax) do { \ +#define GLITTER_BLIT_COVERAGES(cells, y, height,xmin, xmax) do { \ cairo_status_t status = blit_with_span_renderer (cells, \ span_renderer, \ span_pool, \ - y, xmin, xmax); \ + y, height, \ + xmin, xmax); \ if (unlikely (status)) \ return status; \ } while (0) -#define GLITTER_BLIT_COVERAGES_EMPTY(y, xmin, xmax) do { \ - cairo_status_t status = blit_empty_with_span_renderer (span_renderer, y); \ +#define GLITTER_BLIT_COVERAGES_EMPTY(y, height, xmin, xmax) do { \ + cairo_status_t status = blit_empty_with_span_renderer (span_renderer, y, height); \ if (unlikely (status)) \ return status; \ } while (0) @@ -309,8 +311,8 @@ typedef int grid_area_t; #define UNROLL3(x) x x x struct quorem { - int quo; - int rem; + int32_t quo; + int32_t rem; }; /* Header for a chunk of memory in a memory pool. */ @@ -382,6 +384,7 @@ struct edge { /* Original sign of the edge: +1 for downwards, -1 for upwards * edges. */ int dir; + int vertical; }; /* Number of subsample rows per y-bucket. Must be GRID_Y. */ @@ -389,18 +392,28 @@ struct edge { #define EDGE_Y_BUCKET_INDEX(y, ymin) (((y) - (ymin))/EDGE_Y_BUCKET_HEIGHT) +struct bucket { + /* Unsorted list of edges starting within this bucket. */ + struct edge *edges; + + /* Set to non-zero if there are edges starting strictly within the + * bucket. */ + unsigned have_inside_edges; +}; + /* 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. */ + /* The clip extents. */ + grid_scaled_x_t xmin, xmax; 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 bucket *y_buckets; + struct bucket y_buckets_embedded[64]; struct { struct pool base[1]; @@ -702,7 +715,6 @@ static void cell_list_fini(struct cell_list *cells) { pool_fini (cells->cell_pool.base); - cell_list_init (cells); } /* Empty the cell list. This is called at the start of every pixel @@ -715,6 +727,26 @@ cell_list_reset (struct cell_list *cells) pool_reset (cells->cell_pool.base); } +static struct cell * +cell_list_alloc (struct cell_list *cells, + struct cell **cursor, + struct cell *tail, + int x) +{ + struct cell *cell; + + cell = pool_alloc (cells->cell_pool.base, sizeof (struct cell)); + if (unlikely (NULL == cell)) + return NULL; + + *cursor = cell; + cell->next = tail; + cell->x = x; + cell->uncovered_area = 0; + cell->covered_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 @@ -737,22 +769,10 @@ cell_list_find (struct cell_list *cells, int x) } cells->cursor = cursor; - if (tail->x == x) { + if (tail->x == x) return tail; - } else { - struct cell *cell; - - cell = pool_alloc (cells->cell_pool.base, sizeof (struct cell)); - if (unlikely (NULL == cell)) - return NULL; - *cursor = cell; - cell->next = tail; - cell->x = x; - cell->uncovered_area = 0; - cell->covered_height = 0; - return cell; - } + return cell_list_alloc (cells, cursor, tail, x); } /* Find two cells at x1 and x2. This is exactly equivalent @@ -832,9 +852,8 @@ cell_list_find_pair(struct cell_list *cells, int x1, int x2) /* Add an unbounded subpixel span covering subpixels >= x to the * coverage cells. */ static glitter_status_t -cell_list_add_unbounded_subspan( - struct cell_list *cells, - grid_scaled_x_t x) +cell_list_add_unbounded_subspan (struct cell_list *cells, + grid_scaled_x_t x) { struct cell *cell; int ix, fx; @@ -907,20 +926,24 @@ cell_list_render_edge( struct edge *edge, int sign) { - struct quorem x1 = edge->x; - struct quorem x2 = x1; grid_scaled_y_t y1, y2, dy; grid_scaled_x_t dx; int ix1, ix2; grid_scaled_x_t fx1, fx2; - x2.quo += edge->dxdy_full.quo; - x2.rem += edge->dxdy_full.rem; - if (x2.rem >= 0) { - ++x2.quo; - x2.rem -= edge->dy; + 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; } - edge->x = x2; GRID_X_TO_INT_FRAC(x1.quo, ix1, fx1); GRID_X_TO_INT_FRAC(x2.quo, ix2, fx2); @@ -1026,6 +1049,7 @@ static void polygon_init (struct polygon *polygon) { polygon->ymin = polygon->ymax = 0; + polygon->xmin = polygon->xmax = 0; polygon->y_buckets = polygon->y_buckets_embedded; pool_init (polygon->edge_pool.base, 8192 - sizeof (struct _pool_chunk), @@ -1045,10 +1069,11 @@ polygon_fini (struct polygon *polygon) * 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) +polygon_reset (struct polygon *polygon, + grid_scaled_x_t xmin, + grid_scaled_x_t xmax, + 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, @@ -1065,14 +1090,16 @@ polygon_reset( 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 *)); + sizeof (struct bucket)); if (unlikely (NULL == polygon->y_buckets)) goto bail_no_mem; } - memset (polygon->y_buckets, 0, num_buckets * sizeof (struct edge *)); + memset (polygon->y_buckets, 0, num_buckets * sizeof (struct bucket)); polygon->ymin = ymin; polygon->ymax = ymax; + polygon->xmin = xmin; + polygon->xmax = xmax; return GLITTER_STATUS_SUCCESS; bail_no_mem: @@ -1086,10 +1113,13 @@ _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]; + unsigned j = e->ytop - polygon->ymin; + unsigned ix = j / EDGE_Y_BUCKET_HEIGHT; + unsigned offset = j % EDGE_Y_BUCKET_HEIGHT; + struct edge **ptail = &polygon->y_buckets[ix].edges; e->next = *ptail; *ptail = e; + polygon->y_buckets[ix].have_inside_edges |= offset; } inline static glitter_status_t @@ -1115,30 +1145,53 @@ polygon_add_edge (struct polygon *polygon, dx = edge->line.p2.x - edge->line.p1.x; dy = edge->line.p2.y - edge->line.p1.y; e->dy = dy; - e->dxdy = floored_divrem (dx, dy); - - if (ymin <= edge->top) - ytop = edge->top; - else - ytop = ymin; - 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; - } - e->dir = edge->dir; + + ytop = edge->top >= ymin ? edge->top : ymin; + ybot = edge->bottom <= ymax ? edge->bottom : ymax; e->ytop = ytop; - ybot = edge->bottom < ymax ? edge->bottom : ymax; e->height_left = ybot - ytop; - if (e->height_left >= GRID_Y) { - e->dxdy_full = floored_muldivrem (GRID_Y, dx, dy); - } else { + 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; + + /* Drop edges to the right of the clip extents. */ + if (e->x.quo >= polygon->xmax) + return GLITTER_STATUS_SUCCESS; + + /* Offset vertical edges at the left side of the clip extents + * to just shy of the left side. We depend on this when + * checking for possible intersections within the clip + * rectangle. */ + if (e->x.quo <= polygon->xmin) { + e->x.quo = polygon->xmin - 1; + } + } 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->x.quo >= polygon->xmax && e->dxdy.quo >= 0) + return GLITTER_STATUS_SUCCESS; + + 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); @@ -1161,31 +1214,30 @@ active_list_init(struct active_list *active) active_list_reset(active); } -static void -active_list_fini( - struct active_list *active) -{ - active_list_reset(active); -} - /* Merge the edges in an unsorted list of edges into a sorted * list. The sort order is edges ascending by edge->x.quo. Returns * the new head of the sorted list. */ static struct edge * merge_unsorted_edges(struct edge *sorted_head, struct edge *unsorted_head) { - struct edge *head = unsorted_head; struct edge **cursor = &sorted_head; int x; - while (NULL != head) { + if (sorted_head == NULL) { + sorted_head = unsorted_head; + unsorted_head = unsorted_head->next; + sorted_head->next = NULL; + if (unsorted_head == NULL) + return sorted_head; + } + + do { + struct edge *next = unsorted_head->next; struct edge *prev = *cursor; - struct edge *next = head->next; - x = head->x.quo; - if (NULL == prev || x < prev->x.quo) { + x = unsorted_head->x.quo; + if (x < prev->x.quo) cursor = &sorted_head; - } while (1) { UNROLL3({ @@ -1196,26 +1248,29 @@ merge_unsorted_edges(struct edge *sorted_head, struct edge *unsorted_head) }); } - head->next = *cursor; - *cursor = head; + unsorted_head->next = *cursor; + *cursor = unsorted_head; + unsorted_head = next; + } while (unsorted_head != NULL); - head = next; - } return sorted_head; } /* 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) +active_list_can_step_full_row (struct active_list *active, + grid_scaled_x_t xmin) { + const struct edge *e; + grid_scaled_x_t 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) { - struct edge *e = active->head; int min_height = INT_MAX; + e = active->head; while (NULL != e) { if (e->height_left < min_height) min_height = e->height_left; @@ -1225,27 +1280,38 @@ active_list_can_step_full_row( active->min_height = min_height; } - /* Check for intersections only if no edges end during the next - * row. */ - if (active->min_height >= GRID_Y) { - grid_scaled_x_t prev_x = INT_MIN; - struct edge *e = active->head; - while (NULL != e) { - struct quorem x = e->x; + 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) + /* There's may be an intersection if the edge sort order might + * change. */ + if (x.quo <= prev_x) { + /* Ignore intersections to the left of the clip extents. + * This assumes that all vertical edges on or at the left + * side of the clip rectangle have been shifted slightly + * to the left in polygon_add_edge(). */ + if (prev_x >= xmin || x.quo >= xmin || e->x.quo >= xmin) return 0; + } + else { prev_x = x.quo; - e = e->next; } - return 1; + e = e->next; } - return 0; + + return 1; } /* Merges edges on the given subpixel row from the polygon to the @@ -1261,7 +1327,7 @@ active_list_merge_edges_from_polygon( unsigned ix = EDGE_Y_BUCKET_INDEX(y, polygon->ymin); int min_height = active->min_height; struct edge *subrow_edges = NULL; - struct edge **ptail = &polygon->y_buckets[ix]; + struct edge **ptail = &polygon->y_buckets[ix].edges; while (1) { struct edge *tail = *ptail; @@ -1277,8 +1343,10 @@ active_list_merge_edges_from_polygon( ptail = &tail->next; } } - active->head = merge_unsorted_edges(active->head, subrow_edges); - active->min_height = min_height; + if (subrow_edges) { + active->head = merge_unsorted_edges(active->head, subrow_edges); + active->min_height = min_height; + } } /* Advance the edges on the active list by one subsample row by @@ -1439,11 +1507,13 @@ apply_nonzero_fill_rule_and_step_edges (struct active_list *active, } } - 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; + 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; + } } } @@ -1472,6 +1542,7 @@ apply_evenodd_fill_rule_and_step_edges (struct active_list *active, 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) @@ -1490,17 +1561,22 @@ apply_evenodd_fill_rule_and_step_edges (struct active_list *active, else *cursor = right_edge->next; + winding += right_edge->dir; + if ((winding & 1) == 0) { if (right_edge->next == NULL || right_edge->next->x.quo != right_edge->x.quo) { break; } + } - 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; + 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; + } } } @@ -1537,8 +1613,14 @@ blit_span( } } -#define GLITTER_BLIT_COVERAGES(coverages, y, xmin, xmax) \ - blit_cells(coverages, raster_pixels + (y)*raster_stride, xmin, xmax) +#define GLITTER_BLIT_COVERAGES(coverages, y, height, xmin, xmax) \ + do { \ + int __y = y; \ + int __h = height; \ + do { \ + blit_cells(coverages, raster_pixels + (__y)*raster_stride, xmin, xmax); \ + } while (--__h); \ + } while (0) static void blit_cells( @@ -1597,7 +1679,6 @@ static void _glitter_scan_converter_fini(glitter_scan_converter_t *converter) { polygon_fini(converter->polygon); - active_list_fini(converter->active); cell_list_fini(converter->coverages); converter->xmin=0; converter->ymin=0; @@ -1641,7 +1722,7 @@ glitter_scan_converter_reset( active_list_reset(converter->active); cell_list_reset(converter->coverages); - status = polygon_reset(converter->polygon, ymin, ymax); + status = polygon_reset(converter->polygon, xmin, xmax, ymin, ymax); if (status) return status; @@ -1711,19 +1792,48 @@ glitter_scan_converter_add_edge (glitter_scan_converter_t *converter, #endif #ifndef GLITTER_BLIT_COVERAGES_EMPTY -# define GLITTER_BLIT_COVERAGES_EMPTY(y, xmin, xmax) +# define GLITTER_BLIT_COVERAGES_EMPTY(y0, y1, xmin, xmax) #endif +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; + } +} + I glitter_status_t glitter_scan_converter_render( glitter_scan_converter_t *converter, int nonzero_fill, GLITTER_BLIT_COVERAGES_ARGS) { - int i; + int i, j; int ymax_i = converter->ymax / GRID_Y; int ymin_i = converter->ymin / GRID_Y; int xmin_i, xmax_i; + grid_scaled_x_t xmin = converter->xmin; int h = ymax_i - ymin_i; struct polygon *polygon = converter->polygon; struct cell_list *coverages = converter->coverages; @@ -1738,22 +1848,28 @@ glitter_scan_converter_render( GLITTER_BLIT_COVERAGES_BEGIN; /* Render each pixel row. */ - for (i=0; iy_buckets[i]) { + if (polygon->y_buckets[i].edges == NULL) { if (! active->head) { - GLITTER_BLIT_COVERAGES_EMPTY (i+ymin_i, xmin_i, xmax_i); + for (; j < h && ! polygon->y_buckets[j].edges; j++) + ; + GLITTER_BLIT_COVERAGES_EMPTY (i+ymin_i, j-i, xmin_i, xmax_i); continue; } - - do_full_step = active_list_can_step_full_row (active); + do_full_step = active_list_can_step_full_row (active, xmin); + } + else if (! polygon->y_buckets[i].have_inside_edges) { + grid_scaled_y_t y = (i+ymin_i)*GRID_Y; + active_list_merge_edges_from_polygon (active, y, polygon); + do_full_step = active_list_can_step_full_row (active, xmin); } - - cell_list_reset (coverages); if (do_full_step) { /* Step by a full pixel row's worth. */ @@ -1764,8 +1880,20 @@ glitter_scan_converter_render( status = apply_evenodd_fill_rule_and_step_edges (active, coverages); } + + if (active_list_is_vertical (active)) { + while (j < h && + polygon->y_buckets[j].edges == NULL && + active->min_height >= 2*GRID_Y) + { + active->min_height -= GRID_Y; + j++; + } + if (j != i + 1) + step_edges (active, j - (i + 1)); + } } else { - /* Subsample this row. */ + /* Supersample this row. */ grid_scaled_y_t suby; for (suby = 0; suby < GRID_Y; suby++) { grid_scaled_y_t y = (i+ymin_i)*GRID_Y + suby; @@ -1787,13 +1915,13 @@ glitter_scan_converter_render( if (unlikely (status)) return status; - GLITTER_BLIT_COVERAGES(coverages, i+ymin_i, xmin_i, xmax_i); + GLITTER_BLIT_COVERAGES(coverages, i+ymin_i, j-i, xmin_i, xmax_i); + cell_list_reset (coverages); - if (! active->head) { + if (! active->head) active->min_height = INT_MAX; - } else { + else active->min_height -= GRID_Y; - } } /* Clean up the coverage blitter. */ @@ -1807,21 +1935,20 @@ glitter_scan_converter_render( * scan converter subclass. */ static glitter_status_t -blit_with_span_renderer( - struct cell_list *cells, - cairo_span_renderer_t *renderer, - struct pool *span_pool, - int y, - int xmin, - int xmax) +blit_with_span_renderer (struct cell_list *cells, + cairo_span_renderer_t *renderer, + struct pool *span_pool, + int y, int height, + int xmin, int xmax) { struct cell *cell = cells->head; int prev_x = xmin; int cover = 0; cairo_half_open_span_t *spans; unsigned num_spans; + if (cell == NULL) - return CAIRO_STATUS_SUCCESS; + return blit_empty_with_span_renderer (renderer, y, height); /* Skip cells to the left of the clip region. */ while (cell != NULL && cell->x < xmin) { @@ -1833,12 +1960,12 @@ blit_with_span_renderer( /* Count number of cells remaining. */ { struct cell *next = cell; - num_spans = 0; - while (next) { + num_spans = 1; + while (next != NULL) { next = next->next; ++num_spans; } - num_spans = 2*num_spans + 1; + num_spans = 2*num_spans; } /* Allocate enough spans for the row. */ @@ -1853,6 +1980,7 @@ blit_with_span_renderer( for (; cell != NULL; cell = cell->next) { int x = cell->x; int area; + if (x >= xmax) break; @@ -1872,20 +2000,26 @@ blit_with_span_renderer( prev_x = x+1; } - if (prev_x < xmax) { + if (prev_x <= xmax) { spans[num_spans].x = prev_x; spans[num_spans].coverage = GRID_AREA_TO_ALPHA (cover); ++num_spans; } + if (prev_x < xmax && cover) { + spans[num_spans].x = xmax; + spans[num_spans].coverage = 0; + ++num_spans; + } + /* Dump them into the renderer. */ - return renderer->render_row (renderer, y, spans, num_spans); + return renderer->render_rows (renderer, y, height, spans, num_spans); } static glitter_status_t -blit_empty_with_span_renderer (cairo_span_renderer_t *renderer, int y) +blit_empty_with_span_renderer (cairo_span_renderer_t *renderer, int y, int height) { - return renderer->render_row (renderer, y, NULL, 0); + return renderer->render_rows (renderer, y, height, NULL, 0); } struct _cairo_tor_scan_converter { diff --git a/src/cairo-win32-surface.c b/src/cairo-win32-surface.c index 82d1cf5..d4575a3 100644 --- a/src/cairo-win32-surface.c +++ b/src/cairo-win32-surface.c @@ -1954,6 +1954,9 @@ typedef struct _cairo_win32_surface_span_renderer { const cairo_pattern_t *pattern; cairo_antialias_t antialias; + uint8_t *mask_data; + uint32_t mask_stride; + cairo_image_surface_t *mask; cairo_win32_surface_t *dst; cairo_region_t *clip_region; @@ -1962,14 +1965,16 @@ typedef struct _cairo_win32_surface_span_renderer { } cairo_win32_surface_span_renderer_t; static cairo_status_t -_cairo_win32_surface_span_renderer_render_row ( +_cairo_win32_surface_span_renderer_render_rows ( void *abstract_renderer, int y, + int height, const cairo_half_open_span_t *spans, unsigned num_spans) { cairo_win32_surface_span_renderer_t *renderer = abstract_renderer; - _cairo_image_surface_span_render_row (y, spans, num_spans, renderer->mask, &renderer->composite_rectangles); + while (height--) + _cairo_image_surface_span_render_row (y++, spans, num_spans, renderer->mask_data, renderer->mask_stride); return CAIRO_STATUS_SUCCESS; } @@ -2066,8 +2071,7 @@ _cairo_win32_surface_create_span_renderer (cairo_operator_t op, renderer->base.destroy = _cairo_win32_surface_span_renderer_destroy; renderer->base.finish = _cairo_win32_surface_span_renderer_finish; - renderer->base.render_row = - _cairo_win32_surface_span_renderer_render_row; + renderer->base.render_rows = _cairo_win32_surface_span_renderer_render_rows; renderer->op = op; renderer->pattern = pattern; renderer->antialias = antialias; @@ -2088,6 +2092,9 @@ _cairo_win32_surface_create_span_renderer (cairo_operator_t op, _cairo_win32_surface_span_renderer_destroy (renderer); return _cairo_span_renderer_create_in_error (status); } + + renderer->mask_data = renderer->mask->data - rects->mask.x - rects->mask.y * renderer->mask->stride; + renderer->mask_stride = renderer->mask->stride; return &renderer->base; } diff --git a/src/cairo-xlib-display.c b/src/cairo-xlib-display.c index a7a40b8..566d9fb 100644 --- a/src/cairo-xlib-display.c +++ b/src/cairo-xlib-display.c @@ -407,6 +407,10 @@ _cairo_xlib_display_get (Display *dpy, display->buggy_pad_reflect = TRUE; } + /* gradients don't seem to work */ + display->buggy_gradients = TRUE; + + /* XXX workaround; see https://bugzilla.mozilla.org/show_bug.cgi?id=413583 */ /* If buggy_repeat_force == -1, then initialize. * - set to -2, meaning "nothing was specified", and we trust the above detection. diff --git a/src/cairoint.h b/src/cairoint.h index 58850ab..1cdf6ff 100644 --- a/src/cairoint.h +++ b/src/cairoint.h @@ -2257,8 +2257,8 @@ cairo_private void _cairo_image_surface_span_render_row (int y, const cairo_half_open_span_t *spans, unsigned num_spans, - cairo_image_surface_t *mask, - const cairo_composite_rectangles_t *rects); + uint8_t *data, + uint32_t stride); cairo_private cairo_image_transparency_t _cairo_image_analyze_transparency (cairo_image_surface_t *image);