use crate::error::{ParseError, RawTag};
use crate::reader::{be_i32_at, be_u16_at, be_u32_at};
use alloc::vec::Vec;
use font_types::{Fixed, Tag};
pub(crate) const TAG: RawTag = *b"stat";
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct StatAxis {
pub tag: Tag,
pub name_id: u16,
pub ordering: u16,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AxisValue {
Value1 {
axis_index: u16,
flags: u16,
value_name_id: u16,
value: Fixed,
},
Range {
axis_index: u16,
flags: u16,
value_name_id: u16,
nominal_min: Fixed,
nominal: Fixed,
nominal_max: Fixed,
},
Linked {
axis_index: u16,
flags: u16,
value_name_id: u16,
value: Fixed,
linked_value: Fixed,
},
Style {
flags: u16,
value_name_id: u16,
values: Vec<(u16, Fixed)>,
},
}
impl AxisValue {
#[must_use]
pub const fn value_name_id(&self) -> u16 {
match self {
AxisValue::Value1 { value_name_id, .. }
| AxisValue::Range { value_name_id, .. }
| AxisValue::Linked { value_name_id, .. }
| AxisValue::Style { value_name_id, .. } => *value_name_id,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct StatTable<'a> {
data: &'a [u8],
}
impl<'a> StatTable<'a> {
pub fn parse(data: &'a [u8]) -> Result<Self, ParseError> {
if data.len() < 20 {
return Err(ParseError::TruncatedTable {
tag: TAG,
expected: 20,
got: data.len(),
});
}
match be_u16_at(data, 0, TAG)? {
1 => {}
_ => return Err(ParseError::InvalidGlyphFormat),
}
let design_axis_size = be_u16_at(data, 4, TAG)?;
if design_axis_size < 8 {
return Err(ParseError::InvalidGlyphFormat);
}
Ok(Self { data })
}
#[must_use]
pub fn as_bytes(&self) -> &'a [u8] {
self.data
}
pub fn version(&self) -> Result<(u16, u16), ParseError> {
Ok((be_u16_at(self.data, 0, TAG)?, be_u16_at(self.data, 2, TAG)?))
}
pub fn design_axes(&self) -> Result<Vec<StatAxis>, ParseError> {
let count = be_u16_at(self.data, 6, TAG)?;
let offset = be_u32_at(self.data, 8, TAG)?;
let size = usize::from(be_u16_at(self.data, 4, TAG)?);
let base = usize::try_from(offset).map_err(|_| ParseError::InvalidGlyphFormat)?;
let mut out = Vec::with_capacity(usize::from(count));
for i in 0..usize::from(count) {
let at = base + i * size;
let raw = be_u32_at(self.data, at, TAG)?;
out.push(StatAxis {
tag: Tag::new(&raw.to_be_bytes()),
name_id: be_u16_at(self.data, at + 4, TAG)?,
ordering: be_u16_at(self.data, at + 6, TAG)?,
});
}
Ok(out)
}
pub fn axis_values(&self) -> Result<Vec<AxisValue>, ParseError> {
let count = be_u16_at(self.data, 12, TAG)?;
let offset = be_u32_at(self.data, 14, TAG)?;
let base = usize::try_from(offset).map_err(|_| ParseError::InvalidGlyphFormat)?;
let mut out = Vec::with_capacity(usize::from(count));
for i in 0..usize::from(count) {
let at = base + i * 2;
let off = usize::from(be_u16_at(self.data, at, TAG)?);
out.push(self.axis_value_at(base + off)?);
}
Ok(out)
}
fn axis_value_at(&self, at: usize) -> Result<AxisValue, ParseError> {
let fixed_at = |off: usize| -> Result<Fixed, ParseError> {
Ok(Fixed::from_bits(be_i32_at(self.data, off, TAG)?))
};
let format = be_u16_at(self.data, at, TAG)?;
match format {
1 => {
let axis_index = be_u16_at(self.data, at + 2, TAG)?;
let flags = be_u16_at(self.data, at + 4, TAG)?;
let name = be_u16_at(self.data, at + 6, TAG)?;
Ok(AxisValue::Value1 {
axis_index,
flags,
value_name_id: name,
value: fixed_at(at + 8)?,
})
}
2 => {
let axis_index = be_u16_at(self.data, at + 2, TAG)?;
let flags = be_u16_at(self.data, at + 4, TAG)?;
let name = be_u16_at(self.data, at + 6, TAG)?;
Ok(AxisValue::Range {
axis_index,
flags,
value_name_id: name,
nominal: fixed_at(at + 8)?,
nominal_min: fixed_at(at + 12)?,
nominal_max: fixed_at(at + 16)?,
})
}
3 => {
let axis_index = be_u16_at(self.data, at + 2, TAG)?;
let flags = be_u16_at(self.data, at + 4, TAG)?;
let name = be_u16_at(self.data, at + 6, TAG)?;
Ok(AxisValue::Linked {
axis_index,
flags,
value_name_id: name,
value: fixed_at(at + 8)?,
linked_value: fixed_at(at + 12)?,
})
}
4 => {
let axis_count = be_u16_at(self.data, at + 2, TAG)?;
let flags = be_u16_at(self.data, at + 4, TAG)?;
let name = be_u16_at(self.data, at + 6, TAG)?;
let mut values = Vec::with_capacity(usize::from(axis_count));
for a in 0..usize::from(axis_count) {
let rec_at = at + 8 + a * 6;
values.push((be_u16_at(self.data, rec_at, TAG)?, fixed_at(rec_at + 2)?));
}
Ok(AxisValue::Style {
flags,
value_name_id: name,
values,
})
}
_ => Err(ParseError::InvalidGlyphFormat),
}
}
pub fn elided_fallback_name_id(&self) -> Result<u16, ParseError> {
be_u16_at(self.data, 18, TAG)
}
}
#[cfg(test)]
mod tests {
#![allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::indexing_slicing,
clippy::panic
)]
use super::{AxisValue, StatTable};
use crate::error::ParseError;
use alloc::vec::Vec;
use font_types::Fixed;
fn sample() -> Vec<u8> {
let mut d = Vec::new();
let design_axis_offset = 20u32;
let axis_values_offset = 60u32;
d.extend_from_slice(&0x0001_0000u32.to_be_bytes()); d.extend_from_slice(&8u16.to_be_bytes()); d.extend_from_slice(&2u16.to_be_bytes()); d.extend_from_slice(&design_axis_offset.to_be_bytes());
d.extend_from_slice(&4u16.to_be_bytes()); d.extend_from_slice(&axis_values_offset.to_be_bytes());
d.extend_from_slice(&2u16.to_be_bytes()); d.extend_from_slice(b"wght");
d.extend_from_slice(&256u16.to_be_bytes());
d.extend_from_slice(&0u16.to_be_bytes());
d.extend_from_slice(b"wdth");
d.extend_from_slice(&257u16.to_be_bytes());
d.extend_from_slice(&1u16.to_be_bytes());
d.extend_from_slice(&[0u8; 24]);
d.extend_from_slice(&8u16.to_be_bytes()); d.extend_from_slice(&28u16.to_be_bytes()); d.extend_from_slice(&52u16.to_be_bytes()); d.extend_from_slice(&72u16.to_be_bytes()); d.extend_from_slice(&1u16.to_be_bytes());
d.extend_from_slice(&0u16.to_be_bytes());
d.extend_from_slice(&2u16.to_be_bytes());
d.extend_from_slice(&262u16.to_be_bytes());
d.extend_from_slice(&700i32.to_be_bytes()); d.extend_from_slice(&[0u8; 8]);
d.extend_from_slice(&2u16.to_be_bytes());
d.extend_from_slice(&0u16.to_be_bytes());
d.extend_from_slice(&2u16.to_be_bytes());
d.extend_from_slice(&263u16.to_be_bytes());
d.extend_from_slice(&400i32.to_be_bytes());
d.extend_from_slice(&350i32.to_be_bytes());
d.extend_from_slice(&450i32.to_be_bytes());
d.extend_from_slice(&[0u8; 4]);
d.extend_from_slice(&3u16.to_be_bytes());
d.extend_from_slice(&0u16.to_be_bytes());
d.extend_from_slice(&2u16.to_be_bytes());
d.extend_from_slice(&264u16.to_be_bytes());
d.extend_from_slice(&300i32.to_be_bytes());
d.extend_from_slice(&400i32.to_be_bytes());
d.extend_from_slice(&[0u8; 4]);
d.extend_from_slice(&4u16.to_be_bytes());
d.extend_from_slice(&2u16.to_be_bytes());
d.extend_from_slice(&2u16.to_be_bytes());
d.extend_from_slice(&265u16.to_be_bytes());
d.extend_from_slice(&0u16.to_be_bytes());
d.extend_from_slice(&500i32.to_be_bytes());
d.extend_from_slice(&1u16.to_be_bytes());
d.extend_from_slice(&75i32.to_be_bytes());
d
}
#[test]
fn header_and_axes() {
let d = sample();
let t = StatTable::parse(&d).unwrap();
assert_eq!(t.version().unwrap(), (1, 0));
assert_eq!(t.elided_fallback_name_id().unwrap(), 2);
let axes = t.design_axes().unwrap();
assert_eq!(axes.len(), 2);
assert_eq!(axes[0].tag.to_be_bytes(), *b"wght");
assert_eq!(axes[0].name_id, 256);
assert_eq!(axes[0].ordering, 0);
assert_eq!(axes[1].tag.to_be_bytes(), *b"wdth");
assert_eq!(axes[1].ordering, 1);
}
#[test]
fn axis_value_formats() {
let d = sample();
let t = StatTable::parse(&d).unwrap();
let values = t.axis_values().unwrap();
assert_eq!(values.len(), 4);
assert_eq!(
values[0],
AxisValue::Value1 {
axis_index: 0,
flags: 2,
value_name_id: 262,
value: Fixed::from_bits(700)
}
);
match &values[1] {
AxisValue::Range {
axis_index,
nominal_min,
nominal,
nominal_max,
..
} => {
assert_eq!(*axis_index, 0);
assert_eq!(*nominal, Fixed::from_bits(400));
assert_eq!(*nominal_min, Fixed::from_bits(350));
assert_eq!(*nominal_max, Fixed::from_bits(450));
}
other => panic!("expected range, got {other:?}"),
}
match &values[2] {
AxisValue::Linked {
value,
linked_value,
..
} => {
assert_eq!(*value, Fixed::from_bits(300));
assert_eq!(*linked_value, Fixed::from_bits(400));
}
other => panic!("expected linked, got {other:?}"),
}
match &values[3] {
AxisValue::Style {
value_name_id,
values: vals,
..
} => {
assert_eq!(*value_name_id, 265);
assert_eq!(vals.len(), 2);
assert_eq!(vals[0].0, 0);
assert_eq!(vals[0].1, Fixed::from_bits(500));
}
other => panic!("expected style, got {other:?}"),
}
assert_eq!(values[0].value_name_id(), 262);
}
#[test]
fn errors() {
assert!(matches!(
StatTable::parse(&[0u8; 19]),
Err(ParseError::TruncatedTable { .. })
));
let mut d = sample();
d[0..2].copy_from_slice(&2u16.to_be_bytes()); assert_eq!(
StatTable::parse(&d).unwrap_err(),
ParseError::InvalidGlyphFormat
);
let mut d = sample();
d[4..6].copy_from_slice(&4u16.to_be_bytes());
assert_eq!(
StatTable::parse(&d).unwrap_err(),
ParseError::InvalidGlyphFormat
);
let mut d = sample();
let fmt4_at = 60 + 72;
d[fmt4_at..fmt4_at + 2].copy_from_slice(&9u16.to_be_bytes());
let t = StatTable::parse(&d).unwrap();
assert_eq!(t.axis_values().unwrap_err(), ParseError::InvalidGlyphFormat);
}
}