From b12196eaf04ca283a0ed0d48faae9647b8ec2e23 Mon Sep 17 00:00:00 2001 From: Hamza Naveed <45464935+Hamza0101@users.noreply.github.com> Date: Wed, 18 Nov 2026 15:06:16 +0500 Subject: [PATCH] Fonts: the PostScript name of a variable font's named instance (#1864) `name` ID 6 names a variable font's default instance, so every instance was previously embedded under that same name. A named instance's PostScript name is now built as Adobe TN #5902 prescribes. Related to #1690. --- crates/fonts/src/fontdb/face.rs | 13 + crates/fonts/src/lib.rs | 1 + crates/fonts/src/psname.rs | 499 ++++++++++++++++++++++++++++++++ crates/fonts/src/testing.rs | 36 +++ 4 files changed, 549 insertions(+) create mode 100644 crates/fonts/src/psname.rs diff --git a/crates/fonts/src/fontdb/face.rs b/crates/fonts/src/fontdb/face.rs index 6dc5e994e..87e7a21a8 100644 --- a/crates/fonts/src/fontdb/face.rs +++ b/crates/fonts/src/fontdb/face.rs @@ -278,6 +278,19 @@ impl FontFace { .get_or_init(|| if self.is_variable() { None } else { self.skrifa().and_then(|f| name(&f, &[StringId::POSTSCRIPT_NAME])) }) .as_deref() } + /// The PostScript name of this face as an instance of its variable font (Adobe TN #5902): a + /// named instance's name, or one built from the axis values for a point between them. `None` + /// for a static face; the default point gets the file's `name` ID 6. + /// + /// [`Self::postscript_name`] is the file's own `name` ID 6, which names the font's default + /// instance: embedding by it put every weight of a variable font into a PDF under one name + /// (#1690). + pub fn instance_postscript_name(&self) -> Option { + if !self.is_variable() { + return None; + } + crate::psname::instance_postscript_name(&self.skrifa()?, &self.coords) + } /// Glyph id for `c` (0 = .notdef). pub fn glyph_for(&self, c: char) -> u32 { diff --git a/crates/fonts/src/lib.rs b/crates/fonts/src/lib.rs index 3d772b305..ade84be91 100644 --- a/crates/fonts/src/lib.rs +++ b/crates/fonts/src/lib.rs @@ -13,6 +13,7 @@ mod group; mod kind; #[cfg(target_os = "macos")] mod mac_fonts; +pub mod psname; #[cfg(any(test, feature = "testing"))] pub mod testing; mod vertical; diff --git a/crates/fonts/src/psname.rs b/crates/fonts/src/psname.rs new file mode 100644 index 000000000..aff68375f --- /dev/null +++ b/crates/fonts/src/psname.rs @@ -0,0 +1,499 @@ +//! The PostScript name of a variable font's named instance (Adobe TN #5902). +//! +//! `name` ID 6 names the font's **default** instance, so every instance of a variable font embeds +//! under the same name: all the weights of Noto Sans KR went into a PDF as `NotoSansKR-Thin`, and +//! Acrobat's font list, preflight and a print shop's checks then report Thin for every weight +//! (#1690). The outlines were right; only the name was wrong. + +use skrifa::raw::TableProvider; +use skrifa::{FontRef, MetadataProvider, raw::types::NameId}; + +/// Longest PostScript name `name` ID 6 may carry (OpenType), which is where this name goes. +/// +/// TN #5902 works to 127 characters and prescribes a "last resort" name past that; the shorter +/// limit here is the one that matters for a name written into the font's own `name` table. +const MAX_LEN: usize = 63; + +/// Axis values count as the same instance within this much (user units). +const AXIS_EPSILON: f32 = 1e-4; + +/// The PostScript name for the instance of `font` at `coords`, or `None` for a static font; the +/// default point gets the file's `name` ID 6. +/// +/// TN #5902: a named instance's own `postScriptNameID` wins; otherwise the name is the family +/// prefix (`name` ID 25, else the typographic family, else the family -- OpenType reads a missing +/// ID 16 as ID 1) joined to the instance's subfamily with a hyphen, keeping only ASCII letters and +/// digits. A point no named instance covers is named by its axis values +/// ([`arbitrary_instance_name`]). No more than 63 characters either way, the limit of the `name` +/// ID 6 this goes into, where the note allows 127. +pub fn instance_postscript_name(font: &FontRef<'_>, coords: &[([u8; 4], f32)]) -> Option { + let axes = font.axes(); + // `fvar` coordinates are 16.16, so two instances can sit 1/65536 apart -- closer than + // AXIS_EPSILON. Asking for an exact instance would then match whichever of them came first + // and give the one asked for the other's name, so an exact match is looked for first and the + // tolerance is only a fallback for a point that is not exactly on any instance (noted in + // review). + let at = |tolerance: f32| { + let axes = &axes; + move |ni: &skrifa::NamedInstance<'_>| { + axes.iter().zip(ni.user_coords()).all(|(axis, value)| (effective(&axis, coords) - value).abs() <= tolerance) + } + }; + let exact = at(0.0); + let near = at(AXIS_EPSILON); + let Some(instance) = font.named_instances().iter().find(|ni| exact(ni)).or_else(|| font.named_instances().iter().find(|ni| near(ni))) else { + return arbitrary_instance_name(font, coords); + }; + if let Some(id) = instance.postscript_name_id() + && let Some(name) = string(font, id) + { + // The font names this instance itself, so the name is used as it stands -- a hyphen is + // legal in a PostScript name, and `Pretendard-Heavy` is the name, not a family and a + // subfamily to join (noted in review). Only characters a PostScript name cannot hold are + // dropped. + let kept = legal(&name); + if !kept.is_empty() { + return Some(truncate(kept)); + } + } + let prefix = family_prefix(font)?; + let subfamily = string(font, instance.subfamily_name_id()).map(|s| keep(&s)).filter(|s| !s.is_empty())?; + Some(join(&prefix, &subfamily)) +} + +/// TN #5902's family prefix: `name` ID 25, else the typographic family (ID 16), else the family +/// (ID 1, which OpenType says stands in for a missing ID 16), keeping ASCII letters and digits. +fn family_prefix(font: &FontRef<'_>) -> Option { + [NameId::VARIATIONS_POSTSCRIPT_NAME_PREFIX, NameId::TYPOGRAPHIC_FAMILY_NAME, NameId::FAMILY_NAME] + .into_iter() + .find_map(|id| string(font, id).map(|s| keep(&s)).filter(|s| !s.is_empty())) +} + +/// The value of `axis` at `coords` (its default when absent), inside the axis. Compared, not +/// `clamp`ed -- `fvar` is font data, and `f32::clamp` panics on a range whose minimum is past +/// its maximum. +fn effective(axis: &skrifa::Axis, coords: &[([u8; 4], f32)]) -> f32 { + let tag = axis.tag().to_be_bytes(); + let asked = coords.iter().find(|(t, _)| *t == tag).map_or(axis.default_value(), |(_, v)| *v); + if asked < axis.min_value() { + axis.min_value() + } else if asked > axis.max_value() { + axis.max_value() + } else { + asked + } +} + +/// TN #5902's name for a point no named instance covers: the family prefix, then `_` +/// for each axis away from its default, in `fvar` order -- `AndreVar_900wght_5.5wdth`. Axes at +/// their default are left out, as the note allows, so the default point itself has no +/// descriptors and gets the file's `name` ID 6. +/// +/// Returning `None` for every such point, which this did first, left all of them embedding under +/// the default instance's name -- the bug this module is for, at any weight that is not a named +/// one (noted in review). +fn arbitrary_instance_name(font: &FontRef<'_>, coords: &[([u8; 4], f32)]) -> Option { + let axes = font.axes(); + if axes.is_empty() { + return None; + } + let prefix = family_prefix(font)?; + let mut name = prefix.clone(); + for axis in axes.iter() { + let tag = axis.tag().to_be_bytes(); + let value = effective(&axis, coords); + let fixed = to_fixed(value); + if fixed == to_fixed(axis.default_value()) { + continue; + } + name.push('_'); + name.push_str(&fixed_decimal(fixed)); + // Trailing spaces are dropped from a tag (`ital`, `wd `); anything else not a letter or + // digit cannot be in the name either. + name.push_str(&keep(&String::from_utf8_lossy(&tag))); + } + if name == prefix { + return string(font, NameId::POSTSCRIPT_NAME).map(|s| truncate(legal(&s))).filter(|s| !s.is_empty()); + } + if name.chars().count() <= MAX_LEN { + return Some(name); + } + // TN #5902's last resort: the prefix, `-`, an identifier for this instance, and `...`. + let id = format!("{:08X}", digest(&name)); + let room = MAX_LEN - 1 - id.len() - 3; + Some(format!("{}-{id}...", prefix.chars().take(room).collect::())) +} + +/// A user coordinate as `fvar`'s 16.16 fixed point. A value past `i32` saturates and NaN is 0, as +/// `as` does; neither reaches here from a font that parsed. +fn to_fixed(v: f32) -> i32 { + (f64::from(v) * 65536.0).round() as i32 +} + +/// The shortest decimal that reads back as the 16.16 value `v` (TN #5902 and its appendix): no +/// trailing zeroes, no decimal point for a whole number, `0` for zero and no `+`. A value under +/// one keeps the `0` before its point (`0.5`), the zero the integer part needs, not padding. +fn fixed_decimal(v: i32) -> String { + let x = f64::from(v) / 65536.0; + // Sixteen fractional bits need at most six decimal places to come back exactly. + for places in 0..=6 { + let s = format!("{x:.places$}"); + let back = s.parse::().map(|b| (b * 65536.0).round() as i64); + if back == Ok(i64::from(v)) { + let s = if s.contains('.') { s.trim_end_matches('0').trim_end_matches('.').to_string() } else { s }; + return if s == "-0" { "0".into() } else { s }; + } + } + format!("{x}") +} + +/// `prefix-subfamily`, or, when that is past [`MAX_LEN`], both halves shortened with a digest of +/// the whole after them. +/// +/// Both halves matter. The subfamily is what tells two instances of one family apart, so cutting +/// its end lets `Thin` and `Thin Italic` meet; the prefix is what tells two families apart, so +/// cutting *its* end lets `FamilyOne` and `FamilyTwo` meet. Neither can be shortened on its own +/// and stay unique, so a name that does not fit keeps a readable piece of each and ends in a +/// digest of `prefix-subfamily` entire -- the shape TN #5902 prescribes as a "last resort" name +/// for an instance that cannot be named inside the limit. A PDF embedding two instances under one +/// name is the thing this function exists to stop. +/// +/// Shortening only one half -- what this did before -- collided two ways, both noted in review: a +/// 62-character subfamily took a digest of the subfamily alone, so every family reached the same +/// head and the same digest, and a 60-character one left room for two prefix characters, so +/// `FamilyOne` and `FamilyTwo` both shortened to `Fa`. +fn join(prefix: &str, subfamily: &str) -> String { + let whole = format!("{prefix}-{subfamily}"); + if whole.chars().count() <= MAX_LEN { + return whole; + } + // The subfamily is usually the short half, so it is served first, down to the floor the + // prefix keeps for itself; the prefix takes what is left. The digest, not either piece, is + // what actually keeps this name off another one. + let sub_room = (VISIBLE - PREFIX_MIN - 1).min(subfamily.chars().count()); + let short_prefix: String = prefix.chars().take(VISIBLE - 1 - sub_room).collect(); + let short_subfamily: String = subfamily.chars().take(sub_room).collect(); + format!("{short_prefix}-{short_subfamily}-{:08x}", digest(&whole)) +} + +/// Characters a shortened name's readable `prefix-subfamily` gets, the rest going to the digest +/// and the hyphen before it. +const VISIBLE: usize = MAX_LEN - DIGEST_LEN - 1; + +/// A shortened name keeps at least this much of the prefix, so it still says which family it is. +const PREFIX_MIN: usize = 8; + +/// Hex characters the last-resort digest takes. +const DIGEST_LEN: usize = 8; + +/// FNV-1a over the whole `prefix-subfamily`, so two names that agree as far as the limit still +/// differ. Not a security property -- only that two different strings rarely collide. +fn digest(s: &str) -> u32 { + s.bytes().fold(0x811c_9dc5_u32, |h, b| (h ^ u32::from(b)).wrapping_mul(0x0100_0193)) +} + +/// The characters a PostScript name may hold: printable ASCII except the delimiters `[](){}<>/%` +/// and space (OpenType `name` ID 6). Used for a name the font supplies itself. +fn legal(s: &str) -> String { + s.chars().filter(|c| c.is_ascii_graphic() && !matches!(c, '[' | ']' | '(' | ')' | '{' | '}' | '<' | '>' | '/' | '%')).collect() +} + +/// A `name` table string, preferring the US English Windows record a PDF reader looks at. +/// +/// Picking the first record of the right platform took whichever language came first, so a font +/// whose subfamily is listed in another language before English generated its name from that +/// one -- or from a string whose characters all drop out, leaving no name at all (noted in +/// review). US English (0x0409 on Windows, 0 on Macintosh) is tried first. +fn string(font: &FontRef<'_>, id: NameId) -> Option { + let name = font.name().ok()?; + let records = name.name_record(); + let pick = |platform: u16, language: Option| { + records.iter().find(|r| r.name_id() == id && r.platform_id() == platform && language.is_none_or(|want| r.language_id() == want)) + }; + let record = pick(3, Some(0x0409)) + .or_else(|| pick(1, Some(0))) + .or_else(|| pick(3, None)) + .or_else(|| pick(1, None)) + .or_else(|| records.iter().find(|r| r.name_id() == id))?; + let text = record.string(name.string_data()).ok()?.chars().collect::(); + (!text.trim().is_empty()).then_some(text) +} + +/// ASCII letters and digits of `s`, which is what a PostScript name may hold. +fn keep(s: &str) -> String { + s.chars().filter(char::is_ascii_alphanumeric).collect() +} + +/// `s` at most [`MAX_LEN`] characters, cut on a character boundary (the name is ASCII here, so +/// this is a byte cut, but the font's own string need not have been). +fn truncate(s: String) -> String { + match s.char_indices().nth(MAX_LEN) { + Some((at, _)) => s[..at].to_string(), + None => s, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// A variable font named like Noto Sans KR: a `wght` axis and four named instances, with the + /// family prefix in name ID 25. + fn variable(entries: &[(u16, &str)], instances: &[(u16, Option, Vec)]) -> Vec { + let base = crate::testing::font_with_names(entries, &['A']).expect("a font with these names"); + crate::testing::with_fvar(&base, &[(*b"wght", 100.0, 100.0, 900.0, 256)], instances).expect("an fvar") + } + + fn at(font: &[u8], weight: f32) -> Option { + let f = skrifa::FontRef::new(font).expect("the fixture parses"); + instance_postscript_name(&f, &[(*b"wght", weight)]) + } + + /// `name` ID 6 names the default instance, so every weight embedded under it: the four + /// weights of Noto Sans KR all went into the PDF as `NotoSansKR-Thin` (#1690). + #[test] + fn each_named_instance_has_its_own_postscript_name() { + // 1 family, 6 the default instance's PostScript name, 25 the variations prefix, + // 257.. the instances' subfamily names. + let font = variable( + &[(1, "Noto Sans KR"), (6, "NotoSansKR-Thin"), (25, "NotoSansKR"), (257, "Thin"), (258, "Regular"), (259, "Bold"), (260, "Black")], + &[(257, None, vec![100.0]), (258, None, vec![400.0]), (259, None, vec![700.0]), (260, None, vec![900.0])], + ); + assert_eq!(at(&font, 100.0).as_deref(), Some("NotoSansKR-Thin")); + assert_eq!(at(&font, 400.0).as_deref(), Some("NotoSansKR-Regular")); + assert_eq!(at(&font, 700.0).as_deref(), Some("NotoSansKR-Bold")); + assert_eq!(at(&font, 900.0).as_deref(), Some("NotoSansKR-Black")); + // A point between the named instances is not one of them, and is named by its value + // (TN #5902, arbitrary instances). + assert_eq!(at(&font, 550.0).as_deref(), Some("NotoSansKR_550wght")); + } + + /// An instance that names its own PostScript name uses it **as it stands**: the font is + /// naming the instance, not handing over a family and a subfamily to join, and a hyphen is + /// legal in a PostScript name (noted in review). + #[test] + fn an_instances_own_postscript_name_is_used_as_it_stands() { + let font = variable( + &[(1, "Pretendard Variable"), (6, "PretendardVariable-Regular"), (25, "PretendardVariable"), (257, "Bold"), (300, "Pretendard-Heavy")], + &[(257, Some(300), vec![700.0])], + ); + assert_eq!(at(&font, 700.0).as_deref(), Some("Pretendard-Heavy"), "the hyphen the font wrote is kept"); + + // Only the characters a PostScript name cannot hold are dropped: the delimiters and + // spaces, not punctuation a name may carry. + let odd = variable(&[(1, "Fixture"), (25, "Fixture"), (257, "Bold"), (300, "Fix (ture)/Bold+2_x")], &[(257, Some(300), vec![700.0])]); + assert_eq!(at(&odd, 700.0).as_deref(), Some("FixtureBold+2_x")); + } + + /// Two instances must not arrive at the same name. Cutting the end of a long name would do + /// exactly that, so the family prefix gives way and the subfamily -- the part that tells the + /// instances apart -- is kept whole where there is room (noted in review; TN #5902 keeps the + /// identifier for the same reason). The digest after it is what keeps the name off another + /// family's, which shortening the prefix alone did not. + #[test] + fn a_long_name_keeps_the_subfamily_that_tells_instances_apart() { + let long_prefix = "P".repeat(70); + let font = variable( + &[(1, "Fixture"), (25, &long_prefix), (257, "CondensedExtraBoldItalic"), (258, "CondensedExtraBoldOblique")], + &[(257, None, vec![700.0]), (258, None, vec![800.0])], + ); + let (a, b) = (at(&font, 700.0).expect("a name"), at(&font, 800.0).expect("a name")); + assert!(a.len() <= MAX_LEN && b.len() <= MAX_LEN, "within the limit: {} and {}", a.len(), b.len()); + assert!(a.contains("-CondensedExtraBoldItalic-"), "the subfamily survives: {a}"); + assert!(b.contains("-CondensedExtraBoldOblique-"), "the subfamily survives: {b}"); + assert!(a.starts_with(&long_prefix[..8]) && b.starts_with(&long_prefix[..8]), "and so does enough of the family: {a}"); + assert_ne!(a, b, "two instances never share a name"); + } + + /// A name listed in another language before English must not be the one the name is built + /// from (noted in review). + #[test] + fn the_english_record_is_preferred() { + // `with_names` writes the whole table, so every record this needs is in the one call: + // the subfamily is listed in Japanese *before* US English for the same id. + let base = crate::testing::font_with("Fixture", &['A']).unwrap(); + let named = crate::testing::with_names( + &base, + &[ + (3, 1, 0x0411, 1, "Fixture"), + (3, 1, 0x0409, 1, "Fixture"), + (3, 1, 0x0409, 25, "Fixture"), + (3, 1, 0x0411, 257, "\u{592A}\u{5B57}"), + (3, 1, 0x0409, 257, "Bold"), + ], + ) + .expect("a name table with both languages"); + let font = crate::testing::with_fvar(&named, &[(*b"wght", 100.0, 100.0, 900.0, 256)], &[(257, None, vec![700.0])]).unwrap(); + let f = skrifa::FontRef::new(&font).unwrap(); + assert_eq!(instance_postscript_name(&f, &[(*b"wght", 700.0)]).as_deref(), Some("Fixture-Bold")); + } + + /// An instance with no PostScript name of its own, beside one that has one: `fvar` writes + /// 0xFFFF for "none", and 0 would be the copyright notice's id (noted in review). + #[test] + fn an_instance_without_its_own_name_falls_back_to_the_generated_one() { + let font = variable( + &[(0, "Copyright 2026 Nobody"), (1, "Fixture"), (25, "Fixture"), (257, "Bold"), (258, "Black"), (300, "Fixture-TheBold")], + &[(257, Some(300), vec![700.0]), (258, None, vec![900.0])], + ); + assert_eq!(at(&font, 700.0).as_deref(), Some("Fixture-TheBold"), "the instance that names itself"); + assert_eq!(at(&font, 900.0).as_deref(), Some("Fixture-Black"), "and the one that does not is generated"); + } + + /// Without ID 25 the typographic family is the prefix, then the family; and a name a + /// PostScript name cannot hold keeps only its letters and digits. + #[test] + fn the_prefix_falls_back_and_the_name_is_sanitised() { + let typographic = variable(&[(1, "Fixture"), (16, "Fixture Display"), (257, "Semi Bold")], &[(257, None, vec![600.0])]); + assert_eq!(at(&typographic, 600.0).as_deref(), Some("FixtureDisplay-SemiBold")); + + let family_only = variable(&[(1, "Fixture (Beta)"), (257, "Extra Light")], &[(257, None, vec![200.0])]); + assert_eq!(at(&family_only, 200.0).as_deref(), Some("FixtureBeta-ExtraLight")); + } + + /// `name` ID 6 carries at most 63 characters. + #[test] + fn a_name_stays_within_the_limit() { + let long = "L".repeat(80); + let font = variable(&[(1, "Fixture"), (25, &long), (257, "Regular")], &[(257, None, vec![400.0])]); + let name = at(&font, 400.0).expect("a name"); + assert!(name.len() <= MAX_LEN, "within the limit: {name}"); + // Both halves are kept, the subfamily whole here because it is short, and the digest + // after them is what tells this name from another family's (noted in review). + assert!(name.contains("-Regular-"), "and the subfamily is kept: {name}"); + assert!(name.starts_with(&long[..8]), "with enough of the family to name it: {name}"); + } + + /// A static font has no named instances, so it keeps its own `name` ID 6. + #[test] + fn a_static_font_has_no_instance_name() { + let base = crate::testing::font_with_names(&[(1, "Fixture"), (6, "Fixture-Regular")], &['A']).unwrap(); + let f = skrifa::FontRef::new(&base).unwrap(); + assert_eq!(instance_postscript_name(&f, &[]), None); + } + + /// `fvar` coordinates are 16.16, so two instances can sit 1/65536 apart -- inside + /// AXIS_EPSILON. Asking for one of them matched whichever came first and returned the + /// other's name (noted in review). + #[test] + fn two_instances_closer_than_the_tolerance_keep_their_own_names() { + // 1.0 and 1.0 + 1/65536, one 16.16 step apart: distinct in the file and 1.5e-5 apart, + // which is inside AXIS_EPSILON (1e-4). The axis has to be a small-numbered one for the + // two to be different f32s at all -- at a weight of 400 a step of 1/65536 is below half + // an ulp, so the file cannot hold two such instances there in the first place. + let step = 1.0 / 65536.0; + let base = crate::testing::font_with_names(&[(1, "Test"), (6, "Test-Regular"), (25, "Test"), (257, "Regular"), (258, "RegularPlus")], &['A']) + .expect("a font with these names"); + let font = crate::testing::with_fvar(&base, &[(*b"slnt", 0.0, 1.0, 2.0, 256)], &[(257, None, vec![1.0]), (258, None, vec![1.0 + step])]) + .expect("an fvar"); + let slnt = |font: &[u8], v: f32| { + let f = skrifa::FontRef::new(font).expect("the fixture parses"); + instance_postscript_name(&f, &[(*b"slnt", v)]) + }; + assert_ne!(1.0f32, 1.0 + step, "the two coordinates really are different numbers"); + assert_eq!(slnt(&font, 1.0).as_deref(), Some("Test-Regular"), "the exact instance wins"); + assert_eq!(slnt(&font, 1.0 + step).as_deref(), Some("Test-RegularPlus"), "and so does the one next to it"); + // A point on neither still falls back to the tolerance, which is what it is for. + assert_eq!(slnt(&font, 1.0 + step / 2.0).as_deref(), Some("Test-Regular"), "a point in between takes the nearest match"); + } + + /// Two instances must never arrive at one name: a PDF would then embed two different ones + /// under it. Both halves of the name can be what tells them apart, and shortening either in + /// isolation collided -- the subfamily's tail for two instances of a family, the prefix's for + /// two families (both noted in review). + #[test] + fn two_names_that_agree_as_far_as_the_limit_still_differ() { + // Same family, subfamilies differing only past the limit. + let head = "A".repeat(61); + let (a, b) = (join("Family", &format!("{head}B")), join("Family", &format!("{head}C"))); + assert_ne!(a, b, "{a} and {b} name different instances of one family"); + + // Different families, one subfamily. 62 characters took the digest path, which digested + // the subfamily alone, so every family reached the same head and the same digest; 60 left + // room for two prefix characters, so `FamilyOne` and `FamilyTwo` both became `Fa`. + for len in [60, 62] { + let sub = "A".repeat(len); + let (one, two) = (join("FamilyOne", &sub), join("FamilyTwo", &sub)); + assert_ne!(one, two, "subfamily of {len}: {one} and {two} name different families"); + } + + // A one-character difference anywhere in the prefix is enough, however far past the cut. + let long = "P".repeat(80); + let (p, q) = (join(&format!("{long}A"), "Thin"), join(&format!("{long}B"), "Thin")); + assert_ne!(p, q, "{p} and {q} name different families"); + + // Every shortened name is inside the limit, and is a name a PDF can hold. + for name in [a, b, p, q, join("FamilyOne", &"A".repeat(62))] { + assert!(name.chars().count() <= MAX_LEN, "{} characters: {name}", name.chars().count()); + assert_eq!(legal(&name), name, "{name} has a character a PostScript name may not hold"); + } + + // An ordinary name is untouched, and so is one that fits exactly. + assert_eq!(join("NotoSansKR", "Thin"), "NotoSansKR-Thin"); + let exact = join("Family", &"A".repeat(MAX_LEN - "Family-".len())); + assert_eq!(exact.chars().count(), MAX_LEN); + assert!(exact.starts_with("Family-") && exact.ends_with('A'), "kept whole: {exact}"); + } + + /// TN #5902's own examples for arbitrary instances, and the rules beside them: axes at their + /// default are left out, the default point itself keeps `name` ID 6, and values are the + /// shortest decimal that reads back as the same 16.16 number (noted in review). + #[test] + fn a_point_no_instance_names_is_named_by_its_axis_values() { + // 16 "Andre Var" and no prefix of its own; `wght` and `wdth`, no named instances. + let base = crate::testing::font_with_names(&[(1, "Andre Var"), (16, "Andre Var")], &['A']).expect("a font with these names"); + let font = + crate::testing::with_fvar(&base, &[(*b"wght", -10.0, 400.0, 1000.0, 256), (*b"wdth", -10.0, 100.0, 200.0, 257)], &[]).expect("an fvar"); + let f = skrifa::FontRef::new(&font).expect("the fixture parses"); + let name = |wght: f32, wdth: f32| instance_postscript_name(&f, &[(*b"wght", wght), (*b"wdth", wdth)]); + assert_eq!(name(900.0, 5.5).as_deref(), Some("AndreVar_900wght_5.5wdth"), "the note's example"); + assert_eq!(name(-2.9, -1.4).as_deref(), Some("AndreVar_-2.9wght_-1.4wdth"), "and its negative one"); + assert_eq!(name(900.0, 100.0).as_deref(), Some("AndreVar_900wght"), "an axis at its default is left out"); + assert_eq!(name(400.0, 100.0), None, "the default point is the one name ID 6 names"); + assert_eq!(name(5000.0, 100.0).as_deref(), Some("AndreVar_1000wght"), "a value past the axis is where the font draws it"); + // An axis the caller does not mention is at its default. + assert_eq!(instance_postscript_name(&f, &[(*b"wdth", 150.0)]).as_deref(), Some("AndreVar_150wdth")); + + // The shortest decimal that comes back as the same fixed value. + assert_eq!(fixed_decimal(0), "0"); + assert_eq!(fixed_decimal(to_fixed(0.5)), "0.5"); + assert_eq!(fixed_decimal(to_fixed(-2.9)), "-2.9"); + assert_eq!(fixed_decimal(1), "0.00002", "one 65536th"); + assert_eq!(fixed_decimal(to_fixed(100.0)), "100"); + for v in [1, -1, 3, 32768, 65535, 65537, -190054, 0x7fff_ffff, -0x7fff_ffff] { + let s = fixed_decimal(v); + assert_eq!((s.parse::().unwrap() * 65536.0).round() as i64, i64::from(v), "{v} came back from {s}"); + assert!(!s.ends_with('0') || !s.contains('.'), "no trailing zero: {s}"); + } + } + + /// Too many axes for the limit: TN #5902's last resort, the prefix, an identifier and `...`, + /// still one name per point. + #[test] + fn a_point_too_long_to_describe_gets_the_last_resort_name() { + let tags: Vec<[u8; 4]> = (0..12u8).map(|i| [b'a', b'x', b'0' + i / 10, b'0' + i % 10]).collect(); + let axes: Vec<_> = tags.iter().map(|t| (*t, 0.0, 0.0, 1000.0, 256)).collect(); + let base = crate::testing::font_with_names(&[(16, "Andre Var"), (25, "AndreVar")], &['A']).expect("names"); + let font = crate::testing::with_fvar(&base, &axes, &[]).expect("an fvar"); + let f = skrifa::FontRef::new(&font).expect("the fixture parses"); + let point = |v: f32| instance_postscript_name(&f, &tags.iter().map(|t| (*t, v)).collect::>()).expect("a name"); + let (a, b) = (point(123.25), point(456.5)); + for n in [&a, &b] { + assert!(n.starts_with("AndreVar-") && n.ends_with("..."), "the last resort's shape: {n}"); + assert!(n.chars().count() <= MAX_LEN, "within the limit: {n}"); + assert_eq!(legal(n), *n, "only characters a PostScript name may hold: {n}"); + } + assert_ne!(a, b, "two points, two names"); + } + + /// `fvar` is font data: an axis whose minimum is past its maximum names a point without a + /// panic (`f32::clamp` would have panicked). + #[test] + fn a_malformed_axis_range_does_not_panic() { + let base = crate::testing::font_with_names(&[(16, "Odd")], &['A']).expect("names"); + let font = crate::testing::with_fvar(&base, &[(*b"wght", 900.0, 400.0, 100.0, 256)], &[]).expect("an fvar"); + let Ok(f) = skrifa::FontRef::new(&font) else { return }; + let _ = instance_postscript_name(&f, &[(*b"wght", 550.0)]); + let _ = instance_postscript_name(&f, &[(*b"wght", f32::NAN)]); + } +} diff --git a/crates/fonts/src/testing.rs b/crates/fonts/src/testing.rs index b14fc86d7..69f5d0b0f 100644 --- a/crates/fonts/src/testing.rs +++ b/crates/fonts/src/testing.rs @@ -95,6 +95,42 @@ pub fn font_with_names(entries: &[(u16, &str)], chars: &[char]) -> Option, Vec)]) -> Option> { + let fixed = |v: f32| ((v * 65536.0).round() as i32).to_be_bytes(); + let any_ps = instances.iter().any(|(_, ps, _)| ps.is_some()); + let axis_count = u16::try_from(axes.len()).ok()?; + let instance_size = axis_count.checked_mul(4)?.checked_add(if any_ps { 6 } else { 4 })?; + let mut t = Vec::new(); + for v in [1u16, 0, 16, 2, axis_count, 20, u16::try_from(instances.len()).ok()?, instance_size] { + t.extend_from_slice(&v.to_be_bytes()); + } + for (tag, min, def, max, name_id) in axes { + t.extend_from_slice(tag); + t.extend_from_slice(&fixed(*min)); + t.extend_from_slice(&fixed(*def)); + t.extend_from_slice(&fixed(*max)); + t.extend_from_slice(&0u16.to_be_bytes()); + t.extend_from_slice(&name_id.to_be_bytes()); + } + for (subfamily, ps, coords) in instances { + if coords.len() != axes.len() { + return None; + } + t.extend_from_slice(&subfamily.to_be_bytes()); + t.extend_from_slice(&0u16.to_be_bytes()); + coords.iter().for_each(|v| t.extend_from_slice(&fixed(*v))); + if any_ps { + // 0xFFFF is "no PostScript name" in `fvar`; 0 is the copyright notice's name id, so + // writing 0 made an instance look as though it named itself (noted in review). + t.extend_from_slice(&ps.unwrap_or(0xFFFF).to_be_bytes()); + } + } + with_tables(font, vec![(*b"fvar", t)]) +} + /// Every table of the font file `font`: (tag, bytes). fn tables_of(font: &[u8]) -> Option)>> { let be16 = |b: &[u8], at: usize| b.get(at..at + 2).and_then(|s| s.try_into().ok()).map(u16::from_be_bytes);