PairPosFormat2.hh (14375B)
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 : ValueBase 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 struct external_cache_t 127 { 128 hb_ot_layout_mapping_cache_t coverage; 129 hb_ot_layout_mapping_cache_t first; 130 hb_ot_layout_mapping_cache_t second; 131 }; 132 void *external_cache_create () const 133 { 134 external_cache_t *cache = (external_cache_t *) hb_malloc (sizeof (external_cache_t)); 135 if (likely (cache)) 136 { 137 cache->coverage.clear (); 138 cache->first.clear (); 139 cache->second.clear (); 140 } 141 return cache; 142 } 143 144 bool apply (hb_ot_apply_context_t *c, void *external_cache) const 145 { 146 TRACE_APPLY (this); 147 148 hb_buffer_t *buffer = c->buffer; 149 150 #ifndef HB_NO_OT_LAYOUT_LOOKUP_CACHE 151 external_cache_t *cache = (external_cache_t *) external_cache; 152 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint, cache ? &cache->coverage : nullptr); 153 #else 154 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint); 155 #endif 156 if (index == NOT_COVERED) return_trace (false); 157 158 auto &skippy_iter = c->iter_input; 159 skippy_iter.reset_fast (buffer->idx); 160 unsigned unsafe_to; 161 if (unlikely (!skippy_iter.next (&unsafe_to))) 162 { 163 buffer->unsafe_to_concat (buffer->idx, unsafe_to); 164 return_trace (false); 165 } 166 167 #ifndef HB_NO_OT_LAYOUT_LOOKUP_CACHE 168 unsigned int klass1 = (this+classDef1).get_class (buffer->cur().codepoint, cache ? &cache->first : nullptr); 169 unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint, cache ? &cache->second : nullptr); 170 #else 171 unsigned int klass1 = (this+classDef1).get_class (buffer->cur().codepoint); 172 unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint); 173 #endif 174 if (unlikely (klass1 >= class1Count || klass2 >= class2Count)) 175 { 176 buffer->unsafe_to_concat (buffer->idx, skippy_iter.idx + 1); 177 return_trace (false); 178 } 179 180 unsigned int len1 = valueFormat1.get_len (); 181 unsigned int len2 = valueFormat2.get_len (); 182 unsigned int record_len = len1 + len2; 183 184 const Value *v = &values[record_len * (klass1 * class2Count + klass2)]; 185 186 bool applied_first = false, applied_second = false; 187 188 189 /* Isolate simple kerning and apply it half to each side. 190 * Results in better cursor positioning / underline drawing. 191 * 192 * Disabled, because causes issues... :-( 193 * https://github.com/harfbuzz/harfbuzz/issues/3408 194 * https://github.com/harfbuzz/harfbuzz/pull/3235#issuecomment-1029814978 195 */ 196 #ifndef HB_SPLIT_KERN 197 if (false) 198 #endif 199 { 200 if (!len2) 201 { 202 const hb_direction_t dir = buffer->props.direction; 203 const bool horizontal = HB_DIRECTION_IS_HORIZONTAL (dir); 204 const bool backward = HB_DIRECTION_IS_BACKWARD (dir); 205 unsigned mask = horizontal ? ValueFormat::xAdvance : ValueFormat::yAdvance; 206 if (backward) 207 mask |= mask >> 2; /* Add eg. xPlacement in RTL. */ 208 /* Add Devices. */ 209 mask |= mask << 4; 210 211 if (valueFormat1 & ~mask) 212 goto bail; 213 214 /* Is simple kern. Apply value on an empty position slot, 215 * then split it between sides. */ 216 217 hb_glyph_position_t pos{}; 218 if (valueFormat1.apply_value (c, this, v, pos)) 219 { 220 hb_position_t *src = &pos.x_advance; 221 hb_position_t *dst1 = &buffer->cur_pos().x_advance; 222 hb_position_t *dst2 = &buffer->pos[skippy_iter.idx].x_advance; 223 unsigned i = horizontal ? 0 : 1; 224 225 hb_position_t kern = src[i]; 226 hb_position_t kern1 = kern >> 1; 227 hb_position_t kern2 = kern - kern1; 228 229 if (!backward) 230 { 231 dst1[i] += kern1; 232 dst2[i] += kern2; 233 dst2[i + 2] += kern2; 234 } 235 else 236 { 237 dst1[i] += kern1; 238 dst1[i + 2] += src[i + 2] - kern2; 239 dst2[i] += kern2; 240 } 241 242 applied_first = applied_second = kern != 0; 243 goto success; 244 } 245 goto boring; 246 } 247 } 248 bail: 249 250 if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ()) 251 { 252 c->buffer->message (c->font, 253 "try kerning glyphs at %u,%u", 254 c->buffer->idx, skippy_iter.idx); 255 } 256 257 applied_first = len1 && valueFormat1.apply_value (c, this, v, buffer->cur_pos()); 258 applied_second = len2 && valueFormat2.apply_value (c, this, v + len1, buffer->pos[skippy_iter.idx]); 259 260 if (applied_first || applied_second) 261 if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ()) 262 { 263 c->buffer->message (c->font, 264 "kerned glyphs at %u,%u", 265 c->buffer->idx, skippy_iter.idx); 266 } 267 268 if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ()) 269 { 270 c->buffer->message (c->font, 271 "tried kerning glyphs at %u,%u", 272 c->buffer->idx, skippy_iter.idx); 273 } 274 275 success: 276 if (applied_first || applied_second) 277 buffer->unsafe_to_break (buffer->idx, skippy_iter.idx + 1); 278 else 279 boring: 280 buffer->unsafe_to_concat (buffer->idx, skippy_iter.idx + 1); 281 282 if (len2) 283 { 284 skippy_iter.idx++; 285 // https://github.com/harfbuzz/harfbuzz/issues/3824 286 // https://github.com/harfbuzz/harfbuzz/issues/3888#issuecomment-1326781116 287 buffer->unsafe_to_break (buffer->idx, skippy_iter.idx + 1); 288 } 289 290 buffer->idx = skippy_iter.idx; 291 292 return_trace (true); 293 } 294 295 bool subset (hb_subset_context_t *c) const 296 { 297 TRACE_SUBSET (this); 298 auto *out = c->serializer->start_embed (*this); 299 if (unlikely (!c->serializer->extend_min (out))) return_trace (false); 300 out->format = format; 301 302 hb_map_t klass1_map; 303 out->classDef1.serialize_subset (c, classDef1, this, &klass1_map, true, true, &(this + coverage)); 304 out->class1Count = klass1_map.get_population (); 305 306 hb_map_t klass2_map; 307 out->classDef2.serialize_subset (c, classDef2, this, &klass2_map, true, false); 308 out->class2Count = klass2_map.get_population (); 309 310 unsigned len1 = valueFormat1.get_len (); 311 unsigned len2 = valueFormat2.get_len (); 312 313 hb_pair_t<unsigned, unsigned> newFormats = hb_pair (valueFormat1, valueFormat2); 314 315 if (c->plan->normalized_coords) 316 { 317 /* in case of full instancing, all var device flags will be dropped so no 318 * need to strip hints here */ 319 newFormats = compute_effective_value_formats (klass1_map, klass2_map, false, false, &c->plan->layout_variation_idx_delta_map); 320 } 321 /* do not strip hints for VF */ 322 else if (c->plan->flags & HB_SUBSET_FLAGS_NO_HINTING) 323 { 324 hb_blob_t* blob = hb_face_reference_table (c->plan->source, HB_TAG ('f','v','a','r')); 325 bool has_fvar = (blob != hb_blob_get_empty ()); 326 hb_blob_destroy (blob); 327 328 bool strip = !has_fvar; 329 /* special case: strip hints when a VF has no GDEF varstore after 330 * subsetting*/ 331 if (has_fvar && !c->plan->has_gdef_varstore) 332 strip = true; 333 newFormats = compute_effective_value_formats (klass1_map, klass2_map, strip, true); 334 } 335 336 out->valueFormat1 = newFormats.first; 337 out->valueFormat2 = newFormats.second; 338 339 unsigned total_len = len1 + len2; 340 hb_vector_t<unsigned> class2_idxs (+ hb_range ((unsigned) class2Count) | hb_filter (klass2_map)); 341 for (unsigned class1_idx : + hb_range ((unsigned) class1Count) | hb_filter (klass1_map)) 342 { 343 for (unsigned class2_idx : class2_idxs) 344 { 345 unsigned idx = (class1_idx * (unsigned) class2Count + class2_idx) * total_len; 346 valueFormat1.copy_values (c->serializer, out->valueFormat1, this, &values[idx], &c->plan->layout_variation_idx_delta_map); 347 valueFormat2.copy_values (c->serializer, out->valueFormat2, this, &values[idx + len1], &c->plan->layout_variation_idx_delta_map); 348 } 349 } 350 351 bool ret = out->coverage.serialize_subset(c, coverage, this); 352 return_trace (out->class1Count && out->class2Count && ret); 353 } 354 355 356 hb_pair_t<unsigned, unsigned> compute_effective_value_formats (const hb_map_t& klass1_map, 357 const hb_map_t& klass2_map, 358 bool strip_hints, bool strip_empty, 359 const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *varidx_delta_map = nullptr) const 360 { 361 unsigned len1 = valueFormat1.get_len (); 362 unsigned len2 = valueFormat2.get_len (); 363 unsigned record_size = len1 + len2; 364 365 unsigned format1 = 0; 366 unsigned format2 = 0; 367 368 for (unsigned class1_idx : + hb_range ((unsigned) class1Count) | hb_filter (klass1_map)) 369 { 370 for (unsigned class2_idx : + hb_range ((unsigned) class2Count) | hb_filter (klass2_map)) 371 { 372 unsigned idx = (class1_idx * (unsigned) class2Count + class2_idx) * record_size; 373 format1 = format1 | valueFormat1.get_effective_format (&values[idx], strip_hints, strip_empty, this, varidx_delta_map); 374 format2 = format2 | valueFormat2.get_effective_format (&values[idx + len1], strip_hints, strip_empty, this, varidx_delta_map); 375 } 376 377 if (format1 == valueFormat1 && format2 == valueFormat2) 378 break; 379 } 380 381 return hb_pair (format1, format2); 382 } 383 }; 384 385 } 386 } 387 } 388 389 #endif // OT_LAYOUT_GPOS_PAIRPOSFORMAT2_HH