src/hb-cairo-utils.cc - third_party/harfbuzz - Git at Google

 /*
  * Copyright © 2022  Red Hat, Inc
  * Copyright © 2021, 2022  Black Foundry
  *
  *  This is part of HarfBuzz, a text shaping library.
  *
  * Permission is hereby granted, without written agreement and without
  * license or royalty fees, to use, copy, modify, and distribute this
  * software and its documentation for any purpose, provided that the
  * above copyright notice and the following two paragraphs appear in
  * all copies of this software.
  *
  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGE.
  *
  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  *
  * Google Author(s): Matthias Clasen
  */

 #include "hb.hh"

 #ifdef HAVE_CAIRO

 #include "hb-cairo-utils.hh"
 #include "hb-paint.hh"

 /* Some routines in this file were ported from BlackRenderer by Black Foundry.
  * Used by permission to relicense to HarfBuzz license.
  *
  * https://github.com/BlackFoundryCom/black-renderer
  */

 #define PREALLOCATED_COLOR_STOPS 16

 typedef struct {
   float r, g, b, a;
 } hb_cairo_color_t;

 static inline cairo_extend_t
 hb_cairo_extend (hb_paint_extend_t extend)
 {
   switch (extend)
     {
     case HB_PAINT_EXTEND_PAD: return CAIRO_EXTEND_PAD;
     case HB_PAINT_EXTEND_REPEAT: return CAIRO_EXTEND_REPEAT;
     case HB_PAINT_EXTEND_REFLECT: return CAIRO_EXTEND_REFLECT;
     default: break;
     }

   return CAIRO_EXTEND_PAD;
 }

 #ifdef CAIRO_HAS_PNG_FUNCTIONS
 typedef struct
 {
   hb_blob_t *blob;
   unsigned int offset;
 } hb_cairo_read_blob_data_t;

 static cairo_status_t
 hb_cairo_read_blob (void *closure,
 		    unsigned char *data,
 		    unsigned int length)
 {
   hb_cairo_read_blob_data_t *r = (hb_cairo_read_blob_data_t *) closure;
   const char *d;
   unsigned int size;

   d = hb_blob_get_data (r->blob, &size);

   if (r->offset + length > size)
     return CAIRO_STATUS_READ_ERROR;

   hb_memcpy (data, d + r->offset, length);
   r->offset += length;

   return CAIRO_STATUS_SUCCESS;
 }
 #endif

 static const cairo_user_data_key_t *_hb_cairo_surface_blob_user_data_key = {0};

 static void
 _hb_cairo_destroy_blob (void *p)
 {
   hb_blob_destroy ((hb_blob_t *) p);
 }

 void
 _hb_cairo_set_source_color (hb_cairo_context_t *c,
 			    hb_bool_t use_foreground,
 			    hb_color_t color)
 {
   cairo_t *cr = c->cr;

   if (use_foreground)
   {
 #ifdef HAVE_CAIRO_USER_SCALED_FONT_GET_FOREGROUND_SOURCE
     double r, g, b, a;
     cairo_pattern_t *foreground = cairo_user_scaled_font_get_foreground_source (c->scaled_font);
     if (cairo_pattern_get_rgba (foreground, &r, &g, &b, &a) == CAIRO_STATUS_SUCCESS)
       cairo_set_source_rgba (cr, r, g, b, a * hb_color_get_alpha (color) / 255.);
     else
 #endif
       cairo_set_source_rgba (cr, 0, 0, 0, hb_color_get_alpha (color) / 255.);
   }
   else
     cairo_set_source_rgba (cr,
 			   hb_color_get_red (color) / 255.,
 			   hb_color_get_green (color) / 255.,
 			   hb_color_get_blue (color) / 255.,
 			   hb_color_get_alpha (color) / 255.);
 }

 hb_bool_t
 _hb_cairo_paint_glyph_image (hb_cairo_context_t *c,
 			     hb_blob_t *blob,
 			     unsigned width,
 			     unsigned height,
 			     hb_tag_t format,
 			     HB_UNUSED float slant_deprecated,
 			     hb_glyph_extents_t *extents)
 {
   cairo_t *cr = c->cr;

   if (!extents) /* SVG currently. */
     return false;

   cairo_surface_t *surface = nullptr;

 #ifdef CAIRO_HAS_PNG_FUNCTIONS
   if (format == HB_PAINT_IMAGE_FORMAT_PNG)
   {
     hb_cairo_read_blob_data_t r;
     r.blob = blob;
     r.offset = 0;
     surface = cairo_image_surface_create_from_png_stream (hb_cairo_read_blob, &r);

     /* For PNG, width,height can be unreliable, as is the case for NotoColorEmoji :(.
      * Just pull them out of the surface. */
     width = cairo_image_surface_get_width (surface);
     height = cairo_image_surface_get_width (surface);
   }
   else
 #endif
   if (format == HB_PAINT_IMAGE_FORMAT_BGRA)
   {
     /* Byte-endian conversion. */
     unsigned data_size = hb_blob_get_length (blob);
     if (data_size < width * height * 4)
       return false;

     unsigned char *data;
 #ifdef __BYTE_ORDER
     if (__BYTE_ORDER == __BIG_ENDIAN)
     {
       data = (unsigned char *) hb_blob_get_data_writable (blob, nullptr);
       if (!data)
         return false;

       unsigned count = width * height * 4;
       for (unsigned i = 0; i < count; i += 4)
       {
         unsigned char b;
 	b = data[i];
 	data[i] = data[i+3];
 	data[i+3] = b;
 	b = data[i+1];
 	data[i+1] = data[i+2];
 	data[i+2] = b;
       }
     }
     else
 #endif
       data = (unsigned char *) hb_blob_get_data (blob, nullptr);

     surface = cairo_image_surface_create_for_data (data,
 						   CAIRO_FORMAT_ARGB32,
 						   width, height,
 						   width * 4);

     cairo_surface_set_user_data (surface,
 				 _hb_cairo_surface_blob_user_data_key,
 				 hb_blob_reference (blob),
 				 _hb_cairo_destroy_blob);
   }

   if (!surface)
     return false;

   cairo_save (cr);
   /* this clip is here to work around recording surface limitations */
   cairo_rectangle (cr,
                    extents->x_bearing,
                    extents->y_bearing,
                    extents->width,
                    extents->height);
   cairo_clip (cr);

   cairo_pattern_t *pattern = cairo_pattern_create_for_surface (surface);
   cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);

   cairo_matrix_t matrix = {(double) width, 0, 0, (double) height, 0, 0};
   cairo_pattern_set_matrix (pattern, &matrix);

   cairo_translate (cr, extents->x_bearing, extents->y_bearing);
   cairo_scale (cr, extents->width, extents->height);
   cairo_set_source (cr, pattern);

   cairo_paint (cr);

   cairo_pattern_destroy (pattern);
   cairo_surface_destroy (surface);

   cairo_restore (cr);

   return true;
 }

 static bool
 _hb_cairo_get_color_stops (hb_cairo_context_t *c,
 			   hb_color_line_t *color_line,
 			   unsigned *count,
 			   hb_color_stop_t **stops)
 {
   unsigned len = hb_color_line_get_color_stops (color_line, 0, nullptr, nullptr);
   bool allocated = false;
   if (unlikely (!len))
     return false;
   if (len > *count)
   {
     *stops = (hb_color_stop_t *) hb_malloc (len * sizeof (hb_color_stop_t));
     if (unlikely (!*stops))
       return false;
     allocated = true;
   }
   hb_color_line_get_color_stops (color_line, 0, &len, *stops);
   if (unlikely (!len))
   {
     if (allocated)
     {
       hb_free (*stops);
       *stops = nullptr;
     }
     return false;
   }
   for (unsigned i = 0; i < len; i++)
     if ((*stops)[i].is_foreground)
     {
 #ifdef HAVE_CAIRO_USER_SCALED_FONT_GET_FOREGROUND_SOURCE
       double r, g, b, a;
       cairo_pattern_t *foreground = cairo_user_scaled_font_get_foreground_source (c->scaled_font);
       if (cairo_pattern_get_rgba (foreground, &r, &g, &b, &a) == CAIRO_STATUS_SUCCESS)
         (*stops)[i].color = HB_COLOR (round (b * 255.), round (g * 255.), round (r * 255.),
                                       round (a * hb_color_get_alpha ((*stops)[i].color)));
       else
 #endif
         (*stops)[i].color = HB_COLOR (0, 0, 0, hb_color_get_alpha ((*stops)[i].color));
     }

   *count = len;
   return true;
 }

 void
 _hb_cairo_paint_linear_gradient (hb_cairo_context_t *c,
 				 hb_color_line_t *color_line,
 				 float x0, float y0,
 				 float x1, float y1,
 				 float x2, float y2)
 {
   cairo_t *cr = c->cr;

   unsigned int len = PREALLOCATED_COLOR_STOPS;
   hb_color_stop_t stops_[PREALLOCATED_COLOR_STOPS];
   hb_color_stop_t *stops = stops_;
   float xx0, yy0, xx1, yy1;
   float xxx0, yyy0, xxx1, yyy1;
   float min, max;
   cairo_pattern_t *pattern;

   if (unlikely (!_hb_cairo_get_color_stops (c, color_line, &len, &stops)))
     return;
   hb_paint_normalize_color_line (stops, len, &min, &max);

   hb_paint_reduce_linear_anchors (x0, y0, x1, y1, x2, y2, &xx0, &yy0, &xx1, &yy1);

   xxx0 = xx0 + min * (xx1 - xx0);
   yyy0 = yy0 + min * (yy1 - yy0);
   xxx1 = xx0 + max * (xx1 - xx0);
   yyy1 = yy0 + max * (yy1 - yy0);

   pattern = cairo_pattern_create_linear ((double) xxx0, (double) yyy0, (double) xxx1, (double) yyy1);
   cairo_pattern_set_extend (pattern, hb_cairo_extend (hb_color_line_get_extend (color_line)));
   for (unsigned int i = 0; i < len; i++)
     {
       double r, g, b, a;
       r = hb_color_get_red (stops[i].color) / 255.;
       g = hb_color_get_green (stops[i].color) / 255.;
       b = hb_color_get_blue (stops[i].color) / 255.;
       a = hb_color_get_alpha (stops[i].color) / 255.;
       cairo_pattern_add_color_stop_rgba (pattern, (double) stops[i].offset, r, g, b, a);
     }

   cairo_set_source (cr, pattern);
   cairo_paint (cr);

   cairo_pattern_destroy (pattern);

   if (stops != stops_)
     hb_free (stops);
 }

 void
 _hb_cairo_paint_radial_gradient (hb_cairo_context_t *c,
 				 hb_color_line_t *color_line,
 				 float x0, float y0, float r0,
 				 float x1, float y1, float r1)
 {
   cairo_t *cr = c->cr;

   unsigned int len = PREALLOCATED_COLOR_STOPS;
   hb_color_stop_t stops_[PREALLOCATED_COLOR_STOPS];
   hb_color_stop_t *stops = stops_;
   float min, max;
   float xx0, yy0, xx1, yy1;
   float rr0, rr1;
   cairo_pattern_t *pattern;

   if (unlikely (!_hb_cairo_get_color_stops (c, color_line, &len, &stops)))
     return;
   hb_paint_normalize_color_line (stops, len, &min, &max);

   xx0 = x0 + min * (x1 - x0);
   yy0 = y0 + min * (y1 - y0);
   xx1 = x0 + max * (x1 - x0);
   yy1 = y0 + max * (y1 - y0);
   rr0 = r0 + min * (r1 - r0);
   rr1 = r0 + max * (r1 - r0);

   pattern = cairo_pattern_create_radial ((double) xx0, (double) yy0, (double) rr0, (double) xx1, (double) yy1, (double) rr1);
   cairo_pattern_set_extend (pattern, hb_cairo_extend (hb_color_line_get_extend (color_line)));

   for (unsigned int i = 0; i < len; i++)
     {
       double r, g, b, a;
       r = hb_color_get_red (stops[i].color) / 255.;
       g = hb_color_get_green (stops[i].color) / 255.;
       b = hb_color_get_blue (stops[i].color) / 255.;
       a = hb_color_get_alpha (stops[i].color) / 255.;
       cairo_pattern_add_color_stop_rgba (pattern, (double) stops[i].offset, r, g, b, a);
     }

   cairo_set_source (cr, pattern);
   cairo_paint (cr);

   cairo_pattern_destroy (pattern);

   if (stops != stops_)
     hb_free (stops);
 }

 typedef struct {
   float x, y;
 } hb_cairo_point_t;

 static inline float
 _hb_cairo_interpolate (float f0, float f1, float f)
 {
   return f0 + f * (f1 - f0);
 }

 static inline void
 _hb_cairo_premultiply (hb_cairo_color_t *c)
 {
   c->r *= c->a;
   c->g *= c->a;
   c->b *= c->a;
 }

 static inline void
 _hb_cairo_unpremultiply (hb_cairo_color_t *c)
 {
   if (c->a != 0.f)
   {
      c->r /= c->a;
      c->g /= c->a;
      c->b /= c->a;
   }
 }

 static void
 _hb_cairo_interpolate_colors (hb_cairo_color_t *c0, hb_cairo_color_t *c1, float k, hb_cairo_color_t *c)
 {
   // According to the COLR specification, gradients
   // should be interpolated in premultiplied form
   _hb_cairo_premultiply (c0);
   _hb_cairo_premultiply (c1);
   c->r = c0->r + k * (c1->r - c0->r);
   c->g = c0->g + k * (c1->g - c0->g);
   c->b = c0->b + k * (c1->b - c0->b);
   c->a = c0->a + k * (c1->a - c0->a);
   _hb_cairo_unpremultiply (c);
 }

 static inline float
 _hb_cairo_dot (hb_cairo_point_t p, hb_cairo_point_t q)
 {
   return p.x * q.x + p.y * q.y;
 }

 static inline hb_cairo_point_t
 _hb_cairo_normalize (hb_cairo_point_t p)
 {
   float len = sqrtf (_hb_cairo_dot (p, p));

   return hb_cairo_point_t { p.x / len, p.y / len };
 }

 static inline hb_cairo_point_t
 _hb_cairo_sum (hb_cairo_point_t p, hb_cairo_point_t q)
 {
   return hb_cairo_point_t { p.x + q.x, p.y + q.y };
 }

 static inline hb_cairo_point_t
 _hb_cairo_difference (hb_cairo_point_t p, hb_cairo_point_t q)
 {
   return hb_cairo_point_t { p.x - q.x, p.y - q.y };
 }

 static inline hb_cairo_point_t
 _hb_cairo_scale (hb_cairo_point_t p, float f)
 {
   return hb_cairo_point_t { p.x * f, p.y * f };
 }

 typedef struct {
   hb_cairo_point_t center, p0, c0, c1, p1;
   hb_cairo_color_t color0, color1;
 } hb_cairo_patch_t;

 static void
 _hb_cairo_add_patch (cairo_pattern_t *pattern, hb_cairo_point_t *center, hb_cairo_patch_t *p)
 {
   cairo_mesh_pattern_begin_patch (pattern);
   cairo_mesh_pattern_move_to (pattern, (double) center->x, (double) center->y);
   cairo_mesh_pattern_line_to (pattern, (double) p->p0.x, (double) p->p0.y);
   cairo_mesh_pattern_curve_to (pattern,
                                (double) p->c0.x, (double) p->c0.y,
                                (double) p->c1.x, (double) p->c1.y,
                                (double) p->p1.x, (double) p->p1.y);
   cairo_mesh_pattern_line_to (pattern, (double) center->x, (double) center->y);
   cairo_mesh_pattern_set_corner_color_rgba (pattern, 0,
                                             (double) p->color0.r,
                                             (double) p->color0.g,
                                             (double) p->color0.b,
                                             (double) p->color0.a);
   cairo_mesh_pattern_set_corner_color_rgba (pattern, 1,
                                             (double) p->color0.r,
                                             (double) p->color0.g,
                                             (double) p->color0.b,
                                             (double) p->color0.a);
   cairo_mesh_pattern_set_corner_color_rgba (pattern, 2,
                                             (double) p->color1.r,
                                             (double) p->color1.g,
                                             (double) p->color1.b,
                                             (double) p->color1.a);
   cairo_mesh_pattern_set_corner_color_rgba (pattern, 3,
                                             (double) p->color1.r,
                                             (double) p->color1.g,
                                             (double) p->color1.b,
                                             (double) p->color1.a);
   cairo_mesh_pattern_end_patch (pattern);
 }

 #define MAX_ANGLE (HB_PI / 8.f)

 static void
 _hb_cairo_add_sweep_gradient_patches1 (float cx, float cy, float radius,
 				       float a0, hb_cairo_color_t *c0,
 				       float a1, hb_cairo_color_t *c1,
 				       cairo_pattern_t *pattern)
 {
   hb_cairo_point_t center = hb_cairo_point_t { cx, cy };
   int num_splits;
   hb_cairo_point_t p0;
   hb_cairo_color_t color0, color1;

   num_splits = ceilf (fabsf (a1 - a0) / MAX_ANGLE);
   p0 = hb_cairo_point_t { cosf (a0), sinf (a0) };
   color0 = *c0;

   for (int a = 0; a < num_splits; a++)
     {
       float k = (a + 1.) / num_splits;
       float angle1;
       hb_cairo_point_t p1;
       hb_cairo_point_t A, U;
       hb_cairo_point_t C0, C1;
       hb_cairo_patch_t patch;

       angle1 = _hb_cairo_interpolate (a0, a1, k);
       _hb_cairo_interpolate_colors (c0, c1, k, &color1);

       patch.color0 = color0;
       patch.color1 = color1;

       p1 = hb_cairo_point_t { cosf (angle1), sinf (angle1) };
       patch.p0 = _hb_cairo_sum (center, _hb_cairo_scale (p0, radius));
       patch.p1 = _hb_cairo_sum (center, _hb_cairo_scale (p1, radius));

       A = _hb_cairo_normalize (_hb_cairo_sum (p0, p1));
       U = hb_cairo_point_t { -A.y, A.x };
       C0 = _hb_cairo_sum (A, _hb_cairo_scale (U, _hb_cairo_dot (_hb_cairo_difference (p0, A), p0) / _hb_cairo_dot (U, p0)));
       C1 = _hb_cairo_sum (A, _hb_cairo_scale (U, _hb_cairo_dot (_hb_cairo_difference (p1, A), p1) / _hb_cairo_dot (U, p1)));

       patch.c0 = _hb_cairo_sum (center, _hb_cairo_scale (_hb_cairo_sum (C0, _hb_cairo_scale (_hb_cairo_difference (C0, p0), 0.33333f)), radius));
       patch.c1 = _hb_cairo_sum (center, _hb_cairo_scale (_hb_cairo_sum (C1, _hb_cairo_scale (_hb_cairo_difference (C1, p1), 0.33333f)), radius));

       _hb_cairo_add_patch (pattern, &center, &patch);

       p0 = p1;
       color0 = color1;
     }
 }

 static inline hb_cairo_color_t
 _hb_cairo_color_from_hb_color (hb_color_t c)
 {
   return {
     hb_color_get_red   (c) / 255.f,
     hb_color_get_green (c) / 255.f,
     hb_color_get_blue  (c) / 255.f,
     hb_color_get_alpha (c) / 255.f,
   };
 }

 struct _hb_cairo_sweep_patch_ctx {
   float cx, cy, radius;
   cairo_pattern_t *pattern;
 };

 static void
 _hb_cairo_sweep_emit_patch (float a0, hb_color_t c0,
 			    float a1, hb_color_t c1,
 			    void *user_data)
 {
   auto *ctx = (_hb_cairo_sweep_patch_ctx *) user_data;
   hb_cairo_color_t cc0 = _hb_cairo_color_from_hb_color (c0);
   hb_cairo_color_t cc1 = _hb_cairo_color_from_hb_color (c1);
   _hb_cairo_add_sweep_gradient_patches1 (ctx->cx, ctx->cy, ctx->radius,
 					 a0, &cc0, a1, &cc1,
 					 ctx->pattern);
 }

 static void
 _hb_cairo_add_sweep_gradient_patches (hb_color_stop_t *stops,
 				      unsigned int n_stops,
 				      cairo_extend_t extend,
 				      float cx, float cy,
 				      float radius,
 				      float start_angle,
 				      float end_angle,
 				      cairo_pattern_t *pattern)
 {
   hb_paint_extend_t hb_extend =
     extend == CAIRO_EXTEND_REPEAT  ? HB_PAINT_EXTEND_REPEAT  :
     extend == CAIRO_EXTEND_REFLECT ? HB_PAINT_EXTEND_REFLECT :
 				     HB_PAINT_EXTEND_PAD;

   _hb_cairo_sweep_patch_ctx ctx { cx, cy, radius, pattern };
   hb_paint_sweep_gradient_tiles (stops, n_stops, hb_extend,
 				 start_angle, end_angle,
 				 _hb_cairo_sweep_emit_patch, &ctx);
 }

 void
 _hb_cairo_paint_sweep_gradient (hb_cairo_context_t *c,
 				hb_color_line_t *color_line,
 				float cx, float cy,
 				float start_angle,
 				float end_angle)
 {
   cairo_t *cr = c->cr;

   unsigned int len = PREALLOCATED_COLOR_STOPS;
   hb_color_stop_t stops_[PREALLOCATED_COLOR_STOPS];
   hb_color_stop_t *stops = stops_;
   cairo_extend_t extend;
   double x1, y1, x2, y2;
   float max_x, max_y, radius;
   cairo_pattern_t *pattern;

   if (unlikely (!_hb_cairo_get_color_stops (c, color_line, &len, &stops)))
     return;

   hb_array_t<hb_color_stop_t> (stops, len)
     .qsort ([] (const hb_color_stop_t &a, const hb_color_stop_t &b) {
       return (a.offset > b.offset) - (a.offset < b.offset);
     });

   cairo_clip_extents (cr, &x1, &y1, &x2, &y2);
   max_x = (float) hb_max ((x1 - (double) cx) * (x1 - (double) cx), (x2 - (double) cx) * (x2 - (double) cx));
   max_y = (float) hb_max ((y1 - (double) cy) * (y1 - (double) cy), (y2 - (double) cy) * (y2 - (double) cy));
   radius = sqrtf (max_x + max_y);

   extend = hb_cairo_extend (hb_color_line_get_extend (color_line));
   pattern = cairo_pattern_create_mesh ();

   _hb_cairo_add_sweep_gradient_patches (stops, len, extend, cx, cy,
 					radius, start_angle, end_angle, pattern);

   cairo_set_source (cr, pattern);
   cairo_paint (cr);

   cairo_pattern_destroy (pattern);

   if (stops != stops_)
     hb_free (stops);
 }

 #endif
	/*
	* Copyright © 2022 Red Hat, Inc
	* Copyright © 2021, 2022 Black Foundry
	*
	* This is part of HarfBuzz, a text shaping library.
	*
	* Permission is hereby granted, without written agreement and without
	* license or royalty fees, to use, copy, modify, and distribute this
	* software and its documentation for any purpose, provided that the
	* above copyright notice and the following two paragraphs appear in
	* all copies of this software.
	*
	* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
	* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
	* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
	* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
	* DAMAGE.
	*
	* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
	* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
	* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
	* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
	* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
	*
	* Google Author(s): Matthias Clasen
	*/

	#include "hb.hh"

	#ifdef HAVE_CAIRO

	#include "hb-cairo-utils.hh"
	#include "hb-paint.hh"

	/* Some routines in this file were ported from BlackRenderer by Black Foundry.
	* Used by permission to relicense to HarfBuzz license.
	*
	* https://github.com/BlackFoundryCom/black-renderer
	*/

	#define PREALLOCATED_COLOR_STOPS 16

	typedef struct {
	float r, g, b, a;
	} hb_cairo_color_t;

	static inline cairo_extend_t
	hb_cairo_extend (hb_paint_extend_t extend)
	{
	switch (extend)
	{
	case HB_PAINT_EXTEND_PAD: return CAIRO_EXTEND_PAD;
	case HB_PAINT_EXTEND_REPEAT: return CAIRO_EXTEND_REPEAT;
	case HB_PAINT_EXTEND_REFLECT: return CAIRO_EXTEND_REFLECT;
	default: break;
	}

	return CAIRO_EXTEND_PAD;
	}

	#ifdef CAIRO_HAS_PNG_FUNCTIONS
	typedef struct
	{
	hb_blob_t *blob;
	unsigned int offset;
	} hb_cairo_read_blob_data_t;

	static cairo_status_t
	hb_cairo_read_blob (void *closure,
	unsigned char *data,
	unsigned int length)
	{
	hb_cairo_read_blob_data_t r = (hb_cairo_read_blob_data_t ) closure;
	const char *d;
	unsigned int size;

	d = hb_blob_get_data (r->blob, &size);

	if (r->offset + length > size)
	return CAIRO_STATUS_READ_ERROR;

	hb_memcpy (data, d + r->offset, length);
	r->offset += length;

	return CAIRO_STATUS_SUCCESS;
	}
	#endif

	static const cairo_user_data_key_t *_hb_cairo_surface_blob_user_data_key = {0};

	static void
	_hb_cairo_destroy_blob (void *p)
	{
	hb_blob_destroy ((hb_blob_t *) p);
	}

	void
	_hb_cairo_set_source_color (hb_cairo_context_t *c,
	hb_bool_t use_foreground,
	hb_color_t color)
	{
	cairo_t *cr = c->cr;

	if (use_foreground)
	{
	#ifdef HAVE_CAIRO_USER_SCALED_FONT_GET_FOREGROUND_SOURCE
	double r, g, b, a;
	cairo_pattern_t *foreground = cairo_user_scaled_font_get_foreground_source (c->scaled_font);
	if (cairo_pattern_get_rgba (foreground, &r, &g, &b, &a) == CAIRO_STATUS_SUCCESS)
	cairo_set_source_rgba (cr, r, g, b, a * hb_color_get_alpha (color) / 255.);
	else
	#endif
	cairo_set_source_rgba (cr, 0, 0, 0, hb_color_get_alpha (color) / 255.);
	}
	else
	cairo_set_source_rgba (cr,
	hb_color_get_red (color) / 255.,
	hb_color_get_green (color) / 255.,
	hb_color_get_blue (color) / 255.,
	hb_color_get_alpha (color) / 255.);
	}

	hb_bool_t
	_hb_cairo_paint_glyph_image (hb_cairo_context_t *c,
	hb_blob_t *blob,
	unsigned width,
	unsigned height,
	hb_tag_t format,
	HB_UNUSED float slant_deprecated,
	hb_glyph_extents_t *extents)
	{
	cairo_t *cr = c->cr;

	if (!extents) /* SVG currently. */
	return false;

	cairo_surface_t *surface = nullptr;

	#ifdef CAIRO_HAS_PNG_FUNCTIONS
	if (format == HB_PAINT_IMAGE_FORMAT_PNG)
	{
	hb_cairo_read_blob_data_t r;
	r.blob = blob;
	r.offset = 0;
	surface = cairo_image_surface_create_from_png_stream (hb_cairo_read_blob, &r);

	/* For PNG, width,height can be unreliable, as is the case for NotoColorEmoji :(.
	* Just pull them out of the surface. */
	width = cairo_image_surface_get_width (surface);
	height = cairo_image_surface_get_width (surface);
	}
	else
	#endif
	if (format == HB_PAINT_IMAGE_FORMAT_BGRA)
	{
	/* Byte-endian conversion. */
	unsigned data_size = hb_blob_get_length (blob);
	if (data_size < width * height * 4)
	return false;

	unsigned char *data;
	#ifdef __BYTE_ORDER
	if (__BYTE_ORDER == __BIG_ENDIAN)
	{
	data = (unsigned char *) hb_blob_get_data_writable (blob, nullptr);
	if (!data)
	return false;

	unsigned count = width * height * 4;
	for (unsigned i = 0; i < count; i += 4)
	{
	unsigned char b;
	b = data[i];
	data[i] = data[i+3];
	data[i+3] = b;
	b = data[i+1];
	data[i+1] = data[i+2];
	data[i+2] = b;
	}
	}
	else
	#endif
	data = (unsigned char *) hb_blob_get_data (blob, nullptr);

	surface = cairo_image_surface_create_for_data (data,
	CAIRO_FORMAT_ARGB32,
	width, height,
	width * 4);

	cairo_surface_set_user_data (surface,
	_hb_cairo_surface_blob_user_data_key,
	hb_blob_reference (blob),
	_hb_cairo_destroy_blob);
	}

	if (!surface)
	return false;

	cairo_save (cr);
	/* this clip is here to work around recording surface limitations */
	cairo_rectangle (cr,
	extents->x_bearing,
	extents->y_bearing,
	extents->width,
	extents->height);
	cairo_clip (cr);

	cairo_pattern_t *pattern = cairo_pattern_create_for_surface (surface);
	cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);

	cairo_matrix_t matrix = {(double) width, 0, 0, (double) height, 0, 0};
	cairo_pattern_set_matrix (pattern, &matrix);

	cairo_translate (cr, extents->x_bearing, extents->y_bearing);
	cairo_scale (cr, extents->width, extents->height);
	cairo_set_source (cr, pattern);

	cairo_paint (cr);

	cairo_pattern_destroy (pattern);
	cairo_surface_destroy (surface);

	cairo_restore (cr);

	return true;
	}

	static bool
	_hb_cairo_get_color_stops (hb_cairo_context_t *c,
	hb_color_line_t *color_line,
	unsigned *count,
	hb_color_stop_t **stops)
	{
	unsigned len = hb_color_line_get_color_stops (color_line, 0, nullptr, nullptr);
	bool allocated = false;
	if (unlikely (!len))
	return false;
	if (len > *count)
	{
	stops = (hb_color_stop_t ) hb_malloc (len * sizeof (hb_color_stop_t));
	if (unlikely (!*stops))
	return false;
	allocated = true;
	}
	hb_color_line_get_color_stops (color_line, 0, &len, *stops);
	if (unlikely (!len))
	{
	if (allocated)
	{
	hb_free (*stops);
	*stops = nullptr;
	}
	return false;
	}
	for (unsigned i = 0; i < len; i++)
	if ((*stops)[i].is_foreground)
	{
	#ifdef HAVE_CAIRO_USER_SCALED_FONT_GET_FOREGROUND_SOURCE
	double r, g, b, a;
	cairo_pattern_t *foreground = cairo_user_scaled_font_get_foreground_source (c->scaled_font);
	if (cairo_pattern_get_rgba (foreground, &r, &g, &b, &a) == CAIRO_STATUS_SUCCESS)
	(stops)[i].color = HB_COLOR (round (b 255.), round (g * 255.), round (r * 255.),
	round (a * hb_color_get_alpha ((*stops)[i].color)));
	else
	#endif
	(stops)[i].color = HB_COLOR (0, 0, 0, hb_color_get_alpha ((stops)[i].color));
	}

	*count = len;
	return true;
	}

	void
	_hb_cairo_paint_linear_gradient (hb_cairo_context_t *c,
	hb_color_line_t *color_line,
	float x0, float y0,
	float x1, float y1,
	float x2, float y2)
	{
	cairo_t *cr = c->cr;

	unsigned int len = PREALLOCATED_COLOR_STOPS;
	hb_color_stop_t stops_[PREALLOCATED_COLOR_STOPS];
	hb_color_stop_t *stops = stops_;
	float xx0, yy0, xx1, yy1;
	float xxx0, yyy0, xxx1, yyy1;
	float min, max;
	cairo_pattern_t *pattern;

	if (unlikely (!_hb_cairo_get_color_stops (c, color_line, &len, &stops)))
	return;
	hb_paint_normalize_color_line (stops, len, &min, &max);

	hb_paint_reduce_linear_anchors (x0, y0, x1, y1, x2, y2, &xx0, &yy0, &xx1, &yy1);

	xxx0 = xx0 + min * (xx1 - xx0);
	yyy0 = yy0 + min * (yy1 - yy0);
	xxx1 = xx0 + max * (xx1 - xx0);
	yyy1 = yy0 + max * (yy1 - yy0);

	pattern = cairo_pattern_create_linear ((double) xxx0, (double) yyy0, (double) xxx1, (double) yyy1);
	cairo_pattern_set_extend (pattern, hb_cairo_extend (hb_color_line_get_extend (color_line)));
	for (unsigned int i = 0; i < len; i++)
	{
	double r, g, b, a;
	r = hb_color_get_red (stops[i].color) / 255.;
	g = hb_color_get_green (stops[i].color) / 255.;
	b = hb_color_get_blue (stops[i].color) / 255.;
	a = hb_color_get_alpha (stops[i].color) / 255.;
	cairo_pattern_add_color_stop_rgba (pattern, (double) stops[i].offset, r, g, b, a);
	}

	cairo_set_source (cr, pattern);
	cairo_paint (cr);

	cairo_pattern_destroy (pattern);

	if (stops != stops_)
	hb_free (stops);
	}

	void
	_hb_cairo_paint_radial_gradient (hb_cairo_context_t *c,
	hb_color_line_t *color_line,
	float x0, float y0, float r0,
	float x1, float y1, float r1)
	{
	cairo_t *cr = c->cr;

	unsigned int len = PREALLOCATED_COLOR_STOPS;
	hb_color_stop_t stops_[PREALLOCATED_COLOR_STOPS];
	hb_color_stop_t *stops = stops_;
	float min, max;
	float xx0, yy0, xx1, yy1;
	float rr0, rr1;
	cairo_pattern_t *pattern;

	if (unlikely (!_hb_cairo_get_color_stops (c, color_line, &len, &stops)))
	return;
	hb_paint_normalize_color_line (stops, len, &min, &max);

	xx0 = x0 + min * (x1 - x0);
	yy0 = y0 + min * (y1 - y0);
	xx1 = x0 + max * (x1 - x0);
	yy1 = y0 + max * (y1 - y0);
	rr0 = r0 + min * (r1 - r0);
	rr1 = r0 + max * (r1 - r0);

	pattern = cairo_pattern_create_radial ((double) xx0, (double) yy0, (double) rr0, (double) xx1, (double) yy1, (double) rr1);
	cairo_pattern_set_extend (pattern, hb_cairo_extend (hb_color_line_get_extend (color_line)));

	for (unsigned int i = 0; i < len; i++)
	{
	double r, g, b, a;
	r = hb_color_get_red (stops[i].color) / 255.;
	g = hb_color_get_green (stops[i].color) / 255.;
	b = hb_color_get_blue (stops[i].color) / 255.;
	a = hb_color_get_alpha (stops[i].color) / 255.;
	cairo_pattern_add_color_stop_rgba (pattern, (double) stops[i].offset, r, g, b, a);
	}

	cairo_set_source (cr, pattern);
	cairo_paint (cr);

	cairo_pattern_destroy (pattern);

	if (stops != stops_)
	hb_free (stops);
	}

	typedef struct {
	float x, y;
	} hb_cairo_point_t;

	static inline float
	_hb_cairo_interpolate (float f0, float f1, float f)
	{
	return f0 + f * (f1 - f0);
	}

	static inline void
	_hb_cairo_premultiply (hb_cairo_color_t *c)
	{
	c->r *= c->a;
	c->g *= c->a;
	c->b *= c->a;
	}

	static inline void
	_hb_cairo_unpremultiply (hb_cairo_color_t *c)
	{
	if (c->a != 0.f)
	{
	c->r /= c->a;
	c->g /= c->a;
	c->b /= c->a;
	}
	}

	static void
	_hb_cairo_interpolate_colors (hb_cairo_color_t c0, hb_cairo_color_t c1, float k, hb_cairo_color_t *c)
	{
	// According to the COLR specification, gradients
	// should be interpolated in premultiplied form
	_hb_cairo_premultiply (c0);
	_hb_cairo_premultiply (c1);
	c->r = c0->r + k * (c1->r - c0->r);
	c->g = c0->g + k * (c1->g - c0->g);
	c->b = c0->b + k * (c1->b - c0->b);
	c->a = c0->a + k * (c1->a - c0->a);
	_hb_cairo_unpremultiply (c);
	}

	static inline float
	_hb_cairo_dot (hb_cairo_point_t p, hb_cairo_point_t q)
	{
	return p.x * q.x + p.y * q.y;
	}

	static inline hb_cairo_point_t
	_hb_cairo_normalize (hb_cairo_point_t p)
	{
	float len = sqrtf (_hb_cairo_dot (p, p));

	return hb_cairo_point_t { p.x / len, p.y / len };
	}

	static inline hb_cairo_point_t
	_hb_cairo_sum (hb_cairo_point_t p, hb_cairo_point_t q)
	{
	return hb_cairo_point_t { p.x + q.x, p.y + q.y };
	}

	static inline hb_cairo_point_t
	_hb_cairo_difference (hb_cairo_point_t p, hb_cairo_point_t q)
	{
	return hb_cairo_point_t { p.x - q.x, p.y - q.y };
	}

	static inline hb_cairo_point_t
	_hb_cairo_scale (hb_cairo_point_t p, float f)
	{
	return hb_cairo_point_t { p.x * f, p.y * f };
	}

	typedef struct {
	hb_cairo_point_t center, p0, c0, c1, p1;
	hb_cairo_color_t color0, color1;
	} hb_cairo_patch_t;

	static void
	_hb_cairo_add_patch (cairo_pattern_t pattern, hb_cairo_point_t center, hb_cairo_patch_t *p)
	{
	cairo_mesh_pattern_begin_patch (pattern);
	cairo_mesh_pattern_move_to (pattern, (double) center->x, (double) center->y);
	cairo_mesh_pattern_line_to (pattern, (double) p->p0.x, (double) p->p0.y);
	cairo_mesh_pattern_curve_to (pattern,
	(double) p->c0.x, (double) p->c0.y,
	(double) p->c1.x, (double) p->c1.y,
	(double) p->p1.x, (double) p->p1.y);
	cairo_mesh_pattern_line_to (pattern, (double) center->x, (double) center->y);
	cairo_mesh_pattern_set_corner_color_rgba (pattern, 0,
	(double) p->color0.r,
	(double) p->color0.g,
	(double) p->color0.b,
	(double) p->color0.a);
	cairo_mesh_pattern_set_corner_color_rgba (pattern, 1,
	(double) p->color0.r,
	(double) p->color0.g,
	(double) p->color0.b,
	(double) p->color0.a);
	cairo_mesh_pattern_set_corner_color_rgba (pattern, 2,
	(double) p->color1.r,
	(double) p->color1.g,
	(double) p->color1.b,
	(double) p->color1.a);
	cairo_mesh_pattern_set_corner_color_rgba (pattern, 3,
	(double) p->color1.r,
	(double) p->color1.g,
	(double) p->color1.b,
	(double) p->color1.a);
	cairo_mesh_pattern_end_patch (pattern);
	}

	#define MAX_ANGLE (HB_PI / 8.f)

	static void
	_hb_cairo_add_sweep_gradient_patches1 (float cx, float cy, float radius,
	float a0, hb_cairo_color_t *c0,
	float a1, hb_cairo_color_t *c1,
	cairo_pattern_t *pattern)
	{
	hb_cairo_point_t center = hb_cairo_point_t { cx, cy };
	int num_splits;
	hb_cairo_point_t p0;
	hb_cairo_color_t color0, color1;

	num_splits = ceilf (fabsf (a1 - a0) / MAX_ANGLE);
	p0 = hb_cairo_point_t { cosf (a0), sinf (a0) };
	color0 = *c0;

	for (int a = 0; a < num_splits; a++)
	{
	float k = (a + 1.) / num_splits;
	float angle1;
	hb_cairo_point_t p1;
	hb_cairo_point_t A, U;
	hb_cairo_point_t C0, C1;
	hb_cairo_patch_t patch;

	angle1 = _hb_cairo_interpolate (a0, a1, k);
	_hb_cairo_interpolate_colors (c0, c1, k, &color1);

	patch.color0 = color0;
	patch.color1 = color1;

	p1 = hb_cairo_point_t { cosf (angle1), sinf (angle1) };
	patch.p0 = _hb_cairo_sum (center, _hb_cairo_scale (p0, radius));
	patch.p1 = _hb_cairo_sum (center, _hb_cairo_scale (p1, radius));

	A = _hb_cairo_normalize (_hb_cairo_sum (p0, p1));
	U = hb_cairo_point_t { -A.y, A.x };
	C0 = _hb_cairo_sum (A, _hb_cairo_scale (U, _hb_cairo_dot (_hb_cairo_difference (p0, A), p0) / _hb_cairo_dot (U, p0)));
	C1 = _hb_cairo_sum (A, _hb_cairo_scale (U, _hb_cairo_dot (_hb_cairo_difference (p1, A), p1) / _hb_cairo_dot (U, p1)));

	patch.c0 = _hb_cairo_sum (center, _hb_cairo_scale (_hb_cairo_sum (C0, _hb_cairo_scale (_hb_cairo_difference (C0, p0), 0.33333f)), radius));
	patch.c1 = _hb_cairo_sum (center, _hb_cairo_scale (_hb_cairo_sum (C1, _hb_cairo_scale (_hb_cairo_difference (C1, p1), 0.33333f)), radius));

	_hb_cairo_add_patch (pattern, &center, &patch);

	p0 = p1;
	color0 = color1;
	}
	}

	static inline hb_cairo_color_t
	_hb_cairo_color_from_hb_color (hb_color_t c)
	{
	return {
	hb_color_get_red (c) / 255.f,
	hb_color_get_green (c) / 255.f,
	hb_color_get_blue (c) / 255.f,
	hb_color_get_alpha (c) / 255.f,
	};
	}

	struct _hb_cairo_sweep_patch_ctx {
	float cx, cy, radius;
	cairo_pattern_t *pattern;
	};

	static void
	_hb_cairo_sweep_emit_patch (float a0, hb_color_t c0,
	float a1, hb_color_t c1,
	void *user_data)
	{
	auto ctx = (_hb_cairo_sweep_patch_ctx ) user_data;
	hb_cairo_color_t cc0 = _hb_cairo_color_from_hb_color (c0);
	hb_cairo_color_t cc1 = _hb_cairo_color_from_hb_color (c1);
	_hb_cairo_add_sweep_gradient_patches1 (ctx->cx, ctx->cy, ctx->radius,
	a0, &cc0, a1, &cc1,
	ctx->pattern);
	}

	static void
	_hb_cairo_add_sweep_gradient_patches (hb_color_stop_t *stops,
	unsigned int n_stops,
	cairo_extend_t extend,
	float cx, float cy,
	float radius,
	float start_angle,
	float end_angle,
	cairo_pattern_t *pattern)
	{
	hb_paint_extend_t hb_extend =
	extend == CAIRO_EXTEND_REPEAT ? HB_PAINT_EXTEND_REPEAT :
	extend == CAIRO_EXTEND_REFLECT ? HB_PAINT_EXTEND_REFLECT :
	HB_PAINT_EXTEND_PAD;

	_hb_cairo_sweep_patch_ctx ctx { cx, cy, radius, pattern };
	hb_paint_sweep_gradient_tiles (stops, n_stops, hb_extend,
	start_angle, end_angle,
	_hb_cairo_sweep_emit_patch, &ctx);
	}

	void
	_hb_cairo_paint_sweep_gradient (hb_cairo_context_t *c,
	hb_color_line_t *color_line,
	float cx, float cy,
	float start_angle,
	float end_angle)
	{
	cairo_t *cr = c->cr;

	unsigned int len = PREALLOCATED_COLOR_STOPS;
	hb_color_stop_t stops_[PREALLOCATED_COLOR_STOPS];
	hb_color_stop_t *stops = stops_;
	cairo_extend_t extend;
	double x1, y1, x2, y2;
	float max_x, max_y, radius;
	cairo_pattern_t *pattern;

	if (unlikely (!_hb_cairo_get_color_stops (c, color_line, &len, &stops)))
	return;

	hb_array_t<hb_color_stop_t> (stops, len)
	.qsort ([] (const hb_color_stop_t &a, const hb_color_stop_t &b) {
	return (a.offset > b.offset) - (a.offset < b.offset);
	});

	cairo_clip_extents (cr, &x1, &y1, &x2, &y2);
	max_x = (float) hb_max ((x1 - (double) cx) * (x1 - (double) cx), (x2 - (double) cx) * (x2 - (double) cx));
	max_y = (float) hb_max ((y1 - (double) cy) * (y1 - (double) cy), (y2 - (double) cy) * (y2 - (double) cy));
	radius = sqrtf (max_x + max_y);

	extend = hb_cairo_extend (hb_color_line_get_extend (color_line));
	pattern = cairo_pattern_create_mesh ();

	_hb_cairo_add_sweep_gradient_patches (stops, len, extend, cx, cy,
	radius, start_angle, end_angle, pattern);

	cairo_set_source (cr, pattern);
	cairo_paint (cr);

	cairo_pattern_destroy (pattern);

	if (stops != stops_)
	hb_free (stops);
	}

	#endif