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 sanitizeOT::Layout::GPOS_impl::MarkBasePosFormat1_237 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 intersectsOT::Layout::GPOS_impl::MarkBasePosFormat1_247 bool intersects (const hb_set_t *glyphs) const 48 { 49 return (this+markCoverage).intersects (glyphs) && 50 (this+baseCoverage).intersects (glyphs); 51 } 52 closure_lookupsOT::Layout::GPOS_impl::MarkBasePosFormat1_253 void closure_lookups (hb_closure_lookups_context_t *c) const {} 54 collect_variation_indicesOT::Layout::GPOS_impl::MarkBasePosFormat1_255 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 collect_glyphsOT::Layout::GPOS_impl::MarkBasePosFormat1_285 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 get_coverageOT::Layout::GPOS_impl::MarkBasePosFormat1_291 const Coverage &get_coverage () const { return this+markCoverage; } 92 applyOT::Layout::GPOS_impl::MarkBasePosFormat1_293 bool apply (hb_ot_apply_context_t *c) const 94 { 95 TRACE_APPLY (this); 96 hb_buffer_t *buffer = c->buffer; 97 unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint); 98 if (likely (mark_index == NOT_COVERED)) return_trace (false); 99 100 /* Now we search backwards for a non-mark glyph */ 101 hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input; 102 skippy_iter.reset (buffer->idx, 1); 103 skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks); 104 do { 105 unsigned unsafe_from; 106 if (!skippy_iter.prev (&unsafe_from)) 107 { 108 buffer->unsafe_to_concat_from_outbuffer (unsafe_from, buffer->idx + 1); 109 return_trace (false); 110 } 111 112 /* We only want to attach to the first of a MultipleSubst sequence. 113 * https://github.com/harfbuzz/harfbuzz/issues/740 114 * Reject others... 115 * ...but stop if we find a mark in the MultipleSubst sequence: 116 * https://github.com/harfbuzz/harfbuzz/issues/1020 */ 117 if (!_hb_glyph_info_multiplied (&buffer->info[skippy_iter.idx]) || 118 0 == _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx]) || 119 (skippy_iter.idx == 0 || 120 _hb_glyph_info_is_mark (&buffer->info[skippy_iter.idx - 1]) || 121 !_hb_glyph_info_multiplied (&buffer->info[skippy_iter.idx - 1]) || 122 _hb_glyph_info_get_lig_id (&buffer->info[skippy_iter.idx]) != 123 _hb_glyph_info_get_lig_id (&buffer->info[skippy_iter.idx - 1]) || 124 _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx]) != 125 _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx - 1]) + 1 126 )) 127 break; 128 skippy_iter.reject (); 129 } while (true); 130 131 /* Checking that matched glyph is actually a base glyph by GDEF is too strong; disabled */ 132 //if (!_hb_glyph_info_is_base_glyph (&buffer->info[skippy_iter.idx])) { return_trace (false); } 133 134 unsigned int base_index = (this+baseCoverage).get_coverage (buffer->info[skippy_iter.idx].codepoint); 135 if (base_index == NOT_COVERED) 136 { 137 buffer->unsafe_to_concat_from_outbuffer (skippy_iter.idx, buffer->idx + 1); 138 return_trace (false); 139 } 140 141 return_trace ((this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, skippy_iter.idx)); 142 } 143 subsetOT::Layout::GPOS_impl::MarkBasePosFormat1_2144 bool subset (hb_subset_context_t *c) const 145 { 146 TRACE_SUBSET (this); 147 const hb_set_t &glyphset = *c->plan->glyphset_gsub (); 148 const hb_map_t &glyph_map = *c->plan->glyph_map; 149 150 auto *out = c->serializer->start_embed (*this); 151 if (unlikely (!c->serializer->extend_min (out))) return_trace (false); 152 out->format = format; 153 154 hb_map_t klass_mapping; 155 Markclass_closure_and_remap_indexes (this+markCoverage, this+markArray, glyphset, &klass_mapping); 156 157 if (!klass_mapping.get_population ()) return_trace (false); 158 out->classCount = klass_mapping.get_population (); 159 160 auto mark_iter = 161 + hb_zip (this+markCoverage, this+markArray) 162 | hb_filter (glyphset, hb_first) 163 ; 164 165 hb_sorted_vector_t<hb_codepoint_t> new_coverage; 166 + mark_iter 167 | hb_map (hb_first) 168 | hb_map (glyph_map) 169 | hb_sink (new_coverage) 170 ; 171 172 if (!out->markCoverage.serialize_serialize (c->serializer, new_coverage.iter ())) 173 return_trace (false); 174 175 out->markArray.serialize_subset (c, markArray, this, 176 (this+markCoverage).iter (), 177 &klass_mapping); 178 179 unsigned basecount = (this+baseArray).rows; 180 auto base_iter = 181 + hb_zip (this+baseCoverage, hb_range (basecount)) 182 | hb_filter (glyphset, hb_first) 183 ; 184 185 new_coverage.reset (); 186 + base_iter 187 | hb_map (hb_first) 188 | hb_map (glyph_map) 189 | hb_sink (new_coverage) 190 ; 191 192 if (!out->baseCoverage.serialize_serialize (c->serializer, new_coverage.iter ())) 193 return_trace (false); 194 195 hb_sorted_vector_t<unsigned> base_indexes; 196 for (const unsigned row : + base_iter 197 | hb_map (hb_second)) 198 { 199 + hb_range ((unsigned) classCount) 200 | hb_filter (klass_mapping) 201 | hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; }) 202 | hb_sink (base_indexes) 203 ; 204 } 205 206 out->baseArray.serialize_subset (c, baseArray, this, 207 base_iter.len (), 208 base_indexes.iter ()); 209 210 return_trace (true); 211 } 212 }; 213 214 215 } 216 } 217 } 218 219 #endif /* OT_LAYOUT_GPOS_MARKBASEPOSFORMAT1_HH */ 220