Roll HarfBuzz to 1.1.3

third_party/harfbuzz-ng/src/hb-ot-shape-complex-arabic.cc

 /*
  * Copyright © 2010,2012  Google, Inc.
  *
  *  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.
@@ skipping 205 matching lines @@
     bool has_fallback = plan->props.script == HB_SCRIPT_ARABIC && !FEATURE_IS_SYRIAC (arabic_features[i]);
     map->add_feature (arabic_features[i], 1, has_fallback ? F_HAS_FALLBACK : F_NONE);
     map->add_gsub_pause (NULL);
   }
 
   map->add_feature (HB_TAG('r','l','i','g'), 1, F_GLOBAL|F_HAS_FALLBACK);
   if (plan->props.script == HB_SCRIPT_ARABIC)
     map->add_gsub_pause (arabic_fallback_shape);
 
   map->add_global_bool_feature (HB_TAG('c','a','l','t'));
-  map->add_gsub_pause (NULL);
 
   /* The spec includes 'cswh'.  Earlier versions of Windows
    * used to enable this by default, but testing suggests
    * that Windows 8 and later do not enable it by default,
    * and spec now says 'Off by default'.
    * We disabled this in ae23c24c32.
    * Note that IranNastaliq uses this feature extensively
    * to fixup broken glyph sequences.  Oh well...
    * Test case: U+0643,U+0640,U+0631. */
+  //map->add_gsub_pause (NULL);
   //map->add_global_bool_feature (HB_TAG('c','s','w','h'));
   map->add_global_bool_feature (HB_TAG('m','s','e','t'));
 }
 
 #include "hb-ot-shape-complex-arabic-fallback.hh"
 
 struct arabic_shape_plan_t
 {
   ASSERT_POD ();
 
@@ skipping 210 matching lines @@
 
   /* The Arabic shaper currently always processes in RTL mode, so we should
    * stretch / position the stretched pieces to the left / preceding glyphs. */
 
   /* We do a two pass implementation:
    * First pass calculates the exact number of extra glyphs we need,
    * We then enlarge buffer to have that much room,
    * Second pass applies the stretch, copying things to the end of buffer.
    */
 
-  /* 30 = 2048 / 70.
-   * https://www.microsoft.com/typography/cursivescriptguidelines.mspx */
-  hb_position_t overlap = font->x_scale / 30;
-  DEBUG_MSG (ARABIC, NULL, "overlap for stretching is %d", overlap);
   int sign = font->x_scale < 0 ? -1 : +1;
   unsigned int extra_glyphs_needed = 0; // Set during MEASURE, used during CUT
   typedef enum { MEASURE, CUT } step_t;
 
   for (step_t step = MEASURE; step <= CUT; step = (step_t) (step + 1))
   {
     unsigned int count = buffer->len;
     hb_glyph_info_t *info = buffer->info;
     hb_glyph_position_t *pos = buffer->pos;
     unsigned int new_len = count + extra_glyphs_needed; // write head during CUT
@@ skipping 17 matching lines @@
       hb_position_t w_fixed = 0; // Sum of fixed tiles
       hb_position_t w_repeating = 0; // Sum of repeating tiles
       int n_fixed = 0;
       int n_repeating = 0;
 
       unsigned int end = i;
       while (i &&
              hb_in_range<unsigned> (info[i - 1].arabic_shaping_action(), STCH_FIXED, STCH_REPEATING))
       {
         i--;
-        hb_glyph_extents_t extents;
-        if (!font->get_glyph_extents (info[i].codepoint, &extents))
-          extents.width = 0;
-        extents.width -= overlap;
+        hb_position_t width = font->get_glyph_h_advance (info[i].codepoint);
         if (info[i].arabic_shaping_action() == STCH_FIXED)
         {
-          w_fixed += extents.width;
+          w_fixed += width;
           n_fixed++;
         }
         else
         {
-          w_repeating += extents.width;
+          w_repeating += width;
           n_repeating++;
         }
       }
       unsigned int start = i;
       unsigned int context = i;
       while (context &&
              !hb_in_range<unsigned> (info[context - 1].arabic_shaping_action(), STCH_FIXED, STCH_REPEATING) &&
              (_hb_glyph_info_is_default_ignorable (&info[context - 1]) ||
               HB_ARABIC_GENERAL_CATEGORY_IS_WORD (_hb_glyph_info_get_general_category (&info[context - 1]))))
       {
         context--;
         w_total += pos[context].x_advance;
       }
       i++; // Don't touch i again.
 
       DEBUG_MSG (ARABIC, NULL, "%s stretch at (%d,%d,%d)",
                  step == MEASURE ? "measuring" : "cutting", context, start, end);
       DEBUG_MSG (ARABIC, NULL, "rest of word:    count=%d width %d", start - context, w_total);
       DEBUG_MSG (ARABIC, NULL, "fixed tiles:     count=%d width=%d", n_fixed, w_fixed);
       DEBUG_MSG (ARABIC, NULL, "repeating tiles: count=%d width=%d", n_repeating, w_repeating);
 
       /* Number of additional times to repeat each repeating tile. */
       int n_copies = 0;
 
-      hb_position_t w_remaining = w_total - w_fixed - overlap;
+      hb_position_t w_remaining = w_total - w_fixed;
       if (sign * w_remaining > sign * w_repeating && sign * w_repeating > 0)
-        n_copies = (sign * w_remaining + sign * w_repeating / 4) / (sign * w_repeating) - 1;
+        n_copies = (sign * w_remaining) / (sign * w_repeating) - 1;
+
+      /* See if we can improve the fit by adding an extra repeat and squeezing them together a bit. */
+      hb_position_t extra_repeat_overlap = 0;
+      hb_position_t shortfall = sign * w_remaining - sign * w_repeating * (n_copies + 1);
+      if (shortfall > 0)
+      {
+        ++n_copies;
+        hb_position_t excess = (n_copies + 1) * sign * w_repeating - sign * w_remaining;
+        if (excess > 0)
+          extra_repeat_overlap = excess / (n_copies * n_repeating);
+      }
 
       if (step == MEASURE)
       {
         extra_glyphs_needed += n_copies * n_repeating;
         DEBUG_MSG (ARABIC, NULL, "will add extra %d copies of repeating tiles", n_copies);
       }
       else
       {
-        hb_position_t x_offset = -overlap;
+        hb_position_t x_offset = 0;
         for (unsigned int k = end; k > start; k--)
         {
-          hb_glyph_extents_t extents;
-          if (!font->get_glyph_extents (info[k - 1].codepoint, &extents))
-            extents.width = 0;
-          extents.width -= overlap;
+          hb_position_t width = font->get_glyph_h_advance (info[k - 1].codepoint);
 
           unsigned int repeat = 1;
           if (info[k - 1].arabic_shaping_action() == STCH_REPEATING)
             repeat += n_copies;
 
           DEBUG_MSG (ARABIC, NULL, "appending %d copies of glyph %d; j=%d",
                      repeat, info[k - 1].codepoint, j);
           for (unsigned int n = 0; n < repeat; n++)
           {
-            x_offset -= extents.width;
+            x_offset -= width;
+            if (n > 0)
+              x_offset += extra_repeat_overlap;
             pos[k - 1].x_offset = x_offset;
             /* Append copy. */
             --j;
             info[j] = info[k - 1];
             pos[j] = pos[k - 1];
           }
         }
       }
     }
 
@@ skipping 30 matching lines @@
   data_destroy_arabic,
   NULL, /* preprocess_text */
   postprocess_glyphs_arabic,
   HB_OT_SHAPE_NORMALIZATION_MODE_DEFAULT,
   NULL, /* decompose */
   NULL, /* compose */
   setup_masks_arabic,
   HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
   true, /* fallback_position */
 };