The Tor Browser / file revision

 # 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;