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.
This commit is contained in:
Hamza Naveed authored and GitHub committed 2026-11-18 17:06:16 +07:00
1 parent 697279c56f
commit b12196eaf0
4 files changed
+549

No files matched your search

+13
View File
@@ -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<String> {
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 {
+1
View File
@@ -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;
+499
View File
@@ -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<String> {
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<String> {
[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 `_<value><tag>`
/// 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<String> {
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::<String>()))
}
/// 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::<f64>().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<String> {
let name = font.name().ok()?;
let records = name.name_record();
let pick = |platform: u16, language: Option<u16>| {
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::<String>();
(!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<u16>, Vec<f32>)]) -> Vec<u8> {
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<String> {
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::<f64>().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::<Vec<_>>()).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)]);
}
}
+36
View File
@@ -95,6 +95,42 @@ pub fn font_with_names(entries: &[(u16, &str)], chars: &[char]) -> Option<Vec<u8
with_tables(&base, vec![(*b"name", name)])
}
/// `font` with an `fvar` table: `axes` are (tag, min, default, max, axis name id) and `instances`
/// are (subfamily name id, PostScript name id, one user coordinate per axis). Version 1.0, with
/// the optional `postScriptNameID` present only when some instance names one.
pub fn with_fvar(font: &[u8], axes: &[([u8; 4], f32, f32, f32, u16)], instances: &[(u16, Option<u16>, Vec<f32>)]) -> Option<Vec<u8>> {
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<Vec<([u8; 4], Vec<u8>)>> {
let be16 = |b: &[u8], at: usize| b.get(at..at + 2).and_then(|s| s.try_into().ok()).map(u16::from_be_bytes);