diff options
Diffstat (limited to 'gfx/cairo/quartz-minimize-gradient-repeat.patch')
| -rw-r--r-- | gfx/cairo/quartz-minimize-gradient-repeat.patch | 561 |
1 files changed, 561 insertions, 0 deletions
diff --git a/gfx/cairo/quartz-minimize-gradient-repeat.patch b/gfx/cairo/quartz-minimize-gradient-repeat.patch new file mode 100644 index 000000000..9782bef11 --- /dev/null +++ b/gfx/cairo/quartz-minimize-gradient-repeat.patch @@ -0,0 +1,561 @@ +# HG changeset patch +# User Robert O'Callahan <robert@ocallahan.org> +# Date 1249558989 -43200 +# Node ID 0bac4c903d2bb1d5c0d5426209001fc2a77cc105 +# Parent 963b9451ad305924738d05d997a640698cd3af91 +Bug 508730. Don't repeat a Quartz gradient more times than necessary, to avoid Quartz quality problems when there are lots of repeated color stops. r=jmuizelaar + +diff --git a/gfx/cairo/cairo/src/cairo-quartz-surface.c b/gfx/cairo/cairo/src/cairo-quartz-surface.c +--- a/gfx/cairo/cairo/src/cairo-quartz-surface.c ++++ b/gfx/cairo/cairo/src/cairo-quartz-surface.c +@@ -710,82 +710,100 @@ CreateGradientFunction (const cairo_grad + return CGFunctionCreate (pat, + 1, + input_value_range, + 4, + gradient_output_value_ranges, + &gradient_callbacks); + } + ++static void ++UpdateLinearParametersToIncludePoint(double *min_t, double *max_t, CGPoint *start, ++ double dx, double dy, ++ double x, double y) ++{ ++ /* Compute a parameter t such that a line perpendicular to the (dx,dy) ++ vector, passing through (start->x + dx*t, start->y + dy*t), also ++ passes through (x,y). ++ ++ Let px = x - start->x, py = y - start->y. ++ t is given by ++ (px - dx*t)*dx + (py - dy*t)*dy = 0 ++ ++ Solving for t we get ++ numerator = dx*px + dy*py ++ denominator = dx^2 + dy^2 ++ t = numerator/denominator ++ ++ In CreateRepeatingLinearGradientFunction we know the length of (dx,dy) ++ is not zero. (This is checked in _cairo_quartz_setup_linear_source.) ++ */ ++ double px = x - start->x; ++ double py = y - start->y; ++ double numerator = dx*px + dy*py; ++ double denominator = dx*dx + dy*dy; ++ double t = numerator/denominator; ++ ++ if (*min_t > t) { ++ *min_t = t; ++ } ++ if (*max_t < t) { ++ *max_t = t; ++ } ++} ++ + static CGFunctionRef + CreateRepeatingLinearGradientFunction (cairo_quartz_surface_t *surface, + const cairo_gradient_pattern_t *gpat, + CGPoint *start, CGPoint *end, +- CGAffineTransform matrix) ++ cairo_rectangle_int_t *extents) + { + cairo_pattern_t *pat; + float input_value_range[2]; ++ double t_min = 0.; ++ double t_max = 0.; ++ double dx = end->x - start->x; ++ double dy = end->y - start->y; ++ double bounds_x1, bounds_x2, bounds_y1, bounds_y2; + +- CGPoint mstart, mend; ++ if (!extents) { ++ extents = &surface->extents; ++ } ++ bounds_x1 = extents->x; ++ bounds_y1 = extents->y; ++ bounds_x2 = extents->x + extents->width; ++ bounds_y2 = extents->y + extents->height; ++ _cairo_matrix_transform_bounding_box (&gpat->base.matrix, ++ &bounds_x1, &bounds_y1, ++ &bounds_x2, &bounds_y2, ++ NULL); + +- double dx, dy; +- int x_rep_start = 0, x_rep_end = 0; +- int y_rep_start = 0, y_rep_end = 0; ++ UpdateLinearParametersToIncludePoint(&t_min, &t_max, start, dx, dy, ++ bounds_x1, bounds_y1); ++ UpdateLinearParametersToIncludePoint(&t_min, &t_max, start, dx, dy, ++ bounds_x2, bounds_y1); ++ UpdateLinearParametersToIncludePoint(&t_min, &t_max, start, dx, dy, ++ bounds_x2, bounds_y2); ++ UpdateLinearParametersToIncludePoint(&t_min, &t_max, start, dx, dy, ++ bounds_x1, bounds_y2); + +- int rep_start, rep_end; +- +- // figure out how many times we'd need to repeat the gradient pattern +- // to cover the whole (transformed) surface area +- mstart = CGPointApplyAffineTransform (*start, matrix); +- mend = CGPointApplyAffineTransform (*end, matrix); +- +- dx = fabs (mend.x - mstart.x); +- dy = fabs (mend.y - mstart.y); +- +- if (dx > 1e-6) { +- x_rep_start = (int) ceil(MIN(mstart.x, mend.x) / dx); +- x_rep_end = (int) ceil((surface->extents.width - MAX(mstart.x, mend.x)) / dx); +- +- if (mend.x < mstart.x) { +- int swap = x_rep_end; +- x_rep_end = x_rep_start; +- x_rep_start = swap; +- } +- } +- +- if (dy > 1e-6) { +- y_rep_start = (int) ceil(MIN(mstart.y, mend.y) / dy); +- y_rep_end = (int) ceil((surface->extents.width - MAX(mstart.y, mend.y)) / dy); +- +- if (mend.y < mstart.y) { +- int swap = y_rep_end; +- y_rep_end = y_rep_start; +- y_rep_start = swap; +- } +- } +- +- rep_start = MAX(x_rep_start, y_rep_start); +- rep_end = MAX(x_rep_end, y_rep_end); +- +- // extend the line between start and end by rep_start times from the start +- // and rep_end times from the end +- +- dx = end->x - start->x; +- dy = end->y - start->y; +- +- start->x = start->x - dx * rep_start; +- start->y = start->y - dy * rep_start; +- +- end->x = end->x + dx * rep_end; +- end->y = end->y + dy * rep_end; ++ /* Move t_min and t_max to the nearest usable integer to try to avoid ++ subtle variations due to numerical instability, especially accidentally ++ cutting off a pixel. Extending the gradient repetitions is always safe. */ ++ t_min = floor (t_min); ++ t_max = ceil (t_max); ++ end->x = start->x + dx*t_max; ++ end->y = start->y + dy*t_max; ++ start->x = start->x + dx*t_min; ++ start->y = start->y + dy*t_min; + + // set the input range for the function -- the function knows how to + // map values outside of 0.0 .. 1.0 to that range for REPEAT/REFLECT. +- input_value_range[0] = 0.0 - 1.0 * rep_start; +- input_value_range[1] = 1.0 + 1.0 * rep_end; ++ input_value_range[0] = t_min; ++ input_value_range[1] = t_max; + + if (_cairo_pattern_create_copy (&pat, &gpat->base)) + /* quartz doesn't deal very well with malloc failing, so there's + * not much point in us trying either */ + return NULL; + + return CGFunctionCreate (pat, + 1, +@@ -840,35 +858,43 @@ UpdateRadialParameterToIncludePoint(doub + } + } + + /* This must only be called when one of the circles properly contains the other */ + static CGFunctionRef + CreateRepeatingRadialGradientFunction (cairo_quartz_surface_t *surface, + const cairo_gradient_pattern_t *gpat, + CGPoint *start, double *start_radius, +- CGPoint *end, double *end_radius) ++ CGPoint *end, double *end_radius, ++ cairo_rectangle_int_t *extents) + { +- CGRect clip = CGContextGetClipBoundingBox (surface->cgContext); +- CGAffineTransform transform; + cairo_pattern_t *pat; + float input_value_range[2]; + CGPoint *inner; + double *inner_radius; + CGPoint *outer; + double *outer_radius; + /* minimum and maximum t-parameter values that will make our gradient + cover the clipBox */ + double t_min, t_max, t_temp; + /* outer minus inner */ + double dr, dx, dy; ++ double bounds_x1, bounds_x2, bounds_y1, bounds_y2; + +- _cairo_quartz_cairo_matrix_to_quartz (&gpat->base.matrix, &transform); +- /* clip is in cairo device coordinates; get it into cairo user space */ +- clip = CGRectApplyAffineTransform (clip, transform); ++ if (!extents) { ++ extents = &surface->extents; ++ } ++ bounds_x1 = extents->x; ++ bounds_y1 = extents->y; ++ bounds_x2 = extents->x + extents->width; ++ bounds_y2 = extents->y + extents->height; ++ _cairo_matrix_transform_bounding_box (&gpat->base.matrix, ++ &bounds_x1, &bounds_y1, ++ &bounds_x2, &bounds_y2, ++ NULL); + + if (*start_radius < *end_radius) { + /* end circle contains start circle */ + inner = start; + outer = end; + inner_radius = start_radius; + outer_radius = end_radius; + } else { +@@ -878,36 +904,37 @@ CreateRepeatingRadialGradientFunction (c + inner_radius = end_radius; + outer_radius = start_radius; + } + + dr = *outer_radius - *inner_radius; + dx = outer->x - inner->x; + dy = outer->y - inner->y; + ++ /* We can't round or fudge t_min here, it has to be as accurate as possible. */ + t_min = -(*inner_radius/dr); + inner->x += t_min*dx; + inner->y += t_min*dy; + *inner_radius = 0.; + + t_temp = 0.; + UpdateRadialParameterToIncludePoint(&t_temp, inner, dr, dx, dy, +- clip.origin.x, clip.origin.y); ++ bounds_x1, bounds_y1); + UpdateRadialParameterToIncludePoint(&t_temp, inner, dr, dx, dy, +- clip.origin.x + clip.size.width, clip.origin.y); ++ bounds_x2, bounds_y1); + UpdateRadialParameterToIncludePoint(&t_temp, inner, dr, dx, dy, +- clip.origin.x + clip.size.width, clip.origin.y + clip.size.height); ++ bounds_x2, bounds_y2); + UpdateRadialParameterToIncludePoint(&t_temp, inner, dr, dx, dy, +- clip.origin.x, clip.origin.y + clip.size.height); ++ bounds_x1, bounds_y2); + /* UpdateRadialParameterToIncludePoint assumes t=0 means radius 0. + But for the parameter values we use with Quartz, t_min means radius 0. +- Also, add a small fudge factor to avoid rounding issues. Since the +- circles are alway expanding and containing the earlier circles, this is +- OK. */ +- t_temp += 1e-6; ++ Since the circles are alway expanding and contain the earlier circles, ++ it's safe to extend t_max/t_temp as much as we want, so round t_temp up ++ to the nearest integer. This may help us give stable results. */ ++ t_temp = ceil (t_temp); + t_max = t_min + t_temp; + outer->x = inner->x + t_temp*dx; + outer->y = inner->y + t_temp*dy; + *outer_radius = t_temp*dr; + + /* set the input range for the function -- the function knows how to + map values outside of 0.0 .. 1.0 to that range for REPEAT/REFLECT. */ + if (*start_radius < *end_radius) { +@@ -1218,33 +1245,57 @@ _cairo_quartz_setup_fallback_source (cai + surface->sourceImageRect = CGRectMake (0.0, 0.0, w, h); + surface->sourceImage = img; + surface->sourceImageSurface = fallback; + surface->sourceTransform = CGAffineTransformMakeTranslation (x0, y0); + + return DO_IMAGE; + } + ++/* ++Quartz does not support repeating radients. We handle repeating gradients ++by manually extending the gradient and repeating color stops. We need to ++minimize the number of repetitions since Quartz seems to sample our color ++function across the entire range, even if part of that range is not needed ++for the visible area of the gradient, and it samples with some fixed resolution, ++so if the gradient range is too large it samples with very low resolution and ++the gradient is very coarse. CreateRepeatingLinearGradientFunction and ++CreateRepeatingRadialGradientFunction compute the number of repetitions needed ++based on the extents of the object (the clip region cannot be used here since ++we don't want the rasterization of the entire gradient to depend on the ++clip region). ++*/ + static cairo_quartz_action_t + _cairo_quartz_setup_linear_source (cairo_quartz_surface_t *surface, +- const cairo_linear_pattern_t *lpat) ++ const cairo_linear_pattern_t *lpat, ++ cairo_rectangle_int_t *extents) + { + const cairo_pattern_t *abspat = &lpat->base.base; + cairo_matrix_t mat; + CGPoint start, end; + CGFunctionRef gradFunc; + CGColorSpaceRef rgb; + bool extend = abspat->extend == CAIRO_EXTEND_PAD; + + if (lpat->base.n_stops == 0) { + CGContextSetRGBStrokeColor (surface->cgContext, 0., 0., 0., 0.); + CGContextSetRGBFillColor (surface->cgContext, 0., 0., 0., 0.); + return DO_SOLID; + } + ++ if (lpat->p1.x == lpat->p2.x && ++ lpat->p1.y == lpat->p2.y) { ++ /* Quartz handles cases where the vector has no length very ++ * differently from pixman. ++ * Whatever the correct behaviour is, let's at least have only pixman's ++ * implementation to worry about. ++ */ ++ return _cairo_quartz_setup_fallback_source (surface, abspat); ++ } ++ + mat = abspat->matrix; + cairo_matrix_invert (&mat); + _cairo_quartz_cairo_matrix_to_quartz (&mat, &surface->sourceTransform); + + rgb = CGColorSpaceCreateDeviceRGB(); + + start = CGPointMake (_cairo_fixed_to_double (lpat->p1.x), + _cairo_fixed_to_double (lpat->p1.y)); +@@ -1254,33 +1305,34 @@ _cairo_quartz_setup_linear_source (cairo + if (abspat->extend == CAIRO_EXTEND_NONE || + abspat->extend == CAIRO_EXTEND_PAD) + { + gradFunc = CreateGradientFunction (&lpat->base); + } else { + gradFunc = CreateRepeatingLinearGradientFunction (surface, + &lpat->base, + &start, &end, +- surface->sourceTransform); ++ extents); + } + + surface->sourceShading = CGShadingCreateAxial (rgb, + start, end, + gradFunc, + extend, extend); + + CGColorSpaceRelease(rgb); + CGFunctionRelease(gradFunc); + + return DO_SHADING; + } + + static cairo_quartz_action_t + _cairo_quartz_setup_radial_source (cairo_quartz_surface_t *surface, +- const cairo_radial_pattern_t *rpat) ++ const cairo_radial_pattern_t *rpat, ++ cairo_rectangle_int_t *extents) + { + const cairo_pattern_t *abspat = &rpat->base.base; + cairo_matrix_t mat; + CGPoint start, end; + CGFunctionRef gradFunc; + CGColorSpaceRef rgb; + bool extend = abspat->extend == CAIRO_EXTEND_PAD; + double c1x = _cairo_fixed_to_double (rpat->c1.x); +@@ -1322,17 +1374,18 @@ _cairo_quartz_setup_radial_source (cairo + if (abspat->extend == CAIRO_EXTEND_NONE || + abspat->extend == CAIRO_EXTEND_PAD) + { + gradFunc = CreateGradientFunction (&rpat->base); + } else { + gradFunc = CreateRepeatingRadialGradientFunction (surface, + &rpat->base, + &start, &r1, +- &end, &r2); ++ &end, &r2, ++ extents); + } + + surface->sourceShading = CGShadingCreateRadial (rgb, + start, + r1, + end, + r2, + gradFunc, +@@ -1341,17 +1394,18 @@ _cairo_quartz_setup_radial_source (cairo + CGColorSpaceRelease(rgb); + CGFunctionRelease(gradFunc); + + return DO_SHADING; + } + + static cairo_quartz_action_t + _cairo_quartz_setup_source (cairo_quartz_surface_t *surface, +- const cairo_pattern_t *source) ++ const cairo_pattern_t *source, ++ cairo_rectangle_int_t *extents) + { + assert (!(surface->sourceImage || surface->sourceShading || surface->sourcePattern)); + + surface->oldInterpolationQuality = CGContextGetInterpolationQuality (surface->cgContext); + CGContextSetInterpolationQuality (surface->cgContext, _cairo_quartz_filter_to_quartz (source->filter)); + + if (source->type == CAIRO_PATTERN_TYPE_SOLID) { + cairo_solid_pattern_t *solid = (cairo_solid_pattern_t *) source; +@@ -1367,24 +1421,22 @@ _cairo_quartz_setup_source (cairo_quartz + solid->color.blue, + solid->color.alpha); + + return DO_SOLID; + } + + if (source->type == CAIRO_PATTERN_TYPE_LINEAR) { + const cairo_linear_pattern_t *lpat = (const cairo_linear_pattern_t *)source; +- return _cairo_quartz_setup_linear_source (surface, lpat); +- ++ return _cairo_quartz_setup_linear_source (surface, lpat, extents); + } + + if (source->type == CAIRO_PATTERN_TYPE_RADIAL) { + const cairo_radial_pattern_t *rpat = (const cairo_radial_pattern_t *)source; +- return _cairo_quartz_setup_radial_source (surface, rpat); +- ++ return _cairo_quartz_setup_radial_source (surface, rpat, extents); + } + + if (source->type == CAIRO_PATTERN_TYPE_SURFACE && + (source->extend == CAIRO_EXTEND_NONE || (CGContextDrawTiledImagePtr && source->extend == CAIRO_EXTEND_REPEAT))) + { + const cairo_surface_pattern_t *spat = (const cairo_surface_pattern_t *) source; + cairo_surface_t *pat_surf = spat->surface; + CGImageRef img; +@@ -1852,17 +1904,17 @@ _cairo_quartz_surface_paint (void *abstr + if (IS_EMPTY(surface)) + return CAIRO_STATUS_SUCCESS; + + if (op == CAIRO_OPERATOR_DEST) + return CAIRO_STATUS_SUCCESS; + + CGContextSetCompositeOperation (surface->cgContext, _cairo_quartz_cairo_operator_to_quartz (op)); + +- action = _cairo_quartz_setup_source (surface, source); ++ action = _cairo_quartz_setup_source (surface, source, NULL); + + if (action == DO_SOLID || action == DO_PATTERN) { + CGContextFillRect (surface->cgContext, CGRectMake(surface->extents.x, + surface->extents.y, + surface->extents.width, + surface->extents.height)); + } else if (action == DO_SHADING) { + CGContextSaveGState (surface->cgContext); +@@ -1886,16 +1938,35 @@ _cairo_quartz_surface_paint (void *abstr + } + + _cairo_quartz_teardown_source (surface, source); + + ND((stderr, "-- paint\n")); + return rv; + } + ++static cairo_bool_t ++_cairo_quartz_source_needs_extents (const cairo_pattern_t *source) ++{ ++ /* For repeating gradients we need to manually extend the gradient and ++ repeat stops, since Quartz doesn't support repeating gradients natively. ++ We need to minimze the number of repeated stops, and since rasterization ++ depends on the number of repetitions we use (even if some of the ++ repetitions go beyond the extents of the object or outside the clip ++ region), it's important to use the same number of repetitions when ++ rendering an object no matter what the clip region is. So the ++ computation of the repetition count cannot depended on the clip region, ++ and should only depend on the object extents, so we need to compute ++ the object extents for repeating gradients. */ ++ return (source->type == CAIRO_PATTERN_TYPE_LINEAR || ++ source->type == CAIRO_PATTERN_TYPE_RADIAL) && ++ (source->extend == CAIRO_EXTEND_REPEAT || ++ source->extend == CAIRO_EXTEND_REFLECT); ++} ++ + static cairo_int_status_t + _cairo_quartz_surface_fill (void *abstract_surface, + cairo_operator_t op, + const cairo_pattern_t *source, + cairo_path_fixed_t *path, + cairo_fill_rule_t fill_rule, + double tolerance, + cairo_antialias_t antialias, +@@ -1926,17 +1997,27 @@ _cairo_quartz_surface_fill (void *abstra + return CAIRO_STATUS_SUCCESS; + } + + CGContextSaveGState (surface->cgContext); + + CGContextSetShouldAntialias (surface->cgContext, (antialias != CAIRO_ANTIALIAS_NONE)); + CGContextSetCompositeOperation (surface->cgContext, _cairo_quartz_cairo_operator_to_quartz (op)); + +- action = _cairo_quartz_setup_source (surface, source); ++ if (_cairo_quartz_source_needs_extents (source)) ++ { ++ /* We don't need precise extents since these are only used to ++ compute the number of gradient reptitions needed to cover the ++ object. */ ++ cairo_rectangle_int_t path_extents; ++ _cairo_path_fixed_approximate_fill_extents (path, &path_extents); ++ action = _cairo_quartz_setup_source (surface, source, &path_extents); ++ } else { ++ action = _cairo_quartz_setup_source (surface, source, NULL); ++ } + + CGContextBeginPath (surface->cgContext); + + stroke.cgContext = surface->cgContext; + stroke.ctm_inverse = NULL; + rv = _cairo_quartz_cairo_path_to_quartz_context (path, &stroke); + if (rv) + goto BAIL; +@@ -2059,17 +2140,24 @@ _cairo_quartz_surface_stroke (void *abst + + CGContextSetLineDash (surface->cgContext, style->dash_offset, fdash, max_dashes); + if (fdash != sdash) + free (fdash); + } + + CGContextSetCompositeOperation (surface->cgContext, _cairo_quartz_cairo_operator_to_quartz (op)); + +- action = _cairo_quartz_setup_source (surface, source); ++ if (_cairo_quartz_source_needs_extents (source)) ++ { ++ cairo_rectangle_int_t path_extents; ++ _cairo_path_fixed_approximate_stroke_extents (path, style, ctm, &path_extents); ++ action = _cairo_quartz_setup_source (surface, source, &path_extents); ++ } else { ++ action = _cairo_quartz_setup_source (surface, source, NULL); ++ } + + CGContextBeginPath (surface->cgContext); + + stroke.cgContext = surface->cgContext; + stroke.ctm_inverse = ctm_inverse; + rv = _cairo_quartz_cairo_path_to_quartz_context (path, &stroke); + if (rv) + goto BAIL; +@@ -2180,17 +2268,26 @@ _cairo_quartz_surface_show_glyphs (void + if (op == CAIRO_OPERATOR_DEST) + return CAIRO_STATUS_SUCCESS; + + if (cairo_scaled_font_get_type (scaled_font) != CAIRO_FONT_TYPE_QUARTZ) + return CAIRO_INT_STATUS_UNSUPPORTED; + + CGContextSaveGState (surface->cgContext); + +- action = _cairo_quartz_setup_source (surface, source); ++ if (_cairo_quartz_source_needs_extents (source)) ++ { ++ cairo_rectangle_int_t glyph_extents; ++ _cairo_scaled_font_glyph_device_extents (scaled_font, glyphs, num_glyphs, ++ &glyph_extents); ++ action = _cairo_quartz_setup_source (surface, source, &glyph_extents); ++ } else { ++ action = _cairo_quartz_setup_source (surface, source, NULL); ++ } ++ + if (action == DO_SOLID || action == DO_PATTERN) { + CGContextSetTextDrawingMode (surface->cgContext, kCGTextFill); + } else if (action == DO_IMAGE || action == DO_TILED_IMAGE || action == DO_SHADING) { + CGContextSetTextDrawingMode (surface->cgContext, kCGTextClip); + isClipping = TRUE; + } else { + if (action != DO_NOTHING) + rv = CAIRO_INT_STATUS_UNSUPPORTED; |