1use alloc::vec::Vec;
2use core::cmp::Ordering;
3use core::ops::Range;
4use ttf_parser::FromData;
5
6use ttf_parser::opentype_layout::{
7 FeatureIndex, LanguageIndex, LookupIndex, ScriptIndex, VariationIndex,
8};
9
10use super::buffer::{glyph_flag, hb_buffer_t};
11use super::ot_layout::{LayoutTableExt, TableIndex};
12use super::ot_shape_plan::hb_ot_shape_plan_t;
13use super::{hb_font_t, hb_mask_t, hb_tag_t, tag, Language, Script};
14
15pub struct hb_ot_map_t {
16 found_script: [bool; 2],
17 chosen_script: [Option<hb_tag_t>; 2],
18 global_mask: hb_mask_t,
19 features: Vec<feature_map_t>,
20 lookups: [Vec<lookup_map_t>; 2],
21 stages: [Vec<StageMap>; 2],
22}
23
24#[derive(Clone, Copy, Debug, PartialEq, Eq)]
25pub struct feature_map_t {
26 tag: hb_tag_t,
27 // GSUB/GPOS
28 index: [Option<FeatureIndex>; 2],
29 stage: [usize; 2],
30 shift: u32,
31 mask: hb_mask_t,
32 // mask for value=1, for quick access
33 one_mask: hb_mask_t,
34 auto_zwnj: bool,
35 auto_zwj: bool,
36 random: bool,
37 per_syllable: bool,
38}
39
40impl Ord for feature_map_t {
41 fn cmp(&self, other: &Self) -> Ordering {
42 self.tag.cmp(&other.tag)
43 }
44}
45
46impl PartialOrd for feature_map_t {
47 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
48 self.tag.partial_cmp(&other.tag)
49 }
50}
51
52#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
53pub struct lookup_map_t {
54 pub index: LookupIndex,
55 // TODO: to bitflags
56 pub auto_zwnj: bool,
57 pub auto_zwj: bool,
58 pub random: bool,
59 pub mask: hb_mask_t,
60 pub per_syllable: bool,
61}
62
63#[derive(Clone, Copy)]
64pub struct StageMap {
65 // Cumulative
66 pub last_lookup: usize,
67 pub pause_func: Option<pause_func_t>,
68}
69
70// Pause functions return true if new glyph indices might have been added to the buffer.
71// This is used to update buffer digest.
72pub type pause_func_t = fn(&hb_ot_shape_plan_t, &hb_font_t, &mut hb_buffer_t) -> bool;
73
74impl hb_ot_map_t {
75 pub const MAX_BITS: u32 = 8;
76 pub const MAX_VALUE: u32 = (1 << Self::MAX_BITS) - 1;
77
78 #[inline]
79 pub fn found_script(&self, table_index: TableIndex) -> bool {
80 self.found_script[table_index]
81 }
82
83 #[inline]
84 pub fn chosen_script(&self, table_index: TableIndex) -> Option<hb_tag_t> {
85 self.chosen_script[table_index]
86 }
87
88 #[inline]
89 pub fn get_global_mask(&self) -> hb_mask_t {
90 self.global_mask
91 }
92
93 #[inline]
94 pub fn get_mask(&self, feature_tag: hb_tag_t) -> (hb_mask_t, u32) {
95 self.features
96 .binary_search_by_key(&feature_tag, |f| f.tag)
97 .map_or((0, 0), |idx| {
98 (self.features[idx].mask, self.features[idx].shift)
99 })
100 }
101
102 #[inline]
103 pub fn get_1_mask(&self, feature_tag: hb_tag_t) -> hb_mask_t {
104 self.features
105 .binary_search_by_key(&feature_tag, |f| f.tag)
106 .map_or(0, |idx| self.features[idx].one_mask)
107 }
108
109 #[inline]
110 pub fn get_feature_index(
111 &self,
112 table_index: TableIndex,
113 feature_tag: hb_tag_t,
114 ) -> Option<FeatureIndex> {
115 self.features
116 .binary_search_by_key(&feature_tag, |f| f.tag)
117 .ok()
118 .and_then(|idx| self.features[idx].index[table_index])
119 }
120
121 #[inline]
122 pub fn get_feature_stage(
123 &self,
124 table_index: TableIndex,
125 feature_tag: hb_tag_t,
126 ) -> Option<usize> {
127 self.features
128 .binary_search_by_key(&feature_tag, |f| f.tag)
129 .map(|idx| self.features[idx].stage[table_index])
130 .ok()
131 }
132
133 #[inline]
134 pub fn stages(&self, table_index: TableIndex) -> &[StageMap] {
135 &self.stages[table_index]
136 }
137
138 #[inline]
139 pub fn lookup(&self, table_index: TableIndex, index: usize) -> &lookup_map_t {
140 &self.lookups[table_index][index]
141 }
142
143 #[inline]
144 pub fn stage_lookups(&self, table_index: TableIndex, stage: usize) -> &[lookup_map_t] {
145 &self.lookups[table_index][self.stage_lookup_range(table_index, stage)]
146 }
147
148 #[inline]
149 pub fn stage_lookup_range(&self, table_index: TableIndex, stage: usize) -> Range<usize> {
150 let stages = &self.stages[table_index];
151 let lookups = &self.lookups[table_index];
152 let start = stage
153 .checked_sub(1)
154 .map_or(0, |prev| stages[prev].last_lookup);
155 let end = stages
156 .get(stage)
157 .map_or(lookups.len(), |curr| curr.last_lookup);
158 start..end
159 }
160}
161
162pub type hb_ot_map_feature_flags_t = u32;
163pub const F_NONE: u32 = 0x0000;
164pub const F_GLOBAL: u32 = 0x0001; /* Feature applies to all characters; results in no mask allocated for it. */
165pub const F_HAS_FALLBACK: u32 = 0x0002; /* Has fallback implementation, so include mask bit even if feature not found. */
166pub const F_MANUAL_ZWNJ: u32 = 0x0004; /* Don't skip over ZWNJ when matching **context**. */
167pub const F_MANUAL_ZWJ: u32 = 0x0008; /* Don't skip over ZWJ when matching **input**. */
168pub const F_MANUAL_JOINERS: u32 = F_MANUAL_ZWNJ | F_MANUAL_ZWJ;
169pub const F_GLOBAL_MANUAL_JOINERS: u32 = F_GLOBAL | F_MANUAL_JOINERS;
170pub const F_GLOBAL_HAS_FALLBACK: u32 = F_GLOBAL | F_HAS_FALLBACK;
171pub const F_GLOBAL_SEARCH: u32 = 0x0010; /* If feature not found in LangSys, look for it in global feature list and pick one. */
172pub const F_RANDOM: u32 = 0x0020; /* Randomly select a glyph from an AlternateSubstFormat1 subtable. */
173pub const F_PER_SYLLABLE: u32 = 0x0040; /* Contain lookup application to within syllable. */
174
175pub struct hb_ot_map_builder_t<'a> {
176 face: &'a hb_font_t<'a>,
177 found_script: [bool; 2],
178 script_index: [Option<ScriptIndex>; 2],
179 chosen_script: [Option<hb_tag_t>; 2],
180 lang_index: [Option<LanguageIndex>; 2],
181 current_stage: [usize; 2],
182 feature_infos: Vec<feature_info_t>,
183 stages: [Vec<stage_info_t>; 2],
184 pub(crate) is_simple: bool,
185}
186
187#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
188struct feature_info_t {
189 tag: hb_tag_t,
190 // sequence number, used for stable sorting only
191 seq: usize,
192 max_value: u32,
193 flags: hb_ot_map_feature_flags_t,
194 // for non-global features, what should the unset glyphs take
195 default_value: u32,
196 // GSUB/GPOS
197 stage: [usize; 2],
198}
199
200#[derive(Clone, Copy)]
201struct stage_info_t {
202 index: usize,
203 pause_func: Option<pause_func_t>,
204}
205
206const GLOBAL_BIT_SHIFT: u32 = 8 * u32::SIZE as u32 - 1;
207const GLOBAL_BIT_MASK: hb_mask_t = 1 << GLOBAL_BIT_SHIFT;
208
209impl<'a> hb_ot_map_builder_t<'a> {
210 pub fn new(
211 face: &'a hb_font_t<'a>,
212 script: Option<Script>,
213 language: Option<&Language>,
214 ) -> Self {
215 // Fetch script/language indices for GSUB/GPOS. We need these later to skip
216 // features not available in either table and not waste precious bits for them.
217 let (script_tags, lang_tags) = tag::tags_from_script_and_language(script, language);
218
219 let mut found_script = [false; 2];
220 let mut script_index = [None; 2];
221 let mut chosen_script = [None; 2];
222 let mut lang_index = [None; 2];
223
224 for (table_index, table) in face.layout_tables() {
225 if let Some((found, idx, tag)) = table.select_script(&script_tags) {
226 chosen_script[table_index] = Some(tag);
227 found_script[table_index] = found;
228 script_index[table_index] = Some(idx);
229
230 if let Some(idx) = table.select_script_language(idx, &lang_tags) {
231 lang_index[table_index] = Some(idx);
232 }
233 }
234 }
235
236 Self {
237 face,
238 found_script,
239 script_index,
240 chosen_script,
241 lang_index,
242 current_stage: [0, 0],
243 feature_infos: Vec::new(),
244 stages: [Vec::new(), Vec::new()],
245 is_simple: false,
246 }
247 }
248
249 #[inline]
250 pub fn chosen_script(&self, table_index: TableIndex) -> Option<hb_tag_t> {
251 self.chosen_script[table_index]
252 }
253
254 #[inline]
255 pub fn has_feature(&self, tag: hb_tag_t) -> bool {
256 for (table_index, table) in self.face.layout_tables() {
257 if let Some(script_index) = self.script_index[table_index] {
258 if table
259 .find_language_feature(script_index, self.lang_index[table_index], tag)
260 .is_some()
261 {
262 return true;
263 }
264 }
265 }
266
267 false
268 }
269
270 #[inline]
271 pub fn add_feature(&mut self, tag: hb_tag_t, flags: hb_ot_map_feature_flags_t, value: u32) {
272 if !tag.is_null() {
273 let seq = self.feature_infos.len();
274 self.feature_infos.push(feature_info_t {
275 tag,
276 seq,
277 max_value: value,
278 flags,
279 default_value: if flags & F_GLOBAL != 0 { value } else { 0 },
280 stage: self.current_stage,
281 });
282 }
283 }
284
285 #[inline]
286 pub fn enable_feature(&mut self, tag: hb_tag_t, flags: hb_ot_map_feature_flags_t, value: u32) {
287 self.add_feature(tag, flags | F_GLOBAL, value);
288 }
289
290 #[inline]
291 pub fn disable_feature(&mut self, tag: hb_tag_t) {
292 self.add_feature(tag, F_GLOBAL, 0);
293 }
294
295 #[inline]
296 pub fn add_gsub_pause(&mut self, pause: Option<pause_func_t>) {
297 self.add_pause(TableIndex::GSUB, pause);
298 }
299
300 #[inline]
301 pub fn add_gpos_pause(&mut self, pause: Option<pause_func_t>) {
302 self.add_pause(TableIndex::GPOS, pause);
303 }
304
305 fn add_pause(&mut self, table_index: TableIndex, pause: Option<pause_func_t>) {
306 self.stages[table_index].push(stage_info_t {
307 index: self.current_stage[table_index],
308 pause_func: pause,
309 });
310
311 self.current_stage[table_index] += 1;
312 }
313
314 pub fn compile(&mut self) -> hb_ot_map_t {
315 // We default to applying required feature in stage 0. If the required
316 // feature has a tag that is known to the shaper, we apply required feature
317 // in the stage for that tag.
318 let mut required_index = [None; 2];
319 let mut required_tag = [None; 2];
320
321 for (table_index, table) in self.face.layout_tables() {
322 if let Some(script) = self.script_index[table_index] {
323 let lang = self.lang_index[table_index];
324 if let Some((idx, tag)) = table.get_required_language_feature(script, lang) {
325 required_index[table_index] = Some(idx);
326 required_tag[table_index] = Some(tag);
327 }
328 }
329 }
330
331 let (features, required_stage, global_mask) = self.collect_feature_maps(required_tag);
332
333 self.add_gsub_pause(None);
334 self.add_gpos_pause(None);
335
336 let (lookups, stages) =
337 self.collect_lookup_stages(&features, required_index, required_stage);
338
339 hb_ot_map_t {
340 found_script: self.found_script,
341 chosen_script: self.chosen_script,
342 global_mask,
343 features,
344 lookups,
345 stages,
346 }
347 }
348
349 fn collect_feature_maps(
350 &mut self,
351 required_tag: [Option<hb_tag_t>; 2],
352 ) -> (Vec<feature_map_t>, [usize; 2], hb_mask_t) {
353 let mut map_features = Vec::new();
354 let mut required_stage = [0; 2];
355 let mut global_mask = GLOBAL_BIT_MASK;
356 let mut next_bit = glyph_flag::DEFINED.count_ones() + 1;
357
358 // Sort features and merge duplicates.
359 self.dedup_feature_infos();
360
361 for info in &self.feature_infos {
362 let bits_needed = if info.flags & F_GLOBAL != 0 && info.max_value == 1 {
363 // Uses the global bit.
364 0
365 } else {
366 // Limit bits per feature.
367 let v = info.max_value;
368 let num_bits = 8 * core::mem::size_of_val(&v) as u32 - v.leading_zeros();
369 hb_ot_map_t::MAX_BITS.min(num_bits)
370 };
371
372 if info.max_value == 0 || next_bit + bits_needed >= GLOBAL_BIT_SHIFT {
373 // Feature disabled, or not enough bits.
374 continue;
375 }
376
377 let mut found = false;
378 let mut feature_index = [None; 2];
379
380 for (table_index, table) in self.face.layout_tables() {
381 if required_tag[table_index] == Some(info.tag) {
382 required_stage[table_index] = info.stage[table_index];
383 }
384
385 if let Some(script) = self.script_index[table_index] {
386 let lang = self.lang_index[table_index];
387 if let Some(idx) = table.find_language_feature(script, lang, info.tag) {
388 feature_index[table_index] = Some(idx);
389 found = true;
390 }
391 }
392 }
393
394 if !found && info.flags & F_GLOBAL_SEARCH != 0 {
395 // hb_ot_layout_table_find_feature
396 for (table_index, table) in self.face.layout_tables() {
397 if let Some(idx) = table.features.index(info.tag) {
398 feature_index[table_index] = Some(idx);
399 found = true;
400 }
401 }
402 }
403
404 if !found && !info.flags & F_HAS_FALLBACK != 0 {
405 continue;
406 }
407
408 let (shift, mask) = if info.flags & F_GLOBAL != 0 && info.max_value == 1 {
409 // Uses the global bit
410 (GLOBAL_BIT_SHIFT, GLOBAL_BIT_MASK)
411 } else {
412 let shift = next_bit;
413 let mask = (1 << (next_bit + bits_needed)) - (1 << next_bit);
414 next_bit += bits_needed;
415 global_mask |= (info.default_value << shift) & mask;
416 (shift, mask)
417 };
418
419 map_features.push(feature_map_t {
420 tag: info.tag,
421 index: feature_index,
422 stage: info.stage,
423 shift,
424 mask,
425 one_mask: (1 << shift) & mask,
426 auto_zwnj: info.flags & F_MANUAL_ZWNJ == 0,
427 auto_zwj: info.flags & F_MANUAL_ZWJ == 0,
428 random: info.flags & F_RANDOM != 0,
429 per_syllable: info.flags & F_PER_SYLLABLE != 0,
430 });
431 }
432
433 if self.is_simple {
434 map_features.sort();
435 }
436
437 (map_features, required_stage, global_mask)
438 }
439
440 fn dedup_feature_infos(&mut self) {
441 let feature_infos = &mut self.feature_infos;
442 if feature_infos.is_empty() {
443 return;
444 }
445
446 if !self.is_simple {
447 feature_infos.sort();
448 }
449
450 let mut j = 0;
451 for i in 1..feature_infos.len() {
452 if feature_infos[i].tag != feature_infos[j].tag {
453 j += 1;
454 feature_infos[j] = feature_infos[i];
455 } else {
456 if feature_infos[i].flags & F_GLOBAL != 0 {
457 feature_infos[j].flags |= F_GLOBAL;
458 feature_infos[j].max_value = feature_infos[i].max_value;
459 feature_infos[j].default_value = feature_infos[i].default_value;
460 } else {
461 if feature_infos[j].flags & F_GLOBAL != 0 {
462 feature_infos[j].flags ^= F_GLOBAL;
463 }
464 feature_infos[j].max_value =
465 feature_infos[j].max_value.max(feature_infos[i].max_value);
466 // Inherit default_value from j
467 }
468 let flags = feature_infos[i].flags & F_HAS_FALLBACK;
469 feature_infos[j].flags |= flags;
470 feature_infos[j].stage[0] =
471 feature_infos[j].stage[0].min(feature_infos[i].stage[0]);
472 feature_infos[j].stage[1] =
473 feature_infos[j].stage[1].min(feature_infos[i].stage[1]);
474 }
475 }
476
477 feature_infos.truncate(j + 1);
478 }
479
480 fn collect_lookup_stages(
481 &self,
482 map_features: &[feature_map_t],
483 required_feature_index: [Option<FeatureIndex>; 2],
484 required_feature_stage: [usize; 2],
485 ) -> ([Vec<lookup_map_t>; 2], [Vec<StageMap>; 2]) {
486 let mut map_lookups = [Vec::new(), Vec::new()];
487 let mut map_stages = [Vec::new(), Vec::new()];
488
489 for table_index in TableIndex::iter() {
490 // Collect lookup indices for features.
491 let mut stage_index = 0;
492 let mut last_lookup = 0;
493
494 let coords = self.face.ttfp_face.variation_coordinates();
495 let variation_index = self
496 .face
497 .layout_table(table_index)
498 .and_then(|t| t.variations?.find_index(coords));
499
500 for stage in 0..self.current_stage[table_index] {
501 if let Some(feature_index) = required_feature_index[table_index] {
502 if required_feature_stage[table_index] == stage {
503 self.add_lookups(
504 &mut map_lookups[table_index],
505 table_index,
506 feature_index,
507 variation_index,
508 GLOBAL_BIT_MASK,
509 true,
510 true,
511 false,
512 false,
513 );
514 }
515 }
516
517 for feature in map_features {
518 if let Some(feature_index) = feature.index[table_index] {
519 if feature.stage[table_index] == stage {
520 self.add_lookups(
521 &mut map_lookups[table_index],
522 table_index,
523 feature_index,
524 variation_index,
525 feature.mask,
526 feature.auto_zwnj,
527 feature.auto_zwj,
528 feature.random,
529 feature.per_syllable,
530 );
531 }
532 }
533 }
534
535 // Sort lookups and merge duplicates.
536 let lookups = &mut map_lookups[table_index];
537 let len = lookups.len();
538
539 if last_lookup + 1 < len {
540 lookups[last_lookup..].sort();
541
542 let mut j = last_lookup;
543 for i in j + 1..len {
544 if lookups[i].index != lookups[j].index {
545 j += 1;
546 lookups[j] = lookups[i];
547 } else {
548 lookups[j].mask |= lookups[i].mask;
549 lookups[j].auto_zwnj &= lookups[i].auto_zwnj;
550 lookups[j].auto_zwj &= lookups[i].auto_zwj;
551 }
552 }
553
554 lookups.truncate(j + 1);
555 }
556
557 last_lookup = lookups.len();
558
559 if let Some(info) = self.stages[table_index].get(stage_index) {
560 if info.index == stage {
561 map_stages[table_index].push(StageMap {
562 last_lookup,
563 pause_func: info.pause_func,
564 });
565
566 stage_index += 1;
567 }
568 }
569 }
570 }
571
572 (map_lookups, map_stages)
573 }
574
575 fn add_lookups(
576 &self,
577 lookups: &mut Vec<lookup_map_t>,
578 table_index: TableIndex,
579 feature_index: FeatureIndex,
580 variation_index: Option<VariationIndex>,
581 mask: hb_mask_t,
582 auto_zwnj: bool,
583 auto_zwj: bool,
584 random: bool,
585 per_syllable: bool,
586 ) -> Option<()> {
587 let table = self.face.layout_table(table_index)?;
588
589 let lookup_count = table.lookups.len();
590 let feature = match variation_index {
591 Some(idx) => table
592 .variations
593 .and_then(|var| var.find_substitute(feature_index, idx))
594 .or_else(|| table.features.get(feature_index))?,
595 None => table.features.get(feature_index)?,
596 };
597
598 for index in feature.lookup_indices {
599 if index < lookup_count {
600 lookups.push(lookup_map_t {
601 mask,
602 index,
603 auto_zwnj,
604 auto_zwj,
605 random,
606 per_syllable,
607 });
608 }
609 }
610
611 Some(())
612 }
613}
614