MarkBasePosFormat1.hh (8654B)
1 #ifndef OT_LAYOUT_GPOS_MARKBASEPOSFORMAT1_HH 2 #define OT_LAYOUT_GPOS_MARKBASEPOSFORMAT1_HH 3 4 #include "MarkArray.hh" 5 6 namespace OT { 7 namespace Layout { 8 namespace GPOS_impl { 9 10 typedef AnchorMatrix BaseArray; /* base-major-- 11 * in order of BaseCoverage Index--, 12 * mark-minor-- 13 * ordered by class--zero-based. */ 14 15 template <typename Types> 16 struct MarkBasePosFormat1_2 17 { 18 protected: 19 HBUINT16 format; /* Format identifier--format = 1 */ 20 typename Types::template OffsetTo<Coverage> 21 markCoverage; /* Offset to MarkCoverage table--from 22 * beginning of MarkBasePos subtable */ 23 typename Types::template OffsetTo<Coverage> 24 baseCoverage; /* Offset to BaseCoverage table--from 25 * beginning of MarkBasePos subtable */ 26 HBUINT16 classCount; /* Number of classes defined for marks */ 27 typename Types::template OffsetTo<MarkArray> 28 markArray; /* Offset to MarkArray table--from 29 * beginning of MarkBasePos subtable */ 30 typename Types::template OffsetTo<BaseArray> 31 baseArray; /* Offset to BaseArray table--from 32 * beginning of MarkBasePos subtable */ 33 34 public: 35 DEFINE_SIZE_STATIC (4 + 4 * Types::size); 36 37 bool sanitize (hb_sanitize_context_t *c) const 38 { 39 TRACE_SANITIZE (this); 40 return_trace (c->check_struct (this) && 41 markCoverage.sanitize (c, this) && 42 baseCoverage.sanitize (c, this) && 43 markArray.sanitize (c, this) && 44 baseArray.sanitize (c, this, (unsigned int) classCount)); 45 } 46 47 bool intersects (const hb_set_t *glyphs) const 48 { 49 return (this+markCoverage).intersects (glyphs) && 50 (this+baseCoverage).intersects (glyphs); 51 } 52 53 void closure_lookups (hb_closure_lookups_context_t *c) const {} 54 55 void collect_variation_indices (hb_collect_variation_indices_context_t *c) const 56 { 57 + hb_zip (this+markCoverage, this+markArray) 58 | hb_filter (c->glyph_set, hb_first) 59 | hb_map (hb_second) 60 | hb_apply ([&] (const MarkRecord& record) { record.collect_variation_indices (c, &(this+markArray)); }) 61 ; 62 63 hb_map_t klass_mapping; 64 Markclass_closure_and_remap_indexes (this+markCoverage, this+markArray, *c->glyph_set, &klass_mapping); 65 66 unsigned basecount = (this+baseArray).rows; 67 auto base_iter = 68 + hb_zip (this+baseCoverage, hb_range (basecount)) 69 | hb_filter (c->glyph_set, hb_first) 70 | hb_map (hb_second) 71 ; 72 73 hb_sorted_vector_t<unsigned> base_indexes; 74 for (const unsigned row : base_iter) 75 { 76 + hb_range ((unsigned) classCount) 77 | hb_filter (klass_mapping) 78 | hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; }) 79 | hb_sink (base_indexes) 80 ; 81 } 82 (this+baseArray).collect_variation_indices (c, base_indexes.iter ()); 83 } 84 85 void collect_glyphs (hb_collect_glyphs_context_t *c) const 86 { 87 if (unlikely (!(this+markCoverage).collect_coverage (c->input))) return; 88 if (unlikely (!(this+baseCoverage).collect_coverage (c->input))) return; 89 } 90 91 const Coverage &get_coverage () const { return this+markCoverage; } 92 93 static inline bool accept (hb_buffer_t *buffer, unsigned idx) 94 { 95 /* We only want to attach to the first of a MultipleSubst sequence. 96 * https://github.com/harfbuzz/harfbuzz/issues/740 97 * Reject others... 98 * ...but stop if we find a mark in the MultipleSubst sequence: 99 * https://github.com/harfbuzz/harfbuzz/issues/1020 */ 100 return !_hb_glyph_info_multiplied (&buffer->info[idx]) || 101 0 == _hb_glyph_info_get_lig_comp (&buffer->info[idx]) || 102 (idx == 0 || 103 _hb_glyph_info_is_mark (&buffer->info[idx - 1]) || 104 !_hb_glyph_info_multiplied (&buffer->info[idx - 1]) || 105 _hb_glyph_info_get_lig_id (&buffer->info[idx]) != 106 _hb_glyph_info_get_lig_id (&buffer->info[idx - 1]) || 107 _hb_glyph_info_get_lig_comp (&buffer->info[idx]) != 108 _hb_glyph_info_get_lig_comp (&buffer->info[idx - 1]) + 1 109 ); 110 } 111 112 bool apply (hb_ot_apply_context_t *c) const 113 { 114 TRACE_APPLY (this); 115 hb_buffer_t *buffer = c->buffer; 116 unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint); 117 if (likely (mark_index == NOT_COVERED)) return_trace (false); 118 119 /* Now we search backwards for a non-mark glyph. 120 * We don't use skippy_iter.prev() to avoid O(n^2) behavior. */ 121 122 auto &skippy_iter = c->iter_input; 123 skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks); 124 125 if (c->last_base_until > buffer->idx) 126 { 127 c->last_base_until = 0; 128 c->last_base = -1; 129 } 130 unsigned j; 131 for (j = buffer->idx; j > c->last_base_until; j--) 132 { 133 auto match = skippy_iter.match (buffer->info[j - 1]); 134 if (match == skippy_iter.MATCH) 135 { 136 // https://github.com/harfbuzz/harfbuzz/issues/4124 137 if (!accept (buffer, j - 1) && 138 NOT_COVERED == (this+baseCoverage).get_coverage (buffer->info[j - 1].codepoint)) 139 match = skippy_iter.SKIP; 140 } 141 if (match == skippy_iter.MATCH) 142 { 143 c->last_base = (signed) j - 1; 144 break; 145 } 146 } 147 c->last_base_until = buffer->idx; 148 if (c->last_base == -1) 149 { 150 buffer->unsafe_to_concat_from_outbuffer (0, buffer->idx + 1); 151 return_trace (false); 152 } 153 154 unsigned idx = (unsigned) c->last_base; 155 156 /* Checking that matched glyph is actually a base glyph by GDEF is too strong; disabled */ 157 //if (!_hb_glyph_info_is_base_glyph (&buffer->info[idx])) { return_trace (false); } 158 159 unsigned int base_index = (this+baseCoverage).get_coverage (buffer->info[idx].codepoint); 160 if (base_index == NOT_COVERED) 161 { 162 buffer->unsafe_to_concat_from_outbuffer (idx, buffer->idx + 1); 163 return_trace (false); 164 } 165 166 return_trace ((this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, idx)); 167 } 168 169 bool subset (hb_subset_context_t *c) const 170 { 171 TRACE_SUBSET (this); 172 const hb_set_t &glyphset = *c->plan->glyphset_gsub (); 173 const hb_map_t &glyph_map = *c->plan->glyph_map; 174 175 auto *out = c->serializer->start_embed (*this); 176 if (unlikely (!c->serializer->extend_min (out))) return_trace (false); 177 out->format = format; 178 179 hb_map_t klass_mapping; 180 Markclass_closure_and_remap_indexes (this+markCoverage, this+markArray, glyphset, &klass_mapping); 181 182 if (!klass_mapping.get_population ()) return_trace (false); 183 out->classCount = klass_mapping.get_population (); 184 185 auto mark_iter = 186 + hb_zip (this+markCoverage, this+markArray) 187 | hb_filter (glyphset, hb_first) 188 ; 189 190 hb_sorted_vector_t<hb_codepoint_t> new_coverage; 191 + mark_iter 192 | hb_map (hb_first) 193 | hb_map (glyph_map) 194 | hb_sink (new_coverage) 195 ; 196 197 if (!out->markCoverage.serialize_serialize (c->serializer, new_coverage.iter ())) 198 return_trace (false); 199 200 if (unlikely (!out->markArray.serialize_subset (c, markArray, this, 201 (this+markCoverage).iter (), 202 &klass_mapping))) 203 return_trace (false); 204 205 unsigned basecount = (this+baseArray).rows; 206 auto base_iter = 207 + hb_zip (this+baseCoverage, hb_range (basecount)) 208 | hb_filter (glyphset, hb_first) 209 ; 210 211 new_coverage.reset (); 212 hb_sorted_vector_t<unsigned> base_indexes; 213 auto &base_array = (this+baseArray); 214 for (const auto _ : + base_iter) 215 { 216 unsigned row = _.second; 217 bool non_empty = + hb_range ((unsigned) classCount) 218 | hb_filter (klass_mapping) 219 | hb_map ([&] (const unsigned col) { return !base_array.offset_is_null (row, col, (unsigned) classCount); }) 220 | hb_any 221 ; 222 223 if (!non_empty) continue; 224 225 hb_codepoint_t new_g = glyph_map.get ( _.first); 226 new_coverage.push (new_g); 227 228 + hb_range ((unsigned) classCount) 229 | hb_filter (klass_mapping) 230 | hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; }) 231 | hb_sink (base_indexes) 232 ; 233 } 234 235 if (!new_coverage) return_trace (false); 236 if (!out->baseCoverage.serialize_serialize (c->serializer, new_coverage.iter ())) 237 return_trace (false); 238 239 return_trace (out->baseArray.serialize_subset (c, baseArray, this, 240 new_coverage.length, 241 base_indexes.iter ())); 242 } 243 }; 244 245 246 } 247 } 248 } 249 250 #endif /* OT_LAYOUT_GPOS_MARKBASEPOSFORMAT1_HH */