Skip to main content

read_fonts/tables/
trak.rs

1//! The [tracking (trak)](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6trak.html) table.
2
3include!("../../generated/generated_trak.rs");
4
5impl<'a> TrackData<'a> {
6    /// Returns the size table for this set of tracking data.
7    ///
8    /// The `offset_data` parameter comes from the [`Trak`] table.
9    pub fn size_table(&self, offset_data: FontData<'a>) -> Option<&'a [BigEndian<Fixed>]> {
10        let mut cursor = offset_data
11            .split_off(self.size_table_offset() as usize)?
12            .cursor();
13        cursor.read_array(self.n_sizes() as usize).ok()
14    }
15}
16
17impl TrackTableEntry {
18    /// Returns the list of per-size tracking values for this entry.
19    ///
20    /// The `offset_data` parameter comes from the [`Trak`] table and `n_sizes`
21    /// parameter comes from the parent [`TrackData`] table.
22    pub fn per_size_values<'a>(
23        &self,
24        offset_data: FontData<'a>,
25        n_sizes: u16,
26    ) -> Option<&'a [BigEndian<i16>]> {
27        let mut cursor = offset_data.split_off(self.offset() as usize)?.cursor();
28        cursor.read_array(n_sizes as usize).ok()
29    }
30}
31
32#[cfg(test)]
33mod tests {
34    use super::*;
35    use font_test_data::bebuffer::BeBuffer;
36
37    #[test]
38    fn parse_header() {
39        let table_data = example_track_table();
40        let trak = Trak::read(FontData::new(&table_data)).unwrap();
41        assert_eq!(trak.version(), MajorMinor::VERSION_1_0);
42        let _ = trak.horiz().unwrap().unwrap();
43        assert!(trak.vert().is_none());
44    }
45
46    #[test]
47    fn parse_tracks() {
48        let table_data = example_track_table();
49        let trak = Trak::read(FontData::new(&table_data)).unwrap();
50        let horiz = trak.horiz().unwrap().unwrap();
51        let track_table = horiz.track_table();
52        let expected_tracks = [
53            (Fixed::from_i32(-1), NameId::new(256), 52),
54            (Fixed::from_i32(0), NameId::new(258), 60),
55            (Fixed::from_i32(1), NameId::new(257), 56),
56        ];
57        let tracks = track_table
58            .iter()
59            .map(|track| (track.track(), track.name_index(), track.offset()))
60            .collect::<Vec<_>>();
61        assert_eq!(tracks, expected_tracks);
62        let expected_per_size_tracking_values = [[-15i16, -7], [0, 0], [50, 20]];
63        for (track, expected_values) in track_table.iter().zip(expected_per_size_tracking_values) {
64            let values = track
65                .per_size_values(trak.offset_data(), horiz.n_sizes())
66                .unwrap()
67                .iter()
68                .map(|v| v.get())
69                .collect::<Vec<_>>();
70            assert_eq!(values, expected_values);
71        }
72    }
73
74    #[test]
75    fn parse_per_size_values() {
76        let table_data = example_track_table();
77        let trak = Trak::read(FontData::new(&table_data)).unwrap();
78        let horiz = trak.horiz().unwrap().unwrap();
79        let track_table = horiz.track_table();
80        let expected_per_size_tracking_values = [[-15i16, -7], [0, 0], [50, 20]];
81        for (track, expected_values) in track_table.iter().zip(expected_per_size_tracking_values) {
82            let values = track
83                .per_size_values(trak.offset_data(), horiz.n_sizes())
84                .unwrap()
85                .iter()
86                .map(|v| v.get())
87                .collect::<Vec<_>>();
88            assert_eq!(values, expected_values);
89        }
90    }
91
92    #[test]
93    fn parse_sizes() {
94        let table_data = example_track_table();
95        let trak = Trak::read(FontData::new(&table_data)).unwrap();
96        let horiz = trak.horiz().unwrap().unwrap();
97        let size_table = horiz
98            .size_table(trak.offset_data())
99            .unwrap()
100            .iter()
101            .map(|v| v.get())
102            .collect::<Vec<_>>();
103        let expected_sizes = [Fixed::from_i32(12), Fixed::from_i32(24)];
104        assert_eq!(size_table, expected_sizes);
105    }
106
107    #[test]
108    fn insufficient_data() {
109        let mut table_data = example_track_table();
110        // drop the last byte from the final per size value entry
111        table_data.pop();
112        let trak = Trak::read(FontData::new(&table_data)).unwrap();
113        let horiz = trak.horiz().unwrap().unwrap();
114        let track_table = horiz.track_table();
115        // The values for the second track will fail to parse
116        let expected_per_size_tracking_values = [Some([-15i16, -7]), None, Some([50, 20])];
117        for (track, expected_values) in track_table.iter().zip(expected_per_size_tracking_values) {
118            let values = track
119                .per_size_values(trak.offset_data(), horiz.n_sizes())
120                .map(|values| values.iter().map(|v| v.get()).collect::<Vec<_>>());
121            assert_eq!(
122                values,
123                expected_values.map(|value| value.into_iter().collect())
124            );
125        }
126    }
127
128    #[test]
129    fn bad_offset() {
130        let mut table_data = example_track_table();
131        // modify offset of first track table entry to be OOB
132        table_data[26] = 255;
133        let trak = Trak::read(FontData::new(&table_data)).unwrap();
134        let horiz = trak.horiz().unwrap().unwrap();
135        let track_table = horiz.track_table();
136        assert!(track_table[0]
137            .per_size_values(trak.offset_data(), horiz.n_sizes())
138            .is_none());
139    }
140
141    /// From <https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6trak.html>
142    fn example_track_table() -> Vec<u8> {
143        let mut buf = BeBuffer::new();
144        // header
145        buf = buf.push(MajorMinor::VERSION_1_0);
146        buf = buf.extend([0u16, 12, 0, 0]);
147        // TrackData
148        buf = buf.extend([3u16, 2]);
149        buf = buf.push(44u32);
150        // Three sorted TrackTableEntry records
151        buf = buf.push(0xFFFF0000u32).extend([256u16, 52]);
152        buf = buf.push(0x00000000u32).extend([258u16, 60]);
153        buf = buf.push(0x00010000u32).extend([257u16, 56]);
154        // Size subtable
155        buf = buf.push(0x000C0000u32);
156        buf = buf.push(0x00180000u32);
157        // Per-size tracking data values
158        buf = buf.extend([-15i16, -7, 50, 20, 0, 0]);
159        buf.to_vec()
160    }
161}