use crate::error::{ParseError, RawTag};
use crate::reader::Reader;
use crate::tables;
use crate::tables::glyf::{GlyphOutline, GlyphRef, MAX_COMPONENT_DEPTH, MAX_OUTLINE_POINTS};
use crate::tables::{Cmap, HeadTable};
use crate::tag::TableTag;
use alloc::vec::Vec;
use font_types::{F2Dot14, GlyphId, Tag};
const SFNT_VERSION_TRUE: u32 = 0x0001_0000;
const SFNT_VERSION_OTTO: u32 = 0x4F54_544F; const SFNT_VERSION_TRUE_APPLE: u32 = 0x7472_7565; const TTC_TAG: RawTag = *b"ttcf";
const SFNT_TAG: RawTag = *b"sfnt";
const ENTRY: usize = 16;
fn is_known_sfnt_version(version: u32) -> bool {
matches!(
version,
SFNT_VERSION_TRUE | SFNT_VERSION_OTTO | SFNT_VERSION_TRUE_APPLE
)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FontRef<'a> {
data: &'a [u8],
dir_offset: usize,
num_tables: u16,
sfnt_version: u32,
}
impl<'a> FontRef<'a> {
pub fn new(data: &'a [u8]) -> Result<Self, ParseError> {
let mut r = Reader::new(data, SFNT_TAG);
let version = r.u32()?;
if !is_known_sfnt_version(version) {
return Err(ParseError::InvalidSfnt);
}
let num_tables = r.u16()?;
if num_tables == 0 {
return Err(ParseError::InvalidSfnt);
}
r.skip(6)?; validate_directory(data, 0, num_tables)?;
Ok(Self {
data,
dir_offset: 0,
num_tables,
sfnt_version: version,
})
}
#[must_use]
pub fn as_bytes(&self) -> &'a [u8] {
self.data
}
#[must_use]
pub const fn sfnt_version(&self) -> u32 {
self.sfnt_version
}
#[must_use]
pub const fn is_cff(&self) -> bool {
self.sfnt_version == SFNT_VERSION_OTTO
}
#[must_use]
pub fn is_variable(&self) -> bool {
self.table(TableTag::Fvar).is_some()
}
#[must_use]
pub const fn num_tables(&self) -> u16 {
self.num_tables
}
#[must_use]
pub fn table(&self, tag: TableTag) -> Option<&'a [u8]> {
self.table_by_tag(tag.to_tag())
}
#[must_use]
pub fn table_by_tag(&self, tag: Tag) -> Option<&'a [u8]> {
let want = tag.to_be_bytes();
for i in 0..usize::from(self.num_tables) {
let at = self.dir_offset + 12 + i * ENTRY;
let found = crate::reader::slice_at(self.data, at, 4, SFNT_TAG).ok()?;
if found == want {
let offset = crate::reader::be_u32_at(self.data, at + 8, SFNT_TAG).ok()?;
let length = crate::reader::be_u32_at(self.data, at + 12, SFNT_TAG).ok()?;
let offset = usize::try_from(offset).ok()?;
let length = usize::try_from(length).ok()?;
let end = offset.checked_add(length)?;
return self.data.get(offset..end);
}
}
None
}
#[must_use]
pub fn table_directory(&self) -> Vec<(RawTag, u32, u32, u32)> {
let mut out = Vec::with_capacity(usize::from(self.num_tables));
for i in 0..usize::from(self.num_tables) {
let at = self.dir_offset + 12 + i * ENTRY;
let (Ok(raw_tag), Ok(checksum), Ok(offset), Ok(length)) = (
crate::reader::be_u32_at(self.data, at, SFNT_TAG),
crate::reader::be_u32_at(self.data, at + 4, SFNT_TAG),
crate::reader::be_u32_at(self.data, at + 8, SFNT_TAG),
crate::reader::be_u32_at(self.data, at + 12, SFNT_TAG),
) else {
continue;
};
out.push((raw_tag.to_be_bytes(), checksum, offset, length));
}
out
}
fn table_or_err(&self, tag: TableTag) -> Result<&'a [u8], ParseError> {
self.table(tag)
.ok_or(ParseError::UnknownTableTag(tag.to_bytes()))
}
pub fn head(&self) -> Result<HeadTable<'a>, ParseError> {
HeadTable::parse(self.table_or_err(TableTag::Head)?)
}
pub fn hhea(&self) -> Result<tables::HheaTable<'a>, ParseError> {
tables::HheaTable::parse(self.table_or_err(TableTag::Hhea)?)
}
pub fn hmtx(&self) -> Result<tables::HmtxTable<'a>, ParseError> {
let num_h_metrics = self.hhea()?.number_of_h_metrics()?;
tables::HmtxTable::parse(
self.table_or_err(TableTag::Hmtx)?,
num_h_metrics,
self.num_glyphs(),
)
}
pub fn maxp(&self) -> Result<tables::MaxpTable<'a>, ParseError> {
tables::MaxpTable::parse(self.table_or_err(TableTag::Maxp)?)
}
#[must_use]
pub fn num_glyphs(&self) -> u16 {
self.table(TableTag::Maxp)
.and_then(|d| tables::MaxpTable::parse(d).ok())
.map_or(0, |m| m.num_glyphs())
}
pub fn cmap(&self) -> Result<Cmap<'a>, ParseError> {
Cmap::parse(self.table_or_err(TableTag::Cmap)?)
}
pub fn name(&self) -> Result<tables::NameTable<'a>, ParseError> {
tables::NameTable::parse(self.table_or_err(TableTag::Name)?)
}
pub fn os2(&self) -> Result<tables::Os2Table<'a>, ParseError> {
tables::Os2Table::parse(self.table_or_err(TableTag::Os2)?)
}
pub fn post(&self) -> Result<tables::PostTable<'a>, ParseError> {
tables::PostTable::parse(self.table_or_err(TableTag::Post)?)
}
pub fn stat(&self) -> Result<tables::StatTable<'a>, ParseError> {
tables::StatTable::parse(self.table_or_err(TableTag::Stat)?)
}
pub fn dsig(&self) -> Result<tables::DsigTable<'a>, ParseError> {
tables::DsigTable::parse(self.table_or_err(TableTag::Dsig)?)
}
pub fn layout(&self, kind: tables::LayoutKind) -> Result<tables::LayoutTable<'a>, ParseError> {
let tag = kind.tag();
let data = self
.table_by_tag(Tag::new(&tag))
.ok_or(ParseError::UnknownTableTag(tag))?;
tables::LayoutTable::parse(data, kind)
}
pub fn variable(&self) -> Result<VariableFont<'a>, ParseError> {
let fvar = tables::FvarTable::parse(self.table_or_err(TableTag::Fvar)?)?;
let avar = self
.table(TableTag::Avar)
.map(tables::AvarTable::parse)
.transpose()?;
let gvar = self
.table(TableTag::Gvar)
.map(|d| tables::GvarTable::parse(d, self.num_glyphs()))
.transpose()?;
Ok(VariableFont {
font: *self,
fvar,
avar,
gvar,
})
}
pub fn glyph_data(&self, gid: GlyphId) -> Result<Option<&'a [u8]>, ParseError> {
let Some(range) = self.locus(gid)? else {
return Ok(None);
};
let glyf = self.table_or_err(TableTag::Glyf)?;
Ok(glyf.get(range.start..range.end))
}
pub fn glyph(&self, gid: GlyphId) -> Result<Option<GlyphRef<'a>>, ParseError> {
match self.glyph_data(gid)? {
None => Ok(None),
Some(data) => GlyphRef::parse(data),
}
}
fn loca(&self) -> Result<tables::LocaTable<'a>, ParseError> {
let long = self.head()?.index_to_loc_format()? == 1;
tables::LocaTable::parse(self.table_or_err(TableTag::Loca)?, self.num_glyphs(), long)
}
fn locus(&self, gid: GlyphId) -> Result<Option<core::ops::Range<usize>>, ParseError> {
let Ok(id) = u16::try_from(gid.to_u32()) else {
return Ok(None);
};
self.loca()?.glyph_range(id)
}
pub fn advance_width(&self, gid: GlyphId) -> Result<u16, ParseError> {
let Ok(id) = u16::try_from(gid.to_u32()) else {
return Ok(0); };
self.hmtx()?.advance(id)
}
pub fn outline(&self, gid: GlyphId) -> Result<Option<GlyphOutline>, ParseError> {
self.outline_bounded(gid, 0, &mut 0)
}
fn outline_bounded(
&self,
gid: GlyphId,
depth: u8,
budget: &mut usize,
) -> Result<Option<GlyphOutline>, ParseError> {
if depth > MAX_COMPONENT_DEPTH {
return Err(ParseError::InvalidGlyphFormat);
}
let Some(glyph) = self.glyph(gid)? else {
return Ok(None);
};
match glyph {
GlyphRef::Simple(simple) => {
let outline = simple.outline()?;
*budget = budget.saturating_add(outline.point_count());
if *budget > MAX_OUTLINE_POINTS {
return Err(ParseError::InvalidGlyphFormat);
}
Ok(Some(outline))
}
GlyphRef::Composite(composite) => {
let mut contours = Vec::new();
for component in composite.components()? {
*budget = budget.saturating_add(1);
if *budget > MAX_OUTLINE_POINTS {
return Err(ParseError::InvalidGlyphFormat);
}
let Some(inner) = self.outline_bounded(component.glyph, depth + 1, budget)?
else {
continue;
};
let (dx, dy) = if component.args_are_offsets() {
(
f32::from(i16::try_from(component.args.0).unwrap_or(0)),
f32::from(i16::try_from(component.args.1).unwrap_or(0)),
)
} else {
(0.0, 0.0)
};
let [a, b, c, d] = component.transform;
for mut contour in inner.contours {
for pt in &mut contour.points {
let x = a * pt.x + c * pt.y + dx;
let y = b * pt.x + d * pt.y + dy;
pt.x = x;
pt.y = y;
}
contours.push(contour);
}
}
Ok(Some(GlyphOutline { contours }))
}
}
}
pub fn gvar_deltas(&self, gid: GlyphId) -> Result<Vec<tables::TupleVariation>, ParseError> {
let Some(gvar) = self.table(TableTag::Gvar) else {
return Ok(Vec::new());
};
let point_count = self.outline_point_count(gid)?;
let gvar = tables::GvarTable::parse(gvar, self.num_glyphs())?;
let Ok(id) = u16::try_from(gid.to_u32()) else {
return Ok(Vec::new());
};
gvar.glyph_deltas(id, point_count)
}
fn outline_point_count(&self, gid: GlyphId) -> Result<u16, ParseError> {
let Some(data) = self.glyph_data(gid)? else {
return Ok(4); };
let n = match GlyphRef::parse(data)? {
None => 0,
Some(GlyphRef::Simple(s)) => {
let pts = s.points()?;
usize::from(u16::try_from(pts.len()).map_err(|_| ParseError::InvalidGlyphFormat)?)
}
Some(GlyphRef::Composite(c)) => {
let comps = c.components()?;
usize::from(u16::try_from(comps.len()).map_err(|_| ParseError::InvalidGlyphFormat)?)
}
};
u16::try_from(n + 4).map_err(|_| ParseError::InvalidGlyphFormat)
}
}
#[derive(Debug, Clone)]
pub struct OwnedFont {
data: Vec<u8>,
}
impl OwnedFont {
pub fn from_sfnt(data: Vec<u8>) -> Result<Self, ParseError> {
FontRef::new(&data)?;
Ok(Self { data })
}
#[cfg(feature = "woff")]
pub fn from_woff(data: &[u8]) -> Result<Self, ParseError> {
crate::woff::decode(data)
}
#[cfg(feature = "woff2")]
pub fn from_woff2(data: &[u8]) -> Result<Self, ParseError> {
crate::woff2::decode(data)
}
pub fn from_collection(data: &[u8], index: usize) -> Result<Self, ParseError> {
let collection = FontCollection::parse(data)?;
let font = collection.font(index)?;
let mut tables_to_build: Vec<(RawTag, Vec<u8>)> = Vec::new();
for (tag, _checksum, offset, length) in font.table_directory() {
let off = usize::try_from(offset).map_err(|_| ParseError::InvalidSfnt)?;
let len = usize::try_from(length).map_err(|_| ParseError::InvalidSfnt)?;
let bytes = crate::reader::slice_at(font.data, off, len, tag)?;
tables_to_build.push((tag, bytes.to_vec()));
}
let flavor = font.sfnt_version();
build_sfnt(flavor, &mut tables_to_build).map(|data| Self { data })
}
pub fn as_font_ref(&self) -> Result<FontRef<'_>, ParseError> {
FontRef::new(&self.data)
}
#[must_use]
pub fn as_slice(&self) -> &[u8] {
&self.data
}
#[must_use]
pub fn into_vec(self) -> Vec<u8> {
self.data
}
}
#[derive(Debug, Clone)]
pub struct FontCollection<'a> {
data: &'a [u8],
offsets: Vec<usize>,
version: u32,
}
impl<'a> FontCollection<'a> {
pub fn parse(data: &'a [u8]) -> Result<Self, ParseError> {
if data.len() < 12 {
return Err(ParseError::TruncatedTable {
tag: TTC_TAG,
expected: 12,
got: data.len(),
});
}
let tag = crate::reader::slice_at(data, 0, 4, TTC_TAG)?;
if tag != TTC_TAG.as_slice() {
return Err(ParseError::InvalidSfnt);
}
let version = crate::reader::be_u32_at(data, 4, TTC_TAG)?;
let num = crate::reader::be_u32_at(data, 8, TTC_TAG)?;
let num = usize::try_from(num).map_err(|_| ParseError::InvalidSfnt)?;
let end = 12usize
.checked_add(num.checked_mul(4).ok_or(ParseError::InvalidSfnt)?)
.ok_or(ParseError::InvalidSfnt)?;
if data.len() < end {
return Err(ParseError::TruncatedTable {
tag: TTC_TAG,
expected: end,
got: data.len(),
});
}
let mut offsets = Vec::with_capacity(num);
for i in 0..num {
let off = crate::reader::be_u32_at(data, 12 + i * 4, TTC_TAG)?;
let off = usize::try_from(off).map_err(|_| ParseError::InvalidSfnt)?;
offsets.push(off);
}
Ok(Self {
data,
offsets,
version,
})
}
#[must_use]
pub const fn version(&self) -> u32 {
self.version
}
#[must_use]
pub fn len(&self) -> usize {
self.offsets.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.offsets.is_empty()
}
pub fn font(&self, index: usize) -> Result<FontRef<'a>, ParseError> {
let dir_offset =
*self
.offsets
.get(index)
.ok_or(ParseError::CollectionIndexOutOfBounds {
index,
count: self.offsets.len(),
})?;
let sub = self.data.get(dir_offset..).ok_or(ParseError::InvalidSfnt)?;
let mut r = Reader::new(sub, TTC_TAG);
let version = r.u32()?;
if !is_known_sfnt_version(version) {
return Err(ParseError::InvalidSfnt);
}
let num_tables = r.u16()?;
if num_tables == 0 {
return Err(ParseError::InvalidSfnt);
}
r.skip(6)?;
validate_directory(self.data, dir_offset, num_tables)?;
Ok(FontRef {
data: self.data,
dir_offset,
num_tables,
sfnt_version: version,
})
}
pub fn fonts(&self) -> Result<Vec<FontRef<'a>>, ParseError> {
let mut out = Vec::with_capacity(self.offsets.len());
for i in 0..self.offsets.len() {
out.push(self.font(i)?);
}
Ok(out)
}
pub fn fonts_in(data: &'a [u8]) -> Result<Vec<FontRef<'a>>, ParseError> {
Self::parse(data)?.fonts()
}
}
fn validate_directory(data: &[u8], dir_offset: usize, num_tables: u16) -> Result<(), ParseError> {
let dir_end = dir_offset
.checked_add(12 + usize::from(num_tables) * ENTRY)
.ok_or(ParseError::InvalidSfnt)?;
if data.len() < dir_end {
return Err(ParseError::TruncatedTable {
tag: SFNT_TAG,
expected: dir_end,
got: data.len(),
});
}
for i in 0..usize::from(num_tables) {
let at = dir_offset + 12 + i * ENTRY;
let offset = crate::reader::be_u32_at(data, at + 8, SFNT_TAG)?;
let length = crate::reader::be_u32_at(data, at + 12, SFNT_TAG)?;
let offset = usize::try_from(offset).map_err(|_| ParseError::InvalidSfnt)?;
let length = usize::try_from(length).map_err(|_| ParseError::InvalidSfnt)?;
let end = offset.checked_add(length).ok_or(ParseError::InvalidSfnt)?;
if end > data.len() {
let mut tag: RawTag = *b"????";
if let Some(found) = data.get(at..at + 4) {
tag.copy_from_slice(found);
}
return Err(ParseError::TruncatedTable {
tag,
expected: end,
got: data.len(),
});
}
}
Ok(())
}
#[derive(Debug, Clone, Copy)]
pub struct VariableFont<'a> {
font: FontRef<'a>,
fvar: tables::FvarTable<'a>,
avar: Option<tables::AvarTable<'a>>,
gvar: Option<tables::GvarTable<'a>>,
}
impl<'a> VariableFont<'a> {
pub fn axes(&self) -> Result<Vec<tables::VariationAxis>, ParseError> {
self.fvar.axes()
}
pub fn instances(&self) -> Result<Vec<tables::VarInstance>, ParseError> {
self.fvar.instances()
}
#[must_use]
pub const fn avar(&self) -> Option<tables::AvarTable<'a>> {
self.avar
}
#[must_use]
pub const fn gvar(&self) -> Option<tables::GvarTable<'a>> {
self.gvar
}
#[must_use]
pub const fn font(&self) -> FontRef<'a> {
self.font
}
pub fn normalize(&self, axis: usize, value: font_types::Fixed) -> Result<F2Dot14, ParseError> {
let axes = self.fvar.axes()?;
let axis_rec = axes.get(axis).ok_or(ParseError::InvalidGlyphFormat)?;
let min = axis_rec.min.to_f64();
let def = axis_rec.default.to_f64();
let max = axis_rec.max.to_f64();
let v = value.to_f64();
let normalized: f64 = if v < def {
if (def - min).abs() < f64::EPSILON {
-1.0
} else {
(v - def) / (def - min)
}
} else if (max - def).abs() < f64::EPSILON {
1.0
} else {
(v - def) / (max - def)
};
let scaled = normalized.clamp(-1.0, 1.0) * 16_384.0;
let shifted = if scaled < 0.0 {
scaled - 0.5
} else {
scaled + 0.5
};
let bits_wide = shifted as i64; let bits = i16::try_from(bits_wide).map_err(|_| ParseError::InvalidGlyphFormat)?;
let coord = F2Dot14::from_bits(bits);
match self.avar {
Some(avar) => {
let maps = avar.segment_maps()?;
Ok(maps.get(axis).map_or(coord, |m| m.map(coord)))
}
None => Ok(coord),
}
}
}
pub(crate) fn build_sfnt(
flavor: u32,
tables_in: &mut [(RawTag, Vec<u8>)],
) -> Result<Vec<u8>, ParseError> {
if tables_in.is_empty() {
return Err(ParseError::InvalidSfnt);
}
tables_in.sort_by_key(|t| t.0);
let n = tables_in.len();
let entry_selector = 31 - (n as u32).leading_zeros(); let search_range: u32 = 16 << entry_selector;
let range_shift = n as u32 * 16 - search_range;
let dir_len = 12 + n * ENTRY;
let mut out = Vec::with_capacity(dir_len + 1024);
out.extend_from_slice(&flavor.to_be_bytes());
out.extend_from_slice(&(n as u16).to_be_bytes());
out.extend_from_slice(&(search_range as u16).to_be_bytes());
out.extend_from_slice(&(entry_selector as u16).to_be_bytes());
out.extend_from_slice(&(range_shift as u16).to_be_bytes());
let mut offset: u32 = dir_len as u32;
let mut entries = Vec::with_capacity(n);
for (tag, bytes) in tables_in.iter() {
entries.push((*tag, table_checksum(bytes), offset, bytes.len() as u32));
let end = offset
.checked_add(bytes.len() as u32)
.ok_or(ParseError::InvalidSfnt)?;
let pad = (4 - (end % 4)) % 4;
offset = end.checked_add(pad).ok_or(ParseError::InvalidSfnt)?;
}
for (tag, checksum, off, len) in &entries {
out.extend_from_slice(tag);
out.extend_from_slice(&checksum.to_be_bytes());
out.extend_from_slice(&off.to_be_bytes());
out.extend_from_slice(&len.to_be_bytes());
}
for (_, bytes) in tables_in.iter() {
out.extend_from_slice(bytes);
while out.len() % 4 != 0 {
out.push(0);
}
}
let head_off = entries
.iter()
.find(|(t, _, _, _)| t == b"head")
.map(|(_, _, off, _)| *off as usize);
if let Some(head_at) = head_off {
set_bytes(&mut out, head_at + 8, &[0, 0, 0, 0])?;
let adjustment = 0xB1B0_AFBAu32.wrapping_sub(table_checksum(&out));
set_bytes(&mut out, head_at + 8, &adjustment.to_be_bytes())?;
}
Ok(out)
}
fn set_bytes(out: &mut [u8], at: usize, bytes: &[u8; 4]) -> Result<(), ParseError> {
out.get_mut(at..at + 4)
.ok_or(ParseError::InvalidSfnt)?
.copy_from_slice(bytes);
Ok(())
}
pub(crate) fn table_checksum(bytes: &[u8]) -> u32 {
let mut sum: u32 = 0;
let mut chunks = bytes.chunks_exact(4);
for c in chunks.by_ref() {
if let Ok(word) = <[u8; 4]>::try_from(c) {
sum = sum.wrapping_add(u32::from_be_bytes(word));
}
}
let rest = chunks.remainder();
if !rest.is_empty() {
let mut last = [0u8; 4];
for (i, &b) in rest.iter().enumerate() {
if let Some(slot) = last.get_mut(i) {
*slot = b;
}
}
sum = sum.wrapping_add(u32::from_be_bytes(last));
}
sum
}