read_fonts/tables/
cff.rs

1//! The [CFF](https://learn.microsoft.com/en-us/typography/opentype/spec/cff) table
2
3include!("../../generated/generated_cff.rs");
4
5use super::postscript::{dict, Charset, Error, Index1, Latin1String, StringId};
6
7/// The [Compact Font Format](https://learn.microsoft.com/en-us/typography/opentype/spec/cff) table.
8#[derive(Clone)]
9pub struct Cff<'a> {
10    header: CffHeader<'a>,
11    names: Index1<'a>,
12    top_dicts: Index1<'a>,
13    strings: Index1<'a>,
14    global_subrs: Index1<'a>,
15}
16
17impl<'a> Cff<'a> {
18    pub fn offset_data(&self) -> FontData<'a> {
19        self.header.offset_data()
20    }
21
22    pub fn header(&self) -> CffHeader<'a> {
23        self.header.clone()
24    }
25
26    /// Returns the name index.
27    ///
28    /// This contains the PostScript names of all fonts in the font set.
29    ///
30    /// See "Name INDEX" at <https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf#page=13>
31    pub fn names(&self) -> Index1<'a> {
32        self.names.clone()
33    }
34
35    /// Returns the PostScript name for the font in the font set at the
36    /// given index.
37    pub fn name(&self, index: usize) -> Option<Latin1String<'a>> {
38        Some(Latin1String::new(self.names.get(index).ok()?))
39    }
40
41    /// Returns the top dict index.
42    ///
43    /// This contains the top-level DICTs of all fonts in the font set. The
44    /// objects here correspond to those in the name index.
45    ///
46    /// See "Top DICT INDEX" at <https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf#page=14>
47    pub fn top_dicts(&self) -> Index1<'a> {
48        self.top_dicts.clone()
49    }
50
51    /// Returns the string index.
52    ///
53    /// This contains all of the strings used by fonts within the font set.
54    /// They are referenced by string identifiers represented by the
55    /// [`StringId`] type.
56    ///
57    /// See "String INDEX" at <https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf#page=17>
58    pub fn strings(&self) -> Index1<'a> {
59        self.strings.clone()
60    }
61
62    /// Returns the associated string for the given identifier.
63    ///
64    /// If the identifier does not represent a standard string, the result is
65    /// looked up in the string index.
66    pub fn string(&self, id: StringId) -> Option<Latin1String<'a>> {
67        match id.standard_string() {
68            Ok(name) => Some(name),
69            Err(ix) => self.strings.get(ix).ok().map(Latin1String::new),
70        }
71    }
72
73    /// Returns the global subroutine index.
74    ///
75    /// This contains sub-programs that are referenced by one or more
76    /// charstrings in the font set.
77    ///
78    /// See "Local/Global Subrs INDEXes" at <https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf#page=25>
79    pub fn global_subrs(&self) -> Index1<'a> {
80        self.global_subrs.clone()
81    }
82
83    /// Returns the character set associated with the top dict at the given
84    /// index.
85    ///
86    /// See "Charsets" at <https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf#page=21>
87    pub fn charset(&self, top_dict_index: usize) -> Result<Option<Charset<'a>>, Error> {
88        let top_dict = self.top_dicts().get(top_dict_index)?;
89        let offset_data = self.offset_data();
90        let mut charset_offset: Option<usize> = None;
91        let mut num_glyphs: Option<u32> = None;
92        for entry in dict::entries(top_dict, None) {
93            match entry {
94                Ok(dict::Entry::Charset(offset)) => {
95                    charset_offset = Some(offset);
96                }
97                Ok(dict::Entry::CharstringsOffset(offset)) => {
98                    num_glyphs = Some(
99                        Index1::read(
100                            offset_data
101                                .split_off(offset)
102                                .ok_or(ReadError::OutOfBounds)?,
103                        )?
104                        .count() as u32,
105                    );
106                }
107                // The ROS operator signifies a CID-keyed font and the charset
108                // maps to CIDs rather than SIDs which we don't parse for
109                // glyph names.
110                // <https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf#page=28>
111                Ok(dict::Entry::Ros { .. }) => {
112                    return Ok(None);
113                }
114                _ => {}
115            }
116        }
117        if let Some((charset_offset, num_glyphs)) = charset_offset.zip(num_glyphs) {
118            Ok(Some(Charset::new(offset_data, charset_offset, num_glyphs)?))
119        } else {
120            Ok(None)
121        }
122    }
123}
124
125impl TopLevelTable for Cff<'_> {
126    const TAG: Tag = Tag::new(b"CFF ");
127}
128
129impl<'a> FontRead<'a> for Cff<'a> {
130    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
131        let header = CffHeader::read(data)?;
132        let mut data = FontData::new(header.trailing_data());
133        let names = Index1::read(data)?;
134        data = data
135            .split_off(names.size_in_bytes()?)
136            .ok_or(ReadError::OutOfBounds)?;
137        let top_dicts = Index1::read(data)?;
138        data = data
139            .split_off(top_dicts.size_in_bytes()?)
140            .ok_or(ReadError::OutOfBounds)?;
141        let strings = Index1::read(data)?;
142        data = data
143            .split_off(strings.size_in_bytes()?)
144            .ok_or(ReadError::OutOfBounds)?;
145        let global_subrs = Index1::read(data)?;
146        Ok(Self {
147            header,
148            names,
149            top_dicts,
150            strings,
151            global_subrs,
152        })
153    }
154}
155
156#[cfg(test)]
157mod tests {
158    use super::*;
159    use crate::{tables::postscript::StringId, FontRef, TableProvider};
160
161    #[test]
162    fn read_noto_serif_display_cff() {
163        let font = FontRef::new(font_test_data::NOTO_SERIF_DISPLAY_TRIMMED).unwrap();
164        let cff = font.cff().unwrap();
165        assert_eq!(cff.header().major(), 1);
166        assert_eq!(cff.header().minor(), 0);
167        assert_eq!(cff.top_dicts().count(), 1);
168        assert_eq!(cff.names().count(), 1);
169        assert_eq!(cff.global_subrs.count(), 17);
170        let name = Latin1String::new(cff.names().get(0).unwrap());
171        assert_eq!(name, "NotoSerifDisplay-Regular");
172        assert_eq!(cff.strings().count(), 5);
173        // Version
174        assert_eq!(cff.string(StringId::new(391)).unwrap(), "2.9");
175        // Notice
176        assert_eq!(
177            cff.string(StringId::new(392)).unwrap(),
178            "Noto is a trademark of Google LLC."
179        );
180        // Copyright
181        assert_eq!(
182            cff.string(StringId::new(393)).unwrap(),
183            "Copyright 2022 The Noto Project Authors https:github.comnotofontslatin-greek-cyrillic"
184        );
185        // FullName
186        assert_eq!(
187            cff.string(StringId::new(394)).unwrap(),
188            "Noto Serif Display Regular"
189        );
190        // FamilyName
191        assert_eq!(
192            cff.string(StringId::new(395)).unwrap(),
193            "Noto Serif Display"
194        );
195    }
196
197    #[test]
198    fn glyph_names() {
199        test_glyph_names(
200            font_test_data::NOTO_SERIF_DISPLAY_TRIMMED,
201            &[".notdef", "i", "j", "k", "l"],
202        );
203    }
204
205    #[test]
206    fn icons_glyph_names() {
207        test_glyph_names(font_test_data::MATERIAL_ICONS_SUBSET, &[".notdef", "_10k"]);
208    }
209
210    fn test_glyph_names(font_data: &[u8], expected_names: &[&str]) {
211        let font = FontRef::new(font_data).unwrap();
212        let cff = font.cff().unwrap();
213        let charset = cff.charset(0).unwrap().unwrap();
214        let sid_to_string = |sid| std::str::from_utf8(cff.string(sid).unwrap().bytes()).unwrap();
215        let names_by_lookup = (0..charset.num_glyphs())
216            .map(|gid| sid_to_string(charset.string_id(GlyphId::new(gid)).unwrap()))
217            .collect::<Vec<_>>();
218        assert_eq!(names_by_lookup, expected_names);
219        let names_by_iter = charset
220            .iter()
221            .map(|(_gid, sid)| sid_to_string(sid))
222            .collect::<Vec<_>>();
223        assert_eq!(names_by_iter, expected_names);
224    }
225}
read_fonts/tables/cff.rs

read_fonts/tables/
cff.rs
