src/OT/Layout/GPOS/PairPosFormat2.hh

   1 #ifndef OT_LAYOUT_GPOS_PAIRPOSFORMAT2_HH
   2 #define OT_LAYOUT_GPOS_PAIRPOSFORMAT2_HH
   3
   4 #include "ValueFormat.hh"
   5
   6 namespace OT {
   7 namespace Layout {
   8 namespace GPOS_impl {
   9
  10 template <typename Types>
  11 struct PairPosFormat2_4
  12 {
  13   protected:
  14   HBUINT16      format;                 /* Format identifier--format = 2 */
  15   typename Types::template OffsetTo<Coverage>
  16                 coverage;               /* Offset to Coverage table--from
  17                                          * beginning of subtable */
  18   ValueFormat   valueFormat1;           /* ValueRecord definition--for the
  19                                          * first glyph of the pair--may be zero
  20                                          * (0) */
  21   ValueFormat   valueFormat2;           /* ValueRecord definition--for the
  22                                          * second glyph of the pair--may be
  23                                          * zero (0) */
  24   typename Types::template OffsetTo<ClassDef>
  25                 classDef1;              /* Offset to ClassDef table--from
  26                                          * beginning of PairPos subtable--for
  27                                          * the first glyph of the pair */
  28   typename Types::template OffsetTo<ClassDef>
  29                 classDef2;              /* Offset to ClassDef table--from
  30                                          * beginning of PairPos subtable--for
  31                                          * the second glyph of the pair */
  32   HBUINT16      class1Count;            /* Number of classes in ClassDef1
  33                                          * table--includes Class0 */
  34   HBUINT16      class2Count;            /* Number of classes in ClassDef2
  35                                          * table--includes Class0 */
  36   ValueRecord   values;                 /* Matrix of value pairs:
  37                                          * class1-major, class2-minor,
  38                                          * Each entry has value1 and value2 */
  39   public:
  40   DEFINE_SIZE_ARRAY (10 + 3 * Types::size, values);
  41
  42   bool sanitize (hb_sanitize_context_t *c) const
  43   {
  44     TRACE_SANITIZE (this);
  45     if (!(c->check_struct (this)
  46        && coverage.sanitize (c, this)
  47        && classDef1.sanitize (c, this)
  48        && classDef2.sanitize (c, this))) return_trace (false);
  49
  50     unsigned int len1 = valueFormat1.get_len ();
  51     unsigned int len2 = valueFormat2.get_len ();
  52     unsigned int stride = HBUINT16::static_size * (len1 + len2);
  53     unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count;
  54     return_trace (c->check_range ((const void *) values,
  55                                   count,
  56                                   stride) &&
  57                   (c->lazy_some_gpos ||
  58                    (valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) &&
  59                     valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride))));
  60   }
  61
  62   bool intersects (const hb_set_t *glyphs) const
  63   {
  64     return (this+coverage).intersects (glyphs) &&
  65            (this+classDef2).intersects (glyphs);
  66   }
  67
  68   void closure_lookups (hb_closure_lookups_context_t *c) const {}
  69   void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
  70   {
  71     if (!intersects (c->glyph_set)) return;
  72     if ((!valueFormat1.has_device ()) && (!valueFormat2.has_device ())) return;
  73
  74     hb_set_t klass1_glyphs, klass2_glyphs;
  75     if (!(this+classDef1).collect_coverage (&klass1_glyphs)) return;
  76     if (!(this+classDef2).collect_coverage (&klass2_glyphs)) return;
  77
  78     hb_set_t class1_set, class2_set;
  79     for (const unsigned cp : + c->glyph_set->iter () | hb_filter (this + coverage))
  80     {
  81       if (!klass1_glyphs.has (cp)) class1_set.add (0);
  82       else
  83       {
  84         unsigned klass1 = (this+classDef1).get (cp);
  85         class1_set.add (klass1);
  86       }
  87     }
  88
  89     class2_set.add (0);
  90     for (const unsigned cp : + c->glyph_set->iter () | hb_filter (klass2_glyphs))
  91     {
  92       unsigned klass2 = (this+classDef2).get (cp);
  93       class2_set.add (klass2);
  94     }
  95
  96     if (class1_set.is_empty ()
  97         || class2_set.is_empty ()
  98         || (class2_set.get_population() == 1 && class2_set.has(0)))
  99       return;
 100
 101     unsigned len1 = valueFormat1.get_len ();
 102     unsigned len2 = valueFormat2.get_len ();
 103     const hb_array_t<const Value> values_array = values.as_array ((unsigned)class1Count * (unsigned) class2Count * (len1 + len2));
 104     for (const unsigned class1_idx : class1_set.iter ())
 105     {
 106       for (const unsigned class2_idx : class2_set.iter ())
 107       {
 108         unsigned start_offset = (class1_idx * (unsigned) class2Count + class2_idx) * (len1 + len2);
 109         if (valueFormat1.has_device ())
 110           valueFormat1.collect_variation_indices (c, this, values_array.sub_array (start_offset, len1));
 111
 112         if (valueFormat2.has_device ())
 113           valueFormat2.collect_variation_indices (c, this, values_array.sub_array (start_offset+len1, len2));
 114       }
 115     }
 116   }
 117
 118   void collect_glyphs (hb_collect_glyphs_context_t *c) const
 119   {
 120     if (unlikely (!(this+coverage).collect_coverage (c->input))) return;
 121     if (unlikely (!(this+classDef2).collect_coverage (c->input))) return;
 122   }
 123
 124   const Coverage &get_coverage () const { return this+coverage; }
 125
 126   bool apply (hb_ot_apply_context_t *c) const
 127   {
 128     TRACE_APPLY (this);
 129     hb_buffer_t *buffer = c->buffer;
 130     unsigned int index = (this+coverage).get_coverage  (buffer->cur().codepoint);
 131     if (likely (index == NOT_COVERED)) return_trace (false);
 132
 133     hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
 134     skippy_iter.reset_fast (buffer->idx);
 135     unsigned unsafe_to;
 136     if (unlikely (!skippy_iter.next (&unsafe_to)))
 137     {
 138       buffer->unsafe_to_concat (buffer->idx, unsafe_to);
 139       return_trace (false);
 140     }
 141
 142     unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint);
 143     if (!klass2)
 144     {
 145       buffer->unsafe_to_concat (buffer->idx, skippy_iter.idx + 1);
 146       return_trace (false);
 147     }
 148
 149     unsigned int klass1 = (this+classDef1).get_class (buffer->cur().codepoint);
 150     if (unlikely (klass1 >= class1Count || klass2 >= class2Count))
 151     {
 152       buffer->unsafe_to_concat (buffer->idx, skippy_iter.idx + 1);
 153       return_trace (false);
 154     }
 155
 156     unsigned int len1 = valueFormat1.get_len ();
 157     unsigned int len2 = valueFormat2.get_len ();
 158     unsigned int record_len = len1 + len2;
 159
 160     const Value *v = &values[record_len * (klass1 * class2Count + klass2)];
 161
 162     bool applied_first = false, applied_second = false;
 163
 164
 165     /* Isolate simple kerning and apply it half to each side.
 166      * Results in better cursor positioning / underline drawing.
 167      *
 168      * Disabled, because causes issues... :-(
 169      * https://github.com/harfbuzz/harfbuzz/issues/3408
 170      * https://github.com/harfbuzz/harfbuzz/pull/3235#issuecomment-1029814978
 171      */
 172 #ifndef HB_SPLIT_KERN
 173     if (false)
 174 #endif
 175     {
 176       if (!len2)
 177       {
 178         const hb_direction_t dir = buffer->props.direction;
 179         const bool horizontal = HB_DIRECTION_IS_HORIZONTAL (dir);
 180         const bool backward = HB_DIRECTION_IS_BACKWARD (dir);
 181         unsigned mask = horizontal ? ValueFormat::xAdvance : ValueFormat::yAdvance;
 182         if (backward)
 183           mask |= mask >> 2; /* Add eg. xPlacement in RTL. */
 184         /* Add Devices. */
 185         mask |= mask << 4;
 186
 187         if (valueFormat1 & ~mask)
 188           goto bail;
 189
 190         /* Is simple kern. Apply value on an empty position slot,
 191          * then split it between sides. */
 192
 193         hb_glyph_position_t pos{};
 194         if (valueFormat1.apply_value (c, this, v, pos))
 195         {
 196           hb_position_t *src  = &pos.x_advance;
 197           hb_position_t *dst1 = &buffer->cur_pos().x_advance;
 198           hb_position_t *dst2 = &buffer->pos[skippy_iter.idx].x_advance;
 199           unsigned i = horizontal ? 0 : 1;
 200
 201           hb_position_t kern  = src[i];
 202           hb_position_t kern1 = kern >> 1;
 203           hb_position_t kern2 = kern - kern1;
 204
 205           if (!backward)
 206           {
 207             dst1[i] += kern1;
 208             dst2[i] += kern2;
 209             dst2[i + 2] += kern2;
 210           }
 211           else
 212           {
 213             dst1[i] += kern1;
 214             dst1[i + 2] += src[i + 2] - kern2;
 215             dst2[i] += kern2;
 216           }
 217
 218           applied_first = applied_second = kern != 0;
 219           goto success;
 220         }
 221         goto boring;
 222       }
 223     }
 224     bail:
 225
 226     if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
 227     {
 228       c->buffer->message (c->font,
 229                           "try kerning glyphs at %u,%u",
 230                           c->buffer->idx, skippy_iter.idx);
 231     }
 232
 233     applied_first = len1 && valueFormat1.apply_value (c, this, v, buffer->cur_pos());
 234     applied_second = len2 && valueFormat2.apply_value (c, this, v + len1, buffer->pos[skippy_iter.idx]);
 235
 236     if (applied_first || applied_second)
 237       if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
 238       {
 239         c->buffer->message (c->font,
 240                             "kerned glyphs at %u,%u",
 241                             c->buffer->idx, skippy_iter.idx);
 242       }
 243
 244     if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
 245     {
 246       c->buffer->message (c->font,
 247                           "tried kerning glyphs at %u,%u",
 248                           c->buffer->idx, skippy_iter.idx);
 249     }
 250
 251     success:
 252     if (applied_first || applied_second)
 253       buffer->unsafe_to_break (buffer->idx, skippy_iter.idx + 1);
 254     else
 255     boring:
 256       buffer->unsafe_to_concat (buffer->idx, skippy_iter.idx + 1);
 257
 258     if (len2)
 259     {
 260       skippy_iter.idx++;
 261       // https://github.com/harfbuzz/harfbuzz/issues/3824
 262       // https://github.com/harfbuzz/harfbuzz/issues/3888#issuecomment-1326781116
 263       buffer->unsafe_to_break (buffer->idx, skippy_iter.idx + 1);
 264     }
 265
 266     buffer->idx = skippy_iter.idx;
 267
 268     return_trace (true);
 269   }
 270
 271   bool subset (hb_subset_context_t *c) const
 272   {
 273     TRACE_SUBSET (this);
 274     auto *out = c->serializer->start_embed (*this);
 275     if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
 276     out->format = format;
 277
 278     hb_map_t klass1_map;
 279     out->classDef1.serialize_subset (c, classDef1, this, &klass1_map, true, true, &(this + coverage));
 280     out->class1Count = klass1_map.get_population ();
 281
 282     hb_map_t klass2_map;
 283     out->classDef2.serialize_subset (c, classDef2, this, &klass2_map, true, false);
 284     out->class2Count = klass2_map.get_population ();
 285
 286     unsigned len1 = valueFormat1.get_len ();
 287     unsigned len2 = valueFormat2.get_len ();
 288
 289     hb_pair_t<unsigned, unsigned> newFormats = hb_pair (valueFormat1, valueFormat2);
 290     if (c->plan->flags & HB_SUBSET_FLAGS_NO_HINTING)
 291       newFormats = compute_effective_value_formats (klass1_map, klass2_map);
 292
 293     out->valueFormat1 = newFormats.first;
 294     out->valueFormat2 = newFormats.second;
 295
 296     if (c->plan->all_axes_pinned)
 297     {
 298       out->valueFormat1 = out->valueFormat1.drop_device_table_flags ();
 299       out->valueFormat2 = out->valueFormat2.drop_device_table_flags ();
 300     }
 301
 302     unsigned total_len = len1 + len2;
 303     hb_vector_t<unsigned> class2_idxs (+ hb_range ((unsigned) class2Count) | hb_filter (klass2_map));
 304     for (unsigned class1_idx : + hb_range ((unsigned) class1Count) | hb_filter (klass1_map))
 305     {
 306       for (unsigned class2_idx : class2_idxs)
 307       {
 308         unsigned idx = (class1_idx * (unsigned) class2Count + class2_idx) * total_len;
 309         valueFormat1.copy_values (c->serializer, out->valueFormat1, this, &values[idx], &c->plan->layout_variation_idx_delta_map);
 310         valueFormat2.copy_values (c->serializer, out->valueFormat2, this, &values[idx + len1], &c->plan->layout_variation_idx_delta_map);
 311       }
 312     }
 313
 314     const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
 315     const hb_map_t &glyph_map = *c->plan->glyph_map;
 316
 317     auto it =
 318     + hb_iter (this+coverage)
 319     | hb_filter (glyphset)
 320     | hb_map_retains_sorting (glyph_map)
 321     ;
 322
 323     out->coverage.serialize_serialize (c->serializer, it);
 324     return_trace (out->class1Count && out->class2Count && bool (it));
 325   }
 326
 327
 328   hb_pair_t<unsigned, unsigned> compute_effective_value_formats (const hb_map_t& klass1_map,
 329                                                                  const hb_map_t& klass2_map) const
 330   {
 331     unsigned len1 = valueFormat1.get_len ();
 332     unsigned len2 = valueFormat2.get_len ();
 333     unsigned record_size = len1 + len2;
 334
 335     unsigned format1 = 0;
 336     unsigned format2 = 0;
 337
 338     for (unsigned class1_idx : + hb_range ((unsigned) class1Count) | hb_filter (klass1_map))
 339     {
 340       for (unsigned class2_idx : + hb_range ((unsigned) class2Count) | hb_filter (klass2_map))
 341       {
 342         unsigned idx = (class1_idx * (unsigned) class2Count + class2_idx) * record_size;
 343         format1 = format1 | valueFormat1.get_effective_format (&values[idx]);
 344         format2 = format2 | valueFormat2.get_effective_format (&values[idx + len1]);
 345       }
 346
 347       if (format1 == valueFormat1 && format2 == valueFormat2)
 348         break;
 349     }
 350
 351     return hb_pair (format1, format2);
 352   }
 353 };
 354
 355 }
 356 }
 357 }
 358
 359 #endif  // OT_LAYOUT_GPOS_PAIRPOSFORMAT2_HH