+373

crates/text/src/font/mod.rs

··· 1 1 + //! OTF/TTF font file parser. 2 2 + //! 3 3 + //! Parses the OpenType/TrueType table directory and individual tables needed 4 4 + //! for text rendering: head, maxp, hhea, hmtx, cmap, name, loca. 5 5 + 6 6 + use std::fmt; 7 7 + 8 8 + mod parse; 9 9 + mod tables; 10 10 + 11 11 + pub use tables::cmap::CmapTable; 12 12 + pub use tables::head::HeadTable; 13 13 + pub use tables::hhea::HheaTable; 14 14 + pub use tables::hmtx::HmtxTable; 15 15 + pub use tables::loca::LocaTable; 16 16 + pub use tables::maxp::MaxpTable; 17 17 + pub use tables::name::NameTable; 18 18 + 19 19 + /// Errors that can occur during font parsing. 20 20 + #[derive(Debug)] 21 21 + pub enum FontError { 22 22 + /// The data is too short to contain the expected structure. 23 23 + UnexpectedEof, 24 24 + /// The font file has an unrecognized magic number / sfVersion. 25 25 + InvalidMagic(u32), 26 26 + /// A required table is missing. 27 27 + MissingTable(&'static str), 28 28 + /// A table's data is malformed. 29 29 + MalformedTable(&'static str), 30 30 + } 31 31 + 32 32 + impl fmt::Display for FontError { 33 33 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 34 34 + match self { 35 35 + FontError::UnexpectedEof => write!(f, "unexpected end of font data"), 36 36 + FontError::InvalidMagic(v) => write!(f, "invalid font magic: 0x{:08X}", v), 37 37 + FontError::MissingTable(t) => write!(f, "missing required table: {}", t), 38 38 + FontError::MalformedTable(t) => write!(f, "malformed table: {}", t), 39 39 + } 40 40 + } 41 41 + } 42 42 + 43 43 + /// A record in the table directory describing one font table. 44 44 + #[derive(Debug, Clone)] 45 45 + pub struct TableRecord { 46 46 + /// Four-byte tag (e.g. b"head", b"cmap"). 47 47 + pub tag: [u8; 4], 48 48 + /// Checksum of the table. 49 49 + pub checksum: u32, 50 50 + /// Offset from the beginning of the font file. 51 51 + pub offset: u32, 52 52 + /// Length of the table in bytes. 53 53 + pub length: u32, 54 54 + } 55 55 + 56 56 + impl TableRecord { 57 57 + /// Return the tag as a string (for display/debugging). 58 58 + pub fn tag_str(&self) -> &str { 59 59 + std::str::from_utf8(&self.tag).unwrap_or("????") 60 60 + } 61 61 + } 62 62 + 63 63 + /// A parsed OpenType/TrueType font. 64 64 + #[derive(Debug)] 65 65 + pub struct Font { 66 66 + /// Raw font data (owned). 67 67 + data: Vec<u8>, 68 68 + /// Offset subtable version (0x00010000 for TrueType, 0x4F54544F for CFF). 69 69 + pub sf_version: u32, 70 70 + /// Table directory records. 71 71 + pub tables: Vec<TableRecord>, 72 72 + } 73 73 + 74 74 + impl Font { 75 75 + /// Parse a font from raw file bytes. 76 76 + pub fn parse(data: Vec<u8>) -> Result<Font, FontError> { 77 77 + let r = parse::Reader::new(&data); 78 78 + 79 79 + let sf_version = r.u32(0)?; 80 80 + match sf_version { 81 81 + 0x00010000 => {} // TrueType 82 82 + 0x4F54544F => {} // CFF (OpenType with PostScript outlines) 83 83 + 0x74727565 => {} // 'true' — old Apple TrueType 84 84 + _ => return Err(FontError::InvalidMagic(sf_version)), 85 85 + } 86 86 + 87 87 + let num_tables = r.u16(4)? as usize; 88 88 + // skip searchRange(2), entrySelector(2), rangeShift(2) = 6 bytes 89 89 + let mut tables = Vec::with_capacity(num_tables); 90 90 + for i in 0..num_tables { 91 91 + let base = 12 + i * 16; 92 92 + let tag = r.tag(base)?; 93 93 + let checksum = r.u32(base + 4)?; 94 94 + let offset = r.u32(base + 8)?; 95 95 + let length = r.u32(base + 12)?; 96 96 + tables.push(TableRecord { 97 97 + tag, 98 98 + checksum, 99 99 + offset, 100 100 + length, 101 101 + }); 102 102 + } 103 103 + 104 104 + Ok(Font { 105 105 + data, 106 106 + sf_version, 107 107 + tables, 108 108 + }) 109 109 + } 110 110 + 111 111 + /// Load a font from a file path. 112 112 + pub fn from_file(path: &std::path::Path) -> Result<Font, FontError> { 113 113 + let data = std::fs::read(path).map_err(|_| FontError::UnexpectedEof)?; 114 114 + Font::parse(data) 115 115 + } 116 116 + 117 117 + /// Find a table record by its 4-byte tag. 118 118 + pub fn table_record(&self, tag: &[u8; 4]) -> Option<&TableRecord> { 119 119 + self.tables.iter().find(|t| &t.tag == tag) 120 120 + } 121 121 + 122 122 + /// Get the raw bytes for a table. 123 123 + pub fn table_data(&self, tag: &[u8; 4]) -> Option<&[u8]> { 124 124 + let rec = self.table_record(tag)?; 125 125 + let start = rec.offset as usize; 126 126 + let end = start + rec.length as usize; 127 127 + if end <= self.data.len() { 128 128 + Some(&self.data[start..end]) 129 129 + } else { 130 130 + None 131 131 + } 132 132 + } 133 133 + 134 134 + /// Parse the `head` table. 135 135 + pub fn head(&self) -> Result<HeadTable, FontError> { 136 136 + let data = self 137 137 + .table_data(b"head") 138 138 + .ok_or(FontError::MissingTable("head"))?; 139 139 + HeadTable::parse(data) 140 140 + } 141 141 + 142 142 + /// Parse the `maxp` table. 143 143 + pub fn maxp(&self) -> Result<MaxpTable, FontError> { 144 144 + let data = self 145 145 + .table_data(b"maxp") 146 146 + .ok_or(FontError::MissingTable("maxp"))?; 147 147 + MaxpTable::parse(data) 148 148 + } 149 149 + 150 150 + /// Parse the `hhea` table. 151 151 + pub fn hhea(&self) -> Result<HheaTable, FontError> { 152 152 + let data = self 153 153 + .table_data(b"hhea") 154 154 + .ok_or(FontError::MissingTable("hhea"))?; 155 155 + HheaTable::parse(data) 156 156 + } 157 157 + 158 158 + /// Parse the `hmtx` table. 159 159 + /// 160 160 + /// Requires `maxp` and `hhea` to determine dimensions. 161 161 + pub fn hmtx(&self) -> Result<HmtxTable, FontError> { 162 162 + let maxp = self.maxp()?; 163 163 + let hhea = self.hhea()?; 164 164 + let data = self 165 165 + .table_data(b"hmtx") 166 166 + .ok_or(FontError::MissingTable("hmtx"))?; 167 167 + HmtxTable::parse(data, hhea.num_long_hor_metrics, maxp.num_glyphs) 168 168 + } 169 169 + 170 170 + /// Parse the `cmap` table. 171 171 + pub fn cmap(&self) -> Result<CmapTable, FontError> { 172 172 + let data = self 173 173 + .table_data(b"cmap") 174 174 + .ok_or(FontError::MissingTable("cmap"))?; 175 175 + CmapTable::parse(data) 176 176 + } 177 177 + 178 178 + /// Parse the `name` table. 179 179 + pub fn name(&self) -> Result<NameTable, FontError> { 180 180 + let data = self 181 181 + .table_data(b"name") 182 182 + .ok_or(FontError::MissingTable("name"))?; 183 183 + NameTable::parse(data) 184 184 + } 185 185 + 186 186 + /// Parse the `loca` table. 187 187 + /// 188 188 + /// Requires `head` (for index format) and `maxp` (for glyph count). 189 189 + pub fn loca(&self) -> Result<LocaTable, FontError> { 190 190 + let head = self.head()?; 191 191 + let maxp = self.maxp()?; 192 192 + let data = self 193 193 + .table_data(b"loca") 194 194 + .ok_or(FontError::MissingTable("loca"))?; 195 195 + LocaTable::parse(data, head.index_to_loc_format, maxp.num_glyphs) 196 196 + } 197 197 + 198 198 + /// Map a Unicode code point to a glyph index using the cmap table. 199 199 + pub fn glyph_index(&self, codepoint: u32) -> Result<Option<u16>, FontError> { 200 200 + let cmap = self.cmap()?; 201 201 + Ok(cmap.glyph_index(codepoint)) 202 202 + } 203 203 + 204 204 + /// Returns true if this is a TrueType font (vs CFF/PostScript outlines). 205 205 + pub fn is_truetype(&self) -> bool { 206 206 + self.sf_version == 0x00010000 || self.sf_version == 0x74727565 207 207 + } 208 208 + } 209 209 + 210 210 + /// Load the first available system font from standard macOS paths. 211 211 + /// 212 212 + /// Tries these fonts in order: Geneva.ttf, Helvetica.ttc, Monaco.ttf. 213 213 + /// For `.ttc` (TrueType Collection) files, only the first font is parsed. 214 214 + pub fn load_system_font() -> Result<Font, FontError> { 215 215 + let candidates = [ 216 216 + "/System/Library/Fonts/Geneva.ttf", 217 217 + "/System/Library/Fonts/Monaco.ttf", 218 218 + ]; 219 219 + for path in &candidates { 220 220 + let p = std::path::Path::new(path); 221 221 + if p.exists() { 222 222 + return Font::from_file(p); 223 223 + } 224 224 + } 225 225 + Err(FontError::MissingTable("no system font found")) 226 226 + } 227 227 + 228 228 + #[cfg(test)] 229 229 + mod tests { 230 230 + use super::*; 231 231 + 232 232 + fn test_font() -> Font { 233 233 + // Try several common macOS fonts. 234 234 + let paths = [ 235 235 + "/System/Library/Fonts/Geneva.ttf", 236 236 + "/System/Library/Fonts/Monaco.ttf", 237 237 + "/System/Library/Fonts/Keyboard.ttf", 238 238 + ]; 239 239 + for path in &paths { 240 240 + let p = std::path::Path::new(path); 241 241 + if p.exists() { 242 242 + return Font::from_file(p).expect("failed to parse font"); 243 243 + } 244 244 + } 245 245 + panic!("no test font found — need a .ttf file in /System/Library/Fonts/"); 246 246 + } 247 247 + 248 248 + #[test] 249 249 + fn parse_table_directory() { 250 250 + let font = test_font(); 251 251 + assert!(font.is_truetype()); 252 252 + assert!(!font.tables.is_empty()); 253 253 + // Every font must have these tables. 254 254 + assert!(font.table_record(b"head").is_some(), "missing head table"); 255 255 + assert!(font.table_record(b"cmap").is_some(), "missing cmap table"); 256 256 + assert!(font.table_record(b"maxp").is_some(), "missing maxp table"); 257 257 + } 258 258 + 259 259 + #[test] 260 260 + fn parse_head_table() { 261 261 + let font = test_font(); 262 262 + let head = font.head().expect("failed to parse head"); 263 263 + assert!( 264 264 + head.units_per_em > 0, 265 265 + "units_per_em should be positive: {}", 266 266 + head.units_per_em 267 267 + ); 268 268 + assert!( 269 269 + head.units_per_em >= 16 && head.units_per_em <= 16384, 270 270 + "units_per_em out of range: {}", 271 271 + head.units_per_em 272 272 + ); 273 273 + } 274 274 + 275 275 + #[test] 276 276 + fn parse_maxp_table() { 277 277 + let font = test_font(); 278 278 + let maxp = font.maxp().expect("failed to parse maxp"); 279 279 + assert!(maxp.num_glyphs > 0, "font should have at least one glyph"); 280 280 + } 281 281 + 282 282 + #[test] 283 283 + fn parse_hhea_table() { 284 284 + let font = test_font(); 285 285 + let hhea = font.hhea().expect("failed to parse hhea"); 286 286 + assert!(hhea.ascent > 0, "ascent should be positive"); 287 287 + assert!(hhea.num_long_hor_metrics > 0, "should have metrics"); 288 288 + } 289 289 + 290 290 + #[test] 291 291 + fn parse_hmtx_table() { 292 292 + let font = test_font(); 293 293 + let hmtx = font.hmtx().expect("failed to parse hmtx"); 294 294 + let maxp = font.maxp().unwrap(); 295 295 + assert_eq!( 296 296 + hmtx.advances.len(), 297 297 + maxp.num_glyphs as usize, 298 298 + "should have one advance per glyph" 299 299 + ); 300 300 + assert_eq!( 301 301 + hmtx.lsbs.len(), 302 302 + maxp.num_glyphs as usize, 303 303 + "should have one lsb per glyph" 304 304 + ); 305 305 + // Glyph 0 (.notdef) typically has a nonzero advance. 306 306 + assert!(hmtx.advances[0] > 0, "glyph 0 advance should be nonzero"); 307 307 + } 308 308 + 309 309 + #[test] 310 310 + fn parse_cmap_table() { 311 311 + let font = test_font(); 312 312 + let cmap = font.cmap().expect("failed to parse cmap"); 313 313 + 314 314 + // Look up ASCII 'A' (U+0041) — every Latin font should have it. 315 315 + let glyph_a = cmap.glyph_index(0x0041); 316 316 + assert!( 317 317 + glyph_a.is_some() && glyph_a.unwrap() > 0, 318 318 + "should find a glyph for 'A'" 319 319 + ); 320 320 + 321 321 + // Look up space (U+0020). 322 322 + let glyph_space = cmap.glyph_index(0x0020); 323 323 + assert!(glyph_space.is_some(), "should find a glyph for space"); 324 324 + } 325 325 + 326 326 + #[test] 327 327 + fn parse_name_table() { 328 328 + let font = test_font(); 329 329 + let name = font.name().expect("failed to parse name"); 330 330 + let family = name.family_name(); 331 331 + assert!(family.is_some(), "should have a family name"); 332 332 + let family = family.unwrap(); 333 333 + assert!(!family.is_empty(), "family name should not be empty"); 334 334 + } 335 335 + 336 336 + #[test] 337 337 + fn parse_loca_table() { 338 338 + let font = test_font(); 339 339 + let loca = font.loca().expect("failed to parse loca"); 340 340 + let maxp = font.maxp().unwrap(); 341 341 + // loca has num_glyphs + 1 entries. 342 342 + assert_eq!( 343 343 + loca.offsets.len(), 344 344 + maxp.num_glyphs as usize + 1, 345 345 + "loca should have num_glyphs + 1 entries" 346 346 + ); 347 347 + } 348 348 + 349 349 + #[test] 350 350 + fn glyph_index_lookup() { 351 351 + let font = test_font(); 352 352 + // 'A' should map to a nonzero glyph. 353 353 + let gid = font.glyph_index(0x0041).expect("glyph_index failed"); 354 354 + assert!(gid.is_some() && gid.unwrap() > 0); 355 355 + 356 356 + // A private-use code point likely has no glyph. 357 357 + let gid_pua = font.glyph_index(0xFFFD).expect("glyph_index failed"); 358 358 + // FFFD (replacement char) might or might not exist — just check no crash. 359 359 + let _ = gid_pua; 360 360 + } 361 361 + 362 362 + #[test] 363 363 + fn load_system_font_works() { 364 364 + // This test may fail in CI where no fonts are installed, 365 365 + // but should pass on macOS. 366 366 + if std::path::Path::new("/System/Library/Fonts/Geneva.ttf").exists() 367 367 + || std::path::Path::new("/System/Library/Fonts/Monaco.ttf").exists() 368 368 + { 369 369 + let font = load_system_font().expect("should load a system font"); 370 370 + assert!(!font.tables.is_empty()); 371 371 + } 372 372 + } 373 373 + }

+79

crates/text/src/font/parse.rs

··· 1 1 + //! Binary parsing utilities for reading big-endian font data. 2 2 + 3 3 + use super::FontError; 4 4 + 5 5 + /// A zero-copy reader over a byte slice, for big-endian binary parsing. 6 6 + pub struct Reader<'a> { 7 7 + data: &'a [u8], 8 8 + } 9 9 + 10 10 + impl<'a> Reader<'a> { 11 11 + pub fn new(data: &'a [u8]) -> Self { 12 12 + Reader { data } 13 13 + } 14 14 + 15 15 + pub fn len(&self) -> usize { 16 16 + self.data.len() 17 17 + } 18 18 + 19 19 + fn check(&self, offset: usize, size: usize) -> Result<(), FontError> { 20 20 + if offset + size > self.data.len() { 21 21 + Err(FontError::UnexpectedEof) 22 22 + } else { 23 23 + Ok(()) 24 24 + } 25 25 + } 26 26 + 27 27 + pub fn u16(&self, offset: usize) -> Result<u16, FontError> { 28 28 + self.check(offset, 2)?; 29 29 + Ok(u16::from_be_bytes([ 30 30 + self.data[offset], 31 31 + self.data[offset + 1], 32 32 + ])) 33 33 + } 34 34 + 35 35 + pub fn i16(&self, offset: usize) -> Result<i16, FontError> { 36 36 + self.check(offset, 2)?; 37 37 + Ok(i16::from_be_bytes([ 38 38 + self.data[offset], 39 39 + self.data[offset + 1], 40 40 + ])) 41 41 + } 42 42 + 43 43 + pub fn u32(&self, offset: usize) -> Result<u32, FontError> { 44 44 + self.check(offset, 4)?; 45 45 + Ok(u32::from_be_bytes([ 46 46 + self.data[offset], 47 47 + self.data[offset + 1], 48 48 + self.data[offset + 2], 49 49 + self.data[offset + 3], 50 50 + ])) 51 51 + } 52 52 + 53 53 + pub fn i32(&self, offset: usize) -> Result<i32, FontError> { 54 54 + self.check(offset, 4)?; 55 55 + Ok(i32::from_be_bytes([ 56 56 + self.data[offset], 57 57 + self.data[offset + 1], 58 58 + self.data[offset + 2], 59 59 + self.data[offset + 3], 60 60 + ])) 61 61 + } 62 62 + 63 63 + /// Read a 4-byte tag (e.g., table tags like b"head"). 64 64 + pub fn tag(&self, offset: usize) -> Result<[u8; 4], FontError> { 65 65 + self.check(offset, 4)?; 66 66 + Ok([ 67 67 + self.data[offset], 68 68 + self.data[offset + 1], 69 69 + self.data[offset + 2], 70 70 + self.data[offset + 3], 71 71 + ]) 72 72 + } 73 73 + 74 74 + /// Get a sub-slice of the data. 75 75 + pub fn slice(&self, offset: usize, len: usize) -> Result<&'a [u8], FontError> { 76 76 + self.check(offset, len)?; 77 77 + Ok(&self.data[offset..offset + len]) 78 78 + } 79 79 + }

+285

crates/text/src/font/tables/cmap.rs

··· 1 1 + //! `cmap` — Character to Glyph Index Mapping table. 2 2 + //! 3 3 + //! Maps Unicode code points to glyph indices. Supports format 4 (BMP) and 4 4 + //! format 12 (full Unicode). 5 5 + //! Reference: <https://learn.microsoft.com/en-us/typography/opentype/spec/cmap> 6 6 + 7 7 + use crate::font::parse::Reader; 8 8 + use crate::font::FontError; 9 9 + 10 10 + /// Parsed `cmap` table. 11 11 + #[derive(Debug)] 12 12 + pub struct CmapTable { 13 13 + /// The best subtable we found (preferring format 12 over format 4). 14 14 + subtable: CmapSubtable, 15 15 + } 16 16 + 17 17 + #[derive(Debug)] 18 18 + enum CmapSubtable { 19 19 + Format4(Format4), 20 20 + Format12(Format12), 21 21 + } 22 22 + 23 23 + /// cmap format 4: Segment mapping to delta values (BMP only). 24 24 + #[derive(Debug)] 25 25 + struct Format4 { 26 26 + /// Parallel arrays defining segments. 27 27 + end_codes: Vec<u16>, 28 28 + start_codes: Vec<u16>, 29 29 + id_deltas: Vec<i16>, 30 30 + id_range_offsets: Vec<u16>, 31 31 + /// The raw glyph index array following the segments. 32 32 + glyph_indices: Vec<u16>, 33 33 + } 34 34 + 35 35 + /// cmap format 12: Segmented coverage for the full Unicode range. 36 36 + #[derive(Debug)] 37 37 + struct Format12 { 38 38 + groups: Vec<SequentialMapGroup>, 39 39 + } 40 40 + 41 41 + #[derive(Debug)] 42 42 + struct SequentialMapGroup { 43 43 + start_char: u32, 44 44 + end_char: u32, 45 45 + start_glyph: u32, 46 46 + } 47 47 + 48 48 + impl CmapTable { 49 49 + /// Parse the `cmap` table from raw bytes. 50 50 + /// 51 51 + /// Selects the best available subtable: 52 52 + /// 1. Platform 3 (Windows), Encoding 10 (Unicode full) — format 12 53 53 + /// 2. Platform 0 (Unicode), Encoding 4 (Unicode full) — format 12 54 54 + /// 3. Platform 3 (Windows), Encoding 1 (Unicode BMP) — format 4 55 55 + /// 4. Platform 0 (Unicode), Encoding 3 (Unicode BMP) — format 4 56 56 + /// 5. First platform 0 or 3 subtable that parses successfully 57 57 + pub fn parse(data: &[u8]) -> Result<CmapTable, FontError> { 58 58 + let r = Reader::new(data); 59 59 + if r.len() < 4 { 60 60 + return Err(FontError::MalformedTable("cmap")); 61 61 + } 62 62 + 63 63 + let num_tables = r.u16(2)? as usize; 64 64 + 65 65 + // Collect encoding records. 66 66 + struct EncodingRecord { 67 67 + platform_id: u16, 68 68 + encoding_id: u16, 69 69 + offset: u32, 70 70 + } 71 71 + 72 72 + let mut records = Vec::with_capacity(num_tables); 73 73 + for i in 0..num_tables { 74 74 + let base = 4 + i * 8; 75 75 + records.push(EncodingRecord { 76 76 + platform_id: r.u16(base)?, 77 77 + encoding_id: r.u16(base + 2)?, 78 78 + offset: r.u32(base + 4)?, 79 79 + }); 80 80 + } 81 81 + 82 82 + // Try subtables in preference order. 83 83 + // Priority: (3,10) > (0,4) > (0,6) > (3,1) > (0,3) > (0,*) > (3,*) 84 84 + let priority = |pid: u16, eid: u16| -> u8 { 85 85 + match (pid, eid) { 86 86 + (3, 10) => 0, 87 87 + (0, 4) => 1, 88 88 + (0, 6) => 2, 89 89 + (3, 1) => 3, 90 90 + (0, 3) => 4, 91 91 + (0, _) => 5, 92 92 + (3, _) => 6, 93 93 + _ => 255, 94 94 + } 95 95 + }; 96 96 + 97 97 + let mut best: Option<(u8, CmapSubtable)> = None; 98 98 + 99 99 + for rec in &records { 100 100 + let p = priority(rec.platform_id, rec.encoding_id); 101 101 + if p == 255 { 102 102 + continue; 103 103 + } 104 104 + if let Some((bp, _)) = &best { 105 105 + if p >= *bp { 106 106 + continue; 107 107 + } 108 108 + } 109 109 + 110 110 + let offset = rec.offset as usize; 111 111 + if offset + 2 > data.len() { 112 112 + continue; 113 113 + } 114 114 + let format = r.u16(offset)?; 115 115 + 116 116 + match format { 117 117 + 4 => { 118 118 + if let Ok(st) = parse_format4(data, offset) { 119 119 + best = Some((p, CmapSubtable::Format4(st))); 120 120 + } 121 121 + } 122 122 + 12 => { 123 123 + if let Ok(st) = parse_format12(data, offset) { 124 124 + best = Some((p, CmapSubtable::Format12(st))); 125 125 + } 126 126 + } 127 127 + _ => {} 128 128 + } 129 129 + } 130 130 + 131 131 + match best { 132 132 + Some((_, subtable)) => Ok(CmapTable { subtable }), 133 133 + None => Err(FontError::MalformedTable("cmap: no usable subtable")), 134 134 + } 135 135 + } 136 136 + 137 137 + /// Look up a Unicode code point and return the corresponding glyph index. 138 138 + /// 139 139 + /// Returns `None` if the code point is not mapped (maps to glyph 0). 140 140 + pub fn glyph_index(&self, codepoint: u32) -> Option<u16> { 141 141 + let gid = match &self.subtable { 142 142 + CmapSubtable::Format4(f4) => lookup_format4(f4, codepoint), 143 143 + CmapSubtable::Format12(f12) => lookup_format12(f12, codepoint), 144 144 + }; 145 145 + if gid == 0 { 146 146 + None 147 147 + } else { 148 148 + Some(gid) 149 149 + } 150 150 + } 151 151 + } 152 152 + 153 153 + fn parse_format4(data: &[u8], offset: usize) -> Result<Format4, FontError> { 154 154 + let r = Reader::new(data); 155 155 + // format(2) + length(2) + language(2) + segCountX2(2) 156 156 + if offset + 14 > data.len() { 157 157 + return Err(FontError::MalformedTable("cmap format 4")); 158 158 + } 159 159 + 160 160 + let seg_count_x2 = r.u16(offset + 6)? as usize; 161 161 + let seg_count = seg_count_x2 / 2; 162 162 + // skip searchRange(2) + entrySelector(2) + rangeShift(2) 163 163 + let end_codes_offset = offset + 14; 164 164 + // After endCodes there is a reservedPad(2), then startCodes. 165 165 + let start_codes_offset = end_codes_offset + seg_count_x2 + 2; 166 166 + let id_delta_offset = start_codes_offset + seg_count_x2; 167 167 + let id_range_offset = id_delta_offset + seg_count_x2; 168 168 + 169 169 + let mut end_codes = Vec::with_capacity(seg_count); 170 170 + let mut start_codes = Vec::with_capacity(seg_count); 171 171 + let mut id_deltas = Vec::with_capacity(seg_count); 172 172 + let mut id_range_offsets = Vec::with_capacity(seg_count); 173 173 + 174 174 + for i in 0..seg_count { 175 175 + end_codes.push(r.u16(end_codes_offset + i * 2)?); 176 176 + start_codes.push(r.u16(start_codes_offset + i * 2)?); 177 177 + id_deltas.push(r.i16(id_delta_offset + i * 2)?); 178 178 + id_range_offsets.push(r.u16(id_range_offset + i * 2)?); 179 179 + } 180 180 + 181 181 + // Everything after idRangeOffset is the glyphIdArray. 182 182 + let glyph_array_offset = id_range_offset + seg_count_x2; 183 183 + let remaining_bytes = data.len().saturating_sub(glyph_array_offset); 184 184 + let num_glyph_indices = remaining_bytes / 2; 185 185 + let mut glyph_indices = Vec::with_capacity(num_glyph_indices); 186 186 + for i in 0..num_glyph_indices { 187 187 + glyph_indices.push(r.u16(glyph_array_offset + i * 2)?); 188 188 + } 189 189 + 190 190 + Ok(Format4 { 191 191 + end_codes, 192 192 + start_codes, 193 193 + id_deltas, 194 194 + id_range_offsets, 195 195 + glyph_indices, 196 196 + }) 197 197 + } 198 198 + 199 199 + fn lookup_format4(f4: &Format4, codepoint: u32) -> u16 { 200 200 + if codepoint > 0xFFFF { 201 201 + return 0; 202 202 + } 203 203 + let cp = codepoint as u16; 204 204 + 205 205 + for i in 0..f4.end_codes.len() { 206 206 + if cp > f4.end_codes[i] { 207 207 + continue; 208 208 + } 209 209 + if cp < f4.start_codes[i] { 210 210 + return 0; 211 211 + } 212 212 + 213 213 + if f4.id_range_offsets[i] == 0 { 214 214 + // Use delta. 215 215 + return (cp as i32 + f4.id_deltas[i] as i32) as u16; 216 216 + } 217 217 + 218 218 + // Use range offset into glyphIdArray. 219 219 + // The offset is relative to the position of idRangeOffset[i] in the data. 220 220 + // index = idRangeOffset[i]/2 + (cp - startCode[i]) - segCount + i 221 221 + let range_offset = f4.id_range_offsets[i] as usize; 222 222 + let seg_count = f4.end_codes.len(); 223 223 + let idx = range_offset / 2 + (cp - f4.start_codes[i]) as usize; 224 224 + // idx is relative to position of idRangeOffset[i], which is at 225 225 + // range_offset_base + i*2 in the original data. We need to convert 226 226 + // to an index into our glyph_indices array. 227 227 + // The glyph_indices array starts at range_offset_base + seg_count*2. 228 228 + // So the array index = idx - seg_count + i 229 229 + let array_idx = idx.wrapping_sub(seg_count).wrapping_add(i); 230 230 + if array_idx < f4.glyph_indices.len() { 231 231 + let gid = f4.glyph_indices[array_idx]; 232 232 + if gid == 0 { 233 233 + return 0; 234 234 + } 235 235 + return (gid as i32 + f4.id_deltas[i] as i32) as u16; 236 236 + } 237 237 + 238 238 + return 0; 239 239 + } 240 240 + 241 241 + 0 242 242 + } 243 243 + 244 244 + fn parse_format12(data: &[u8], offset: usize) -> Result<Format12, FontError> { 245 245 + let r = Reader::new(data); 246 246 + // format(2) + reserved(2) + length(4) + language(4) + numGroups(4) 247 247 + if offset + 16 > data.len() { 248 248 + return Err(FontError::MalformedTable("cmap format 12")); 249 249 + } 250 250 + 251 251 + let num_groups = r.u32(offset + 12)? as usize; 252 252 + let groups_offset = offset + 16; 253 253 + 254 254 + let mut groups = Vec::with_capacity(num_groups); 255 255 + for i in 0..num_groups { 256 256 + let base = groups_offset + i * 12; 257 257 + groups.push(SequentialMapGroup { 258 258 + start_char: r.u32(base)?, 259 259 + end_char: r.u32(base + 4)?, 260 260 + start_glyph: r.u32(base + 8)?, 261 261 + }); 262 262 + } 263 263 + 264 264 + Ok(Format12 { groups }) 265 265 + } 266 266 + 267 267 + fn lookup_format12(f12: &Format12, codepoint: u32) -> u16 { 268 268 + // Binary search for the group containing codepoint. 269 269 + let mut lo = 0usize; 270 270 + let mut hi = f12.groups.len(); 271 271 + while lo < hi { 272 272 + let mid = lo + (hi - lo) / 2; 273 273 + let group = &f12.groups[mid]; 274 274 + if codepoint < group.start_char { 275 275 + hi = mid; 276 276 + } else if codepoint > group.end_char { 277 277 + lo = mid + 1; 278 278 + } else { 279 279 + // Found it. 280 280 + let gid = group.start_glyph + (codepoint - group.start_char); 281 281 + return gid as u16; 282 282 + } 283 283 + } 284 284 + 0 285 285 + }

+74

crates/text/src/font/tables/head.rs

··· 1 1 + //! `head` — Font Header table. 2 2 + //! 3 3 + //! Contains global font metrics and flags. 4 4 + //! Reference: <https://learn.microsoft.com/en-us/typography/opentype/spec/head> 5 5 + 6 6 + use crate::font::parse::Reader; 7 7 + use crate::font::FontError; 8 8 + 9 9 + /// Parsed `head` table. 10 10 + #[derive(Debug)] 11 11 + pub struct HeadTable { 12 12 + /// Major version (should be 1). 13 13 + pub major_version: u16, 14 14 + /// Minor version (should be 0). 15 15 + pub minor_version: u16, 16 16 + /// Font revision (fixed-point 16.16). 17 17 + pub font_revision: i32, 18 18 + /// Units per em (typically 1000 or 2048). 19 19 + pub units_per_em: u16, 20 20 + /// Bounding box: minimum x. 21 21 + pub x_min: i16, 22 22 + /// Bounding box: minimum y. 23 23 + pub y_min: i16, 24 24 + /// Bounding box: maximum x. 25 25 + pub x_max: i16, 26 26 + /// Bounding box: maximum y. 27 27 + pub y_max: i16, 28 28 + /// Mac style flags (bit 0 = bold, bit 1 = italic). 29 29 + pub mac_style: u16, 30 30 + /// Smallest readable size in pixels. 31 31 + pub lowest_rec_ppem: u16, 32 32 + /// 0 = short offsets in loca, 1 = long offsets. 33 33 + pub index_to_loc_format: i16, 34 34 + } 35 35 + 36 36 + impl HeadTable { 37 37 + /// Parse the `head` table from raw bytes. 38 38 + pub fn parse(data: &[u8]) -> Result<HeadTable, FontError> { 39 39 + let r = Reader::new(data); 40 40 + // Minimum head table size is 54 bytes. 41 41 + if r.len() < 54 { 42 42 + return Err(FontError::MalformedTable("head")); 43 43 + } 44 44 + 45 45 + let major_version = r.u16(0)?; 46 46 + let minor_version = r.u16(2)?; 47 47 + let font_revision = r.i32(4)?; 48 48 + // skip checksumAdjustment(4) + magicNumber(4) + flags(2) 49 49 + let units_per_em = r.u16(18)?; 50 50 + // skip created(8) + modified(8) 51 51 + let x_min = r.i16(36)?; 52 52 + let y_min = r.i16(38)?; 53 53 + let x_max = r.i16(40)?; 54 54 + let y_max = r.i16(42)?; 55 55 + let mac_style = r.u16(44)?; 56 56 + let lowest_rec_ppem = r.u16(46)?; 57 57 + // skip fontDirectionHint(2) 58 58 + let index_to_loc_format = r.i16(50)?; 59 59 + 60 60 + Ok(HeadTable { 61 61 + major_version, 62 62 + minor_version, 63 63 + font_revision, 64 64 + units_per_em, 65 65 + x_min, 66 66 + y_min, 67 67 + x_max, 68 68 + y_max, 69 69 + mac_style, 70 70 + lowest_rec_ppem, 71 71 + index_to_loc_format, 72 72 + }) 73 73 + } 74 74 + }

+60

crates/text/src/font/tables/hhea.rs

··· 1 1 + //! `hhea` — Horizontal Header table. 2 2 + //! 3 3 + //! Contains global horizontal layout metrics. 4 4 + //! Reference: <https://learn.microsoft.com/en-us/typography/opentype/spec/hhea> 5 5 + 6 6 + use crate::font::parse::Reader; 7 7 + use crate::font::FontError; 8 8 + 9 9 + /// Parsed `hhea` table. 10 10 + #[derive(Debug)] 11 11 + pub struct HheaTable { 12 12 + /// Typographic ascent (in font units). 13 13 + pub ascent: i16, 14 14 + /// Typographic descent (typically negative, in font units). 15 15 + pub descent: i16, 16 16 + /// Typographic line gap (in font units). 17 17 + pub line_gap: i16, 18 18 + /// Maximum advance width across all glyphs. 19 19 + pub advance_width_max: u16, 20 20 + /// Minimum left side bearing across all glyphs. 21 21 + pub min_left_side_bearing: i16, 22 22 + /// Minimum right side bearing across all glyphs. 23 23 + pub min_right_side_bearing: i16, 24 24 + /// Maximum x extent (max(lsb + (xMax - xMin))). 25 25 + pub x_max_extent: i16, 26 26 + /// Number of entries in the hmtx table's longHorMetric array. 27 27 + pub num_long_hor_metrics: u16, 28 28 + } 29 29 + 30 30 + impl HheaTable { 31 31 + /// Parse the `hhea` table from raw bytes. 32 32 + pub fn parse(data: &[u8]) -> Result<HheaTable, FontError> { 33 33 + let r = Reader::new(data); 34 34 + if r.len() < 36 { 35 35 + return Err(FontError::MalformedTable("hhea")); 36 36 + } 37 37 + 38 38 + // skip version(4) 39 39 + let ascent = r.i16(4)?; 40 40 + let descent = r.i16(6)?; 41 41 + let line_gap = r.i16(8)?; 42 42 + let advance_width_max = r.u16(10)?; 43 43 + let min_left_side_bearing = r.i16(12)?; 44 44 + let min_right_side_bearing = r.i16(14)?; 45 45 + let x_max_extent = r.i16(16)?; 46 46 + // skip caretSlopeRise(2), caretSlopeRun(2), caretOffset(2), reserved(8), metricDataFormat(2) 47 47 + let num_long_hor_metrics = r.u16(34)?; 48 48 + 49 49 + Ok(HheaTable { 50 50 + ascent, 51 51 + descent, 52 52 + line_gap, 53 53 + advance_width_max, 54 54 + min_left_side_bearing, 55 55 + min_right_side_bearing, 56 56 + x_max_extent, 57 57 + num_long_hor_metrics, 58 58 + }) 59 59 + } 60 60 + }

+55

crates/text/src/font/tables/hmtx.rs

··· 1 1 + //! `hmtx` — Horizontal Metrics table. 2 2 + //! 3 3 + //! Contains per-glyph horizontal metrics (advance width + left side bearing). 4 4 + //! Reference: <https://learn.microsoft.com/en-us/typography/opentype/spec/hmtx> 5 5 + 6 6 + use crate::font::parse::Reader; 7 7 + use crate::font::FontError; 8 8 + 9 9 + /// Parsed `hmtx` table. 10 10 + /// 11 11 + /// Both `advances` and `lsbs` are indexed by glyph ID and have exactly 12 12 + /// `num_glyphs` entries. 13 13 + #[derive(Debug)] 14 14 + pub struct HmtxTable { 15 15 + /// Advance widths for each glyph (in font units). 16 16 + pub advances: Vec<u16>, 17 17 + /// Left side bearings for each glyph (in font units). 18 18 + pub lsbs: Vec<i16>, 19 19 + } 20 20 + 21 21 + impl HmtxTable { 22 22 + /// Parse the `hmtx` table from raw bytes. 23 23 + /// 24 24 + /// `num_long_hor_metrics` comes from `hhea`, `num_glyphs` from `maxp`. 25 25 + pub fn parse( 26 26 + data: &[u8], 27 27 + num_long_hor_metrics: u16, 28 28 + num_glyphs: u16, 29 29 + ) -> Result<HmtxTable, FontError> { 30 30 + let r = Reader::new(data); 31 31 + let n_long = num_long_hor_metrics as usize; 32 32 + let n_glyphs = num_glyphs as usize; 33 33 + 34 34 + let mut advances = Vec::with_capacity(n_glyphs); 35 35 + let mut lsbs = Vec::with_capacity(n_glyphs); 36 36 + 37 37 + // First n_long entries are (advance_width: u16, lsb: i16) pairs. 38 38 + for i in 0..n_long { 39 39 + let offset = i * 4; 40 40 + advances.push(r.u16(offset)?); 41 41 + lsbs.push(r.i16(offset + 2)?); 42 42 + } 43 43 + 44 44 + // Remaining glyphs share the last advance width, but have individual lsbs. 45 45 + let last_advance = advances.last().copied().unwrap_or(0); 46 46 + let remaining = n_glyphs.saturating_sub(n_long); 47 47 + let lsb_offset = n_long * 4; 48 48 + for i in 0..remaining { 49 49 + advances.push(last_advance); 50 50 + lsbs.push(r.i16(lsb_offset + i * 2)?); 51 51 + } 52 52 + 53 53 + Ok(HmtxTable { advances, lsbs }) 54 54 + } 55 55 + }

+79

crates/text/src/font/tables/loca.rs

··· 1 1 + //! `loca` — Index to Location table. 2 2 + //! 3 3 + //! Maps glyph IDs to byte offsets within the `glyf` table. 4 4 + //! Reference: <https://learn.microsoft.com/en-us/typography/opentype/spec/loca> 5 5 + 6 6 + use crate::font::parse::Reader; 7 7 + use crate::font::FontError; 8 8 + 9 9 + /// Parsed `loca` table. 10 10 + /// 11 11 + /// Contains `num_glyphs + 1` offsets. The glyph data for glyph `i` starts at 12 12 + /// `offsets[i]` and ends at `offsets[i + 1]`. If they are equal, the glyph 13 13 + /// has no outline (e.g., a space character). 14 14 + #[derive(Debug)] 15 15 + pub struct LocaTable { 16 16 + /// Byte offsets into the `glyf` table, one per glyph plus a sentinel. 17 17 + pub offsets: Vec<u32>, 18 18 + } 19 19 + 20 20 + impl LocaTable { 21 21 + /// Parse the `loca` table from raw bytes. 22 22 + /// 23 23 + /// `index_to_loc_format` comes from the `head` table (0 = short, 1 = long). 24 24 + /// `num_glyphs` comes from the `maxp` table. 25 25 + pub fn parse( 26 26 + data: &[u8], 27 27 + index_to_loc_format: i16, 28 28 + num_glyphs: u16, 29 29 + ) -> Result<LocaTable, FontError> { 30 30 + let r = Reader::new(data); 31 31 + let count = num_glyphs as usize + 1; 32 32 + let mut offsets = Vec::with_capacity(count); 33 33 + 34 34 + match index_to_loc_format { 35 35 + 0 => { 36 36 + // Short format: offsets are u16 values divided by 2. 37 37 + for i in 0..count { 38 38 + let raw = r.u16(i * 2)? as u32; 39 39 + offsets.push(raw * 2); 40 40 + } 41 41 + } 42 42 + 1 => { 43 43 + // Long format: offsets are u32 values. 44 44 + for i in 0..count { 45 45 + offsets.push(r.u32(i * 4)?); 46 46 + } 47 47 + } 48 48 + _ => return Err(FontError::MalformedTable("loca: invalid index format")), 49 49 + } 50 50 + 51 51 + Ok(LocaTable { offsets }) 52 52 + } 53 53 + 54 54 + /// Returns true if the glyph has outline data (non-empty in glyf). 55 55 + pub fn has_outline(&self, glyph_id: u16) -> bool { 56 56 + let i = glyph_id as usize; 57 57 + if i + 1 < self.offsets.len() { 58 58 + self.offsets[i] != self.offsets[i + 1] 59 59 + } else { 60 60 + false 61 61 + } 62 62 + } 63 63 + 64 64 + /// Get the byte range for a glyph within the `glyf` table. 65 65 + pub fn glyph_range(&self, glyph_id: u16) -> Option<(u32, u32)> { 66 66 + let i = glyph_id as usize; 67 67 + if i + 1 < self.offsets.len() { 68 68 + let start = self.offsets[i]; 69 69 + let end = self.offsets[i + 1]; 70 70 + if start < end { 71 71 + Some((start, end)) 72 72 + } else { 73 73 + None 74 74 + } 75 75 + } else { 76 76 + None 77 77 + } 78 78 + } 79 79 + }

+35

crates/text/src/font/tables/maxp.rs

··· 1 1 + //! `maxp` — Maximum Profile table. 2 2 + //! 3 3 + //! Contains the number of glyphs in the font plus (for TrueType) various 4 4 + //! maximum values used for memory allocation. 5 5 + //! Reference: <https://learn.microsoft.com/en-us/typography/opentype/spec/maxp> 6 6 + 7 7 + use crate::font::parse::Reader; 8 8 + use crate::font::FontError; 9 9 + 10 10 + /// Parsed `maxp` table. 11 11 + #[derive(Debug)] 12 12 + pub struct MaxpTable { 13 13 + /// Version (0x00005000 for CFF, 0x00010000 for TrueType). 14 14 + pub version: u32, 15 15 + /// Total number of glyphs in the font. 16 16 + pub num_glyphs: u16, 17 17 + } 18 18 + 19 19 + impl MaxpTable { 20 20 + /// Parse the `maxp` table from raw bytes. 21 21 + pub fn parse(data: &[u8]) -> Result<MaxpTable, FontError> { 22 22 + let r = Reader::new(data); 23 23 + if r.len() < 6 { 24 24 + return Err(FontError::MalformedTable("maxp")); 25 25 + } 26 26 + 27 27 + let version = r.u32(0)?; 28 28 + let num_glyphs = r.u16(4)?; 29 29 + 30 30 + Ok(MaxpTable { 31 31 + version, 32 32 + num_glyphs, 33 33 + }) 34 34 + } 35 35 + }

+9

crates/text/src/font/tables/mod.rs

··· 1 1 + //! Individual font table parsers. 2 2 + 3 3 + pub mod cmap; 4 4 + pub mod head; 5 5 + pub mod hhea; 6 6 + pub mod hmtx; 7 7 + pub mod loca; 8 8 + pub mod maxp; 9 9 + pub mod name;

+221

crates/text/src/font/tables/name.rs

··· 1 1 + //! `name` — Naming table. 2 2 + //! 3 3 + //! Contains human-readable strings like family name, style name, copyright, etc. 4 4 + //! Reference: <https://learn.microsoft.com/en-us/typography/opentype/spec/name> 5 5 + 6 6 + use crate::font::parse::Reader; 7 7 + use crate::font::FontError; 8 8 + 9 9 + /// Parsed `name` table. 10 10 + #[derive(Debug)] 11 11 + pub struct NameTable { 12 12 + /// All name records extracted from the table. 13 13 + pub records: Vec<NameRecord>, 14 14 + } 15 15 + 16 16 + /// A single name record. 17 17 + #[derive(Debug)] 18 18 + pub struct NameRecord { 19 19 + /// Platform ID (0 = Unicode, 1 = Macintosh, 3 = Windows). 20 20 + pub platform_id: u16, 21 21 + /// Encoding ID (platform-specific). 22 22 + pub encoding_id: u16, 23 23 + /// Language ID. 24 24 + pub language_id: u16, 25 25 + /// Name ID (1 = family, 2 = subfamily, 4 = full name, 6 = PostScript name, etc.). 26 26 + pub name_id: u16, 27 27 + /// The decoded string value. 28 28 + pub value: String, 29 29 + } 30 30 + 31 31 + impl NameTable { 32 32 + /// Parse the `name` table from raw bytes. 33 33 + pub fn parse(data: &[u8]) -> Result<NameTable, FontError> { 34 34 + let r = Reader::new(data); 35 35 + if r.len() < 6 { 36 36 + return Err(FontError::MalformedTable("name")); 37 37 + } 38 38 + 39 39 + // format(2) + count(2) + stringOffset(2) 40 40 + let count = r.u16(2)? as usize; 41 41 + let string_offset = r.u16(4)? as usize; 42 42 + 43 43 + let mut records = Vec::with_capacity(count); 44 44 + 45 45 + for i in 0..count { 46 46 + let base = 6 + i * 12; 47 47 + if base + 12 > data.len() { 48 48 + break; 49 49 + } 50 50 + 51 51 + let platform_id = r.u16(base)?; 52 52 + let encoding_id = r.u16(base + 2)?; 53 53 + let language_id = r.u16(base + 4)?; 54 54 + let name_id = r.u16(base + 6)?; 55 55 + let length = r.u16(base + 8)? as usize; 56 56 + let offset = r.u16(base + 10)? as usize; 57 57 + 58 58 + let str_start = string_offset + offset; 59 59 + if str_start + length > data.len() { 60 60 + continue; 61 61 + } 62 62 + 63 63 + let raw = r.slice(str_start, length)?; 64 64 + let value = decode_name_string(platform_id, encoding_id, raw); 65 65 + 66 66 + records.push(NameRecord { 67 67 + platform_id, 68 68 + encoding_id, 69 69 + language_id, 70 70 + name_id, 71 71 + value, 72 72 + }); 73 73 + } 74 74 + 75 75 + Ok(NameTable { records }) 76 76 + } 77 77 + 78 78 + /// Get the font family name (name ID 1). 79 79 + /// 80 80 + /// Prefers Windows/Unicode platform, falls back to any platform. 81 81 + pub fn family_name(&self) -> Option<&str> { 82 82 + self.get_name(1) 83 83 + } 84 84 + 85 85 + /// Get the font subfamily/style name (name ID 2, e.g. "Regular", "Bold"). 86 86 + pub fn subfamily_name(&self) -> Option<&str> { 87 87 + self.get_name(2) 88 88 + } 89 89 + 90 90 + /// Get the full font name (name ID 4). 91 91 + pub fn full_name(&self) -> Option<&str> { 92 92 + self.get_name(4) 93 93 + } 94 94 + 95 95 + /// Get a name string by name ID. 96 96 + /// 97 97 + /// Prefers Windows platform (3) with English, then any platform. 98 98 + fn get_name(&self, name_id: u16) -> Option<&str> { 99 99 + // Prefer Windows platform (3), English (language_id 0x0409). 100 100 + let win_en = self 101 101 + .records 102 102 + .iter() 103 103 + .find(|r| r.name_id == name_id && r.platform_id == 3 && r.language_id == 0x0409); 104 104 + if let Some(rec) = win_en { 105 105 + if !rec.value.is_empty() { 106 106 + return Some(&rec.value); 107 107 + } 108 108 + } 109 109 + 110 110 + // Fall back to any Windows platform record. 111 111 + let win = self 112 112 + .records 113 113 + .iter() 114 114 + .find(|r| r.name_id == name_id && r.platform_id == 3); 115 115 + if let Some(rec) = win { 116 116 + if !rec.value.is_empty() { 117 117 + return Some(&rec.value); 118 118 + } 119 119 + } 120 120 + 121 121 + // Fall back to any record. 122 122 + self.records 123 123 + .iter() 124 124 + .find(|r| r.name_id == name_id && !r.value.is_empty()) 125 125 + .map(|r| r.value.as_str()) 126 126 + } 127 127 + } 128 128 + 129 129 + /// Decode a name string based on platform/encoding. 130 130 + fn decode_name_string(platform_id: u16, encoding_id: u16, data: &[u8]) -> String { 131 131 + match platform_id { 132 132 + 0 => { 133 133 + // Unicode platform — always UTF-16BE. 134 134 + decode_utf16be(data) 135 135 + } 136 136 + 1 => { 137 137 + // Macintosh platform. 138 138 + if encoding_id == 0 { 139 139 + // Mac Roman. 140 140 + decode_mac_roman(data) 141 141 + } else { 142 142 + // Other Mac encodings — treat as ASCII fallback. 143 143 + String::from_utf8_lossy(data).into_owned() 144 144 + } 145 145 + } 146 146 + 3 => { 147 147 + // Windows platform — encoding 1 = UTF-16BE, encoding 10 = UTF-16BE. 148 148 + match encoding_id { 149 149 + 1 | 10 => decode_utf16be(data), 150 150 + 0 => { 151 151 + // Symbol encoding — treat as UTF-16BE. 152 152 + decode_utf16be(data) 153 153 + } 154 154 + _ => String::from_utf8_lossy(data).into_owned(), 155 155 + } 156 156 + } 157 157 + _ => String::from_utf8_lossy(data).into_owned(), 158 158 + } 159 159 + } 160 160 + 161 161 + fn decode_utf16be(data: &[u8]) -> String { 162 162 + let mut chars = Vec::with_capacity(data.len() / 2); 163 163 + let mut i = 0; 164 164 + while i + 1 < data.len() { 165 165 + let unit = u16::from_be_bytes([data[i], data[i + 1]]); 166 166 + i += 2; 167 167 + 168 168 + // Handle surrogate pairs. 169 169 + if (0xD800..=0xDBFF).contains(&unit) { 170 170 + if i + 1 < data.len() { 171 171 + let lo = u16::from_be_bytes([data[i], data[i + 1]]); 172 172 + if (0xDC00..=0xDFFF).contains(&lo) { 173 173 + i += 2; 174 174 + let cp = 0x10000 + ((unit as u32 - 0xD800) << 10) + (lo as u32 - 0xDC00); 175 175 + if let Some(ch) = char::from_u32(cp) { 176 176 + chars.push(ch); 177 177 + } 178 178 + continue; 179 179 + } 180 180 + } 181 181 + // Lone surrogate — skip. 182 182 + continue; 183 183 + } 184 184 + 185 185 + if let Some(ch) = char::from_u32(unit as u32) { 186 186 + chars.push(ch); 187 187 + } 188 188 + } 189 189 + chars.into_iter().collect() 190 190 + } 191 191 + 192 192 + fn decode_mac_roman(data: &[u8]) -> String { 193 193 + // Mac Roman: 0x00-0x7F are ASCII, 0x80-0xFF map to specific Unicode code points. 194 194 + static MAC_ROMAN_HIGH: [u16; 128] = [ 195 195 + 0x00C4, 0x00C5, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1, 0x00E0, 0x00E2, 0x00E4, 196 196 + 0x00E3, 0x00E5, 0x00E7, 0x00E9, 0x00E8, 0x00EA, 0x00EB, 0x00ED, 0x00EC, 0x00EE, 0x00EF, 197 197 + 0x00F1, 0x00F3, 0x00F2, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x00F9, 0x00FB, 0x00FC, 0x2020, 198 198 + 0x00B0, 0x00A2, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x00DF, 0x00AE, 0x00A9, 0x2122, 0x00B4, 199 199 + 0x00A8, 0x2260, 0x00C6, 0x00D8, 0x221E, 0x00B1, 0x2264, 0x2265, 0x00A5, 0x00B5, 0x2202, 200 200 + 0x2211, 0x220F, 0x03C0, 0x222B, 0x00AA, 0x00BA, 0x03A9, 0x00E6, 0x00F8, 0x00BF, 0x00A1, 201 201 + 0x00AC, 0x221A, 0x0192, 0x2248, 0x2206, 0x00AB, 0x00BB, 0x2026, 0x00A0, 0x00C0, 0x00C3, 202 202 + 0x00D5, 0x0152, 0x0153, 0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x25CA, 203 203 + 0x00FF, 0x0178, 0x2044, 0x20AC, 0x2039, 0x203A, 0xFB01, 0xFB02, 0x2021, 0x00B7, 0x201A, 204 204 + 0x201E, 0x2030, 0x00C2, 0x00CA, 0x00C1, 0x00CB, 0x00C8, 0x00CD, 0x00CE, 0x00CF, 0x00CC, 205 205 + 0x00D3, 0x00D4, 0xF8FF, 0x00D2, 0x00DA, 0x00DB, 0x00D9, 0x0131, 0x02C6, 0x02DC, 0x00AF, 206 206 + 0x02D8, 0x02D9, 0x02DA, 0x00B8, 0x02DD, 0x02DB, 0x02C7, 207 207 + ]; 208 208 + 209 209 + let mut s = String::with_capacity(data.len()); 210 210 + for &b in data { 211 211 + if b < 0x80 { 212 212 + s.push(b as char); 213 213 + } else { 214 214 + let cp = MAC_ROMAN_HIGH[(b - 0x80) as usize]; 215 215 + if let Some(ch) = char::from_u32(cp as u32) { 216 216 + s.push(ch); 217 217 + } 218 218 + } 219 219 + } 220 220 + s 221 221 + }

+2

crates/text/src/lib.rs

··· 1 1 //! Font parsing (OTF/TTF), shaping, rasterization, and line breaking — pure Rust. 2 2 + 3 3 + pub mod font;