ttf_parser/tables/cff/
dict.rs

1use core::convert::TryFrom;
2use core::ops::Range;
3
4use crate::Stream;
5
6// Limits according to the Adobe Technical Note #5176, chapter 4 DICT Data.
7const TWO_BYTE_OPERATOR_MARK: u8 = 12;
8const END_OF_FLOAT_FLAG: u8 = 0xf;
9
10#[derive(Clone, Copy, Debug)]
11pub struct Operator(pub u16);
12
13impl Operator {
14    #[inline]
15    pub fn get(self) -> u16 { self.0 }
16}
17
18
19pub struct DictionaryParser<'a> {
20    data: &'a [u8],
21    // The current offset.
22    offset: usize,
23    // Offset to the last operands start.
24    operands_offset: usize,
25    // Actual operands.
26    operands: &'a mut [i32],
27    // An amount of operands in the `operands` array.
28    operands_len: u16,
29}
30
31impl<'a> DictionaryParser<'a> {
32    #[inline]
33    pub fn new(data: &'a [u8], operands_buffer: &'a mut [i32]) -> Self {
34        DictionaryParser {
35            data,
36            offset: 0,
37            operands_offset: 0,
38            operands: operands_buffer,
39            operands_len: 0,
40        }
41    }
42
43    #[inline(never)]
44    pub fn parse_next(&mut self) -> Option<Operator> {
45        let mut s = Stream::new_at(self.data, self.offset)?;
46        self.operands_offset = self.offset;
47        while !s.at_end() {
48            let b: u8 = s.read()?;
49            // 0..=21 bytes are operators.
50            if is_dict_one_byte_op(b) {
51                let mut operator = u16::from(b);
52
53                // Check that operator is two byte long.
54                if b == TWO_BYTE_OPERATOR_MARK {
55                    // Use a 1200 'prefix' to make two byte operators more readable.
56                    // 12 3 => 1203
57                    operator = 1200 + u16::from(s.read::<u8>()?);
58                }
59
60                self.offset = s.offset();
61                return Some(Operator(operator));
62            } else {
63                skip_number(b, &mut s)?;
64            }
65        }
66
67        None
68    }
69
70    /// Parses operands of the current operator.
71    ///
72    /// In the DICT structure, operands are defined before an operator.
73    /// So we are trying to find an operator first and the we can actually parse the operands.
74    ///
75    /// Since this methods is pretty expensive and we do not care about most of the operators,
76    /// we can speed up parsing by parsing operands only for required operators.
77    ///
78    /// We still have to "skip" operands during operators search (see `skip_number()`),
79    /// but it's still faster that a naive method.
80    pub fn parse_operands(&mut self) -> Option<()> {
81        let mut s = Stream::new_at(self.data, self.operands_offset)?;
82        self.operands_len = 0;
83        while !s.at_end() {
84            let b: u8 = s.read()?;
85            // 0..=21 bytes are operators.
86            if is_dict_one_byte_op(b) {
87                break;
88            } else {
89                let op = parse_number(b, &mut s)?;
90                self.operands[usize::from(self.operands_len)] = op;
91                self.operands_len += 1;
92
93                if usize::from(self.operands_len) >= self.operands.len() {
94                    break;
95                }
96            }
97        }
98
99        Some(())
100    }
101
102    #[inline]
103    pub fn operands(&self) -> &[i32] {
104        &self.operands[..usize::from(self.operands_len)]
105    }
106
107    #[inline]
108    pub fn parse_offset(&mut self) -> Option<usize> {
109        self.parse_operands()?;
110        let operands = self.operands();
111        if operands.len() == 1 {
112            usize::try_from(operands[0]).ok()
113        } else {
114            None
115        }
116    }
117
118    #[inline]
119    pub fn parse_range(&mut self) -> Option<Range<usize>> {
120        self.parse_operands()?;
121        let operands = self.operands();
122        if operands.len() == 2 {
123            let len = usize::try_from(operands[0]).ok()?;
124            let start = usize::try_from(operands[1]).ok()?;
125            let end = start.checked_add(len)?;
126            Some(start..end)
127        } else {
128            None
129        }
130    }
131}
132
133// One-byte CFF DICT Operators according to the
134// Adobe Technical Note #5176, Appendix H CFF DICT Encoding.
135pub fn is_dict_one_byte_op(b: u8) -> bool {
136    match b {
137        0..=27 => true,
138        28..=30 => false, // numbers
139        31 => true, // Reserved
140        32..=254 => false, // numbers
141        255 => true, // Reserved
142    }
143}
144
145// Adobe Technical Note #5177, Table 3 Operand Encoding
146pub fn parse_number(b0: u8, s: &mut Stream) -> Option<i32> {
147    match b0 {
148        28 => {
149            let n = i32::from(s.read::<i16>()?);
150            Some(n)
151        }
152        29 => {
153            let n = s.read::<i32>()?;
154            Some(n)
155        }
156        30 => {
157            // We do not parse float, because we don't use it.
158            // And by skipping it we can remove the core::num::dec2flt dependency.
159            while !s.at_end() {
160                let b1: u8 = s.read()?;
161                let nibble1 = b1 >> 4;
162                let nibble2 = b1 & 15;
163                if nibble1 == END_OF_FLOAT_FLAG || nibble2 == END_OF_FLOAT_FLAG {
164                    break;
165                }
166            }
167            Some(0)
168        }
169        32..=246 => {
170            let n = i32::from(b0) - 139;
171            Some(n)
172        }
173        247..=250 => {
174            let b1 = i32::from(s.read::<u8>()?);
175            let n = (i32::from(b0) - 247) * 256 + b1 + 108;
176            Some(n)
177        }
178        251..=254 => {
179            let b1 = i32::from(s.read::<u8>()?);
180            let n = -(i32::from(b0) - 251) * 256 - b1 - 108;
181            Some(n)
182        }
183        _ => None,
184    }
185}
186
187// Just like `parse_number`, but doesn't actually parses the data.
188pub fn skip_number(b0: u8, s: &mut Stream) -> Option<()> {
189    match b0 {
190        28 => s.skip::<u16>(),
191        29 => s.skip::<u32>(),
192        30 => {
193            while !s.at_end() {
194                let b1: u8 = s.read()?;
195                let nibble1 = b1 >> 4;
196                let nibble2 = b1 & 15;
197                if nibble1 == END_OF_FLOAT_FLAG || nibble2 == END_OF_FLOAT_FLAG {
198                    break;
199                }
200            }
201        }
202        32..=246 => {}
203        247..=250 => s.skip::<u8>(),
204        251..=254 => s.skip::<u8>(),
205        _ => return None,
206    }
207
208    Some(())
209}
210
211
212#[cfg(test)]
213mod tests {
214    use super::*;
215
216    #[test]
217    fn parse_dict_number() {
218        assert_eq!(parse_number(0xFA, &mut Stream::new(&[0x7C])).unwrap(), 1000);
219        assert_eq!(parse_number(0xFE, &mut Stream::new(&[0x7C])).unwrap(), -1000);
220        assert_eq!(parse_number(0x1C, &mut Stream::new(&[0x27, 0x10])).unwrap(), 10000);
221        assert_eq!(parse_number(0x1C, &mut Stream::new(&[0xD8, 0xF0])).unwrap(), -10000);
222        assert_eq!(parse_number(0x1D, &mut Stream::new(&[0x00, 0x01, 0x86, 0xA0])).unwrap(), 100000);
223        assert_eq!(parse_number(0x1D, &mut Stream::new(&[0xFF, 0xFE, 0x79, 0x60])).unwrap(), -100000);
224    }
225}
ttf_parser/tables/cff/dict.rs

ttf_parser/tables/cff/
dict.rs
