mirror of
https://github.com/storytold/wordcraft.git
synced 2026-11-19 08:55:26 +00:00
Fonts: fallback no longer keeps unneeded font families in memory
Font fallback records the file stamp with the first coverage read, so a rescan does not keep loading families that are no longer needed, and a replaced file still invalidates the cache. Originally authored by @arcanii in #2345.
This commit is contained in:
1 parent
b0d3165ede
commit
c3fe680a0f
5 files changed
+415
-146
No files matched your search
@@ -26,11 +26,11 @@ mod names;
|
||||
|
||||
use face::{BUNDLED, FontBytes};
|
||||
pub use face::{FALLBACK_FAMILY, FaceRef, FontFace, bundled};
|
||||
#[cfg(test)]
|
||||
use fallback_data::{Coverage, RUN_FALLBACK_CACHE_CHARS, SYS_FALLBACK_MAX_FILE, file_coverage, ranges_hold};
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
use fallback_data::{CoverageIndex, SysFallback};
|
||||
use fallback_data::{FallbackCache, RunFallbackCache};
|
||||
#[cfg(test)]
|
||||
use fallback_data::{RUN_FALLBACK_CACHE_CHARS, coverage_ranges, ranges_hold};
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
use names::CatalogEntry;
|
||||
pub(crate) use names::face_names;
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use super::face::{FALLBACK_FAMILY, FontFace};
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
use super::fallback_data::{CoverageIndex, IndexedFile, SYS_MISSES_MAX, SYSTEM_FALLBACKS, coverage_ranges, ranges_hold, read_fallback_file};
|
||||
use super::fallback_data::{CoverageIndex, IndexedFile, SYS_MISSES_MAX, SYSTEM_FALLBACKS, file_stamp, ranges_hold, read_fallback_file};
|
||||
use super::fallback_data::{FALLBACK_CACHE_MAX, RTL_FALLBACKS, RUN_FALLBACK_CACHE_CHARS, RUN_FALLBACK_CACHE_MAX, arabic_block, fallback_order};
|
||||
use super::{Arc, FontDb};
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
@@ -235,7 +235,7 @@ impl FontDb {
|
||||
}
|
||||
|
||||
/// Load a system font covering `c` (preferred fallback families first, then any cataloged
|
||||
/// file under 40 MB, found through the coverage index). Returns true if one was loaded.
|
||||
/// file under 40 MB, both found through the coverage index). Returns true if one was loaded.
|
||||
/// Misses are remembered.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn system_fallback(&self, c: char) -> bool {
|
||||
@@ -257,6 +257,11 @@ impl FontDb {
|
||||
if self.is_loaded(fam) || !cataloged.iter().any(|f| f.eq_ignore_ascii_case(fam)) {
|
||||
continue;
|
||||
}
|
||||
// A family none of whose files maps `c` is not loaded for it: it would stay loaded
|
||||
// and help nothing (an emoji loaded every CJK family a Mac has first, 500 MB).
|
||||
if !self.family_maps(fam, c) {
|
||||
continue;
|
||||
}
|
||||
if !self.sys.lock().unwrap_or_else(std::sync::PoisonError::into_inner).tried.insert(fam) {
|
||||
continue;
|
||||
}
|
||||
@@ -276,8 +281,47 @@ impl FontDb {
|
||||
false
|
||||
}
|
||||
|
||||
/// Load the first cataloged font file (in path order) that maps `c`, reading each file not
|
||||
/// yet indexed as the search reaches it. Returns whether a loaded face now covers `c`.
|
||||
/// Does a file of the installed `family` map `c`? Answered by the coverage index, which reads
|
||||
/// a file's character maps the first time it is asked about it.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) fn family_maps(&self, family: &str, c: char) -> bool {
|
||||
let paths = self.family_paths(family);
|
||||
let mut index = self.coverage_index();
|
||||
paths.iter().any(|p| index.file_holds(p, u32::from(c)))
|
||||
}
|
||||
|
||||
/// The coverage index, its file list brought up to date with the catalog.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn coverage_index(&self) -> std::sync::MutexGuard<'_, CoverageIndex> {
|
||||
let mut index = self.coverage.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
let generation = self.catalog_gen.load(Ordering::Acquire);
|
||||
if index.generation != Some(generation) {
|
||||
// A new scan (or the first search): keep what is known of files still installed,
|
||||
// unless a file was replaced since its character maps were read.
|
||||
let mut known: HashMap<std::path::PathBuf, IndexedFile> =
|
||||
std::mem::take(&mut index.files).into_iter().map(|f| (f.path.clone(), f)).collect();
|
||||
let mut paths: Vec<std::path::PathBuf> =
|
||||
self.catalog.read().unwrap_or_else(std::sync::PoisonError::into_inner).iter().map(|e| e.path.clone()).collect();
|
||||
paths.sort();
|
||||
paths.dedup();
|
||||
let files = paths.into_iter().map(|path| match known.remove(&path) {
|
||||
Some(mut file) => {
|
||||
if file.ranges.is_some() && file.stamp != file_stamp(&file.path) {
|
||||
file.ranges = None;
|
||||
}
|
||||
file
|
||||
}
|
||||
None => IndexedFile { used: index.loaded.contains(&path), path, ranges: None, stamp: None },
|
||||
});
|
||||
index.files = files.collect();
|
||||
index.generation = Some(generation);
|
||||
}
|
||||
index
|
||||
}
|
||||
|
||||
/// Load the first cataloged font file (in path order) that maps `c`, reading the character
|
||||
/// maps of each file not yet indexed as the search reaches it. Returns whether a loaded face
|
||||
/// now covers `c`.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn indexed_fallback(&self, c: char) -> bool {
|
||||
self.load_indexed(&[c], false)
|
||||
@@ -294,49 +338,22 @@ impl FontDb {
|
||||
self.load_indexed(chars, true);
|
||||
}
|
||||
|
||||
/// Load the cataloged font files (in path order) that map every char of `chars`, reading each
|
||||
/// file not yet indexed as the search reaches it, until a loaded face covers them all; with
|
||||
/// `whole_family`, each such file's family is loaded with it (whatever of it isn't loaded
|
||||
/// yet). A collection's faces only together may map them: the search then goes on. Returns
|
||||
/// whether a loaded face now covers them all.
|
||||
/// Load the cataloged font files (in path order) that map every char of `chars`, reading the
|
||||
/// character maps of each file not yet indexed as the search reaches it, until a loaded face
|
||||
/// covers them all; with `whole_family`, each such file's family is loaded with it (whatever
|
||||
/// of it isn't loaded yet). A collection's faces only together may map them: the search then
|
||||
/// goes on. Returns whether a loaded face now covers them all.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn load_indexed(&self, chars: &[char], whole_family: bool) -> bool {
|
||||
let covered = |db: &FontDb| db.read_faces().iter().any(|f| chars.iter().all(|c| f.covers(*c)));
|
||||
let cps: Vec<u32> = chars.iter().map(|c| u32::from(*c)).collect();
|
||||
let maps_all = |ranges: &[(u32, u32)]| cps.iter().all(|cp| ranges_hold(ranges, *cp));
|
||||
let mut index = self.coverage.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
let generation = self.catalog_gen.load(Ordering::Acquire);
|
||||
if index.generation != Some(generation) {
|
||||
// A new scan (or the first search): keep what is known of files still installed.
|
||||
let mut known: HashMap<std::path::PathBuf, IndexedFile> =
|
||||
std::mem::take(&mut index.files).into_iter().map(|f| (f.path.clone(), f)).collect();
|
||||
let mut paths: Vec<std::path::PathBuf> =
|
||||
self.catalog.read().unwrap_or_else(std::sync::PoisonError::into_inner).iter().map(|e| e.path.clone()).collect();
|
||||
paths.sort();
|
||||
paths.dedup();
|
||||
let files = paths
|
||||
.into_iter()
|
||||
.map(|path| known.remove(&path).unwrap_or_else(|| IndexedFile { used: index.loaded.contains(&path), path, ranges: None }));
|
||||
index.files = files.collect();
|
||||
index.generation = Some(generation);
|
||||
}
|
||||
let mut index = self.coverage_index();
|
||||
let CoverageIndex { files, reads, .. } = &mut *index;
|
||||
for i in 0..files.len() {
|
||||
let Some(file) = files.get_mut(i).filter(|f| !f.used) else { continue };
|
||||
let mut data = None;
|
||||
match &file.ranges {
|
||||
Some(r) if !maps_all(r) => continue,
|
||||
Some(_) => {}
|
||||
None => {
|
||||
*reads += 1;
|
||||
data = read_fallback_file(&file.path);
|
||||
let ranges = data.as_deref().map(coverage_ranges).unwrap_or_default();
|
||||
let hit = maps_all(&ranges);
|
||||
file.ranges = Some(ranges);
|
||||
if !hit {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if !maps_all(file.ranges(reads)) {
|
||||
continue;
|
||||
}
|
||||
// The file maps them: load it (once; its faces are loaded fonts from now on).
|
||||
file.used = true;
|
||||
@@ -351,17 +368,12 @@ impl FontDb {
|
||||
load.push(f.path.clone());
|
||||
}
|
||||
let fonts: Vec<(Vec<u8>, Option<String>)> = load.iter().filter_map(|p| read_fallback_file(p)).map(|b| (b, None)).collect();
|
||||
*reads += fonts.len();
|
||||
if self.add_fonts(fonts) > 0 && covered(self) {
|
||||
return true;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if data.is_none() {
|
||||
*reads += 1;
|
||||
data = read_fallback_file(&file.path);
|
||||
}
|
||||
if let Some(data) = data
|
||||
if let Some(data) = read_fallback_file(&file.path)
|
||||
&& self.add_font(data) > 0
|
||||
&& covered(self)
|
||||
{
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
use super::face::{FALLBACK_FAMILY, FontFace};
|
||||
use super::{Arc, HashMap};
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
use super::{FileRef, MetadataProvider};
|
||||
use super::MetadataProvider;
|
||||
use super::face::{FALLBACK_FAMILY, FontFace};
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
use super::names::{TableReader, mini_font};
|
||||
use super::{Arc, HashMap};
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
#[derive(Default)]
|
||||
@@ -17,14 +19,16 @@ pub(super) struct SysFallback {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) const SYS_MISSES_MAX: usize = 65_536;
|
||||
|
||||
/// Installed font files larger than this are not searched for fallback characters.
|
||||
/// Installed font files larger than this are not loaded for a fallback character the coverage
|
||||
/// index finds in them (a preferred fallback family loads whatever its size).
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
const SYS_FALLBACK_MAX_FILE: u64 = 40 << 20;
|
||||
pub(super) const SYS_FALLBACK_MAX_FILE: u64 = 40 << 20;
|
||||
|
||||
/// Which characters each cataloged font file maps (#605). Before it, every distinct character no
|
||||
/// loaded font covered read and parsed every installed font file again: 500 distinct Tangut
|
||||
/// characters froze the app for most of a minute. Now each file is read once, when a search
|
||||
/// first gets to it, and later searches answer from its ranges, reading only a file that matches.
|
||||
/// characters froze the app for most of a minute. Now each file's character maps are read once,
|
||||
/// when a search first gets to it, and later searches answer from its ranges, loading only a file
|
||||
/// that matches. The system fallback asks it too before loading a preferred family.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
#[derive(Default)]
|
||||
pub(super) struct CoverageIndex {
|
||||
@@ -32,23 +36,58 @@ pub(super) struct CoverageIndex {
|
||||
pub(super) generation: Option<u32>,
|
||||
/// The cataloged font files, sorted.
|
||||
pub(super) files: Vec<IndexedFile>,
|
||||
/// Font files read by fallback searches (each at most once to index it, once more to load it).
|
||||
/// Font files whose character maps fallback searches read (each once, and again only when
|
||||
/// a rescan finds it replaced).
|
||||
pub(super) reads: usize,
|
||||
/// Files loaded by family name ([`FontDb::load_cataloged`]), whether or not they are indexed
|
||||
/// yet: a search never loads them a second time.
|
||||
pub(super) loaded: std::collections::HashSet<std::path::PathBuf>,
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
impl CoverageIndex {
|
||||
/// Does the cataloged file at `path` map `cp`? Its character maps are read the first time.
|
||||
pub(super) fn file_holds(&mut self, path: &std::path::Path, cp: u32) -> bool {
|
||||
let Ok(i) = self.files.binary_search_by(|f| f.path.as_path().cmp(path)) else { return false };
|
||||
let Some(file) = self.files.get_mut(i) else { return false };
|
||||
ranges_hold(file.ranges(&mut self.reads), cp)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) struct IndexedFile {
|
||||
pub(super) path: std::path::PathBuf,
|
||||
/// The code points the file's faces map, as sorted, disjoint inclusive ranges (`None` until
|
||||
/// the file is read; empty when it can't be read or is too large).
|
||||
/// its character maps are read; empty when they can't be).
|
||||
pub(super) ranges: Option<Box<[(u32, u32)]>>,
|
||||
/// The file's size and modification time when its character maps were read: a rescan
|
||||
/// drops the ranges of a file replaced since.
|
||||
pub(super) stamp: Option<(u64, std::time::SystemTime)>,
|
||||
/// Loaded for a character it covers: its faces are searched as loaded fonts from then on.
|
||||
pub(super) used: bool,
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
impl IndexedFile {
|
||||
/// The code points the file maps. Its character maps are read the first time (counted in
|
||||
/// `reads`), and its stamp kept with them, so a rescan keeps them unless the file is replaced.
|
||||
pub(super) fn ranges(&mut self, reads: &mut usize) -> &[(u32, u32)] {
|
||||
let (path, stamp) = (&self.path, &mut self.stamp);
|
||||
self.ranges.get_or_insert_with(|| {
|
||||
*reads += 1;
|
||||
*stamp = file_stamp(path);
|
||||
file_coverage(path)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// The size and modification time of the file at `path` (`None` when it can't be read).
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) fn file_stamp(path: &std::path::Path) -> Option<(u64, std::time::SystemTime)> {
|
||||
let meta = std::fs::metadata(path).ok()?;
|
||||
Some((meta.len(), meta.modified().ok()?))
|
||||
}
|
||||
|
||||
/// Does `ranges` (sorted, disjoint, inclusive) hold `cp`?
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) fn ranges_hold(ranges: &[(u32, u32)], cp: u32) -> bool {
|
||||
@@ -56,56 +95,94 @@ pub(super) fn ranges_hold(ranges: &[(u32, u32)], cp: u32) -> bool {
|
||||
ranges.get(i).is_some_and(|r| r.0 <= cp)
|
||||
}
|
||||
|
||||
/// The code points mapped by the faces of `data` (a font file or collection), as sorted,
|
||||
/// disjoint, inclusive ranges. Bounded however damaged the file: at most 256 faces, a budget of
|
||||
/// mappings read across them, and a cap on the ranges kept.
|
||||
/// The code points a font file's faces map, gathered face by face into sorted, disjoint,
|
||||
/// inclusive ranges. Bounded however damaged the file: a budget of mappings read across its
|
||||
/// faces, and a cap on the ranges kept.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) fn coverage_ranges(data: &[u8]) -> Box<[(u32, u32)]> {
|
||||
const MAX_FACES: u32 = 256;
|
||||
const MAX_MAPPINGS: usize = 4 * 0x11_0000;
|
||||
const MAX_RANGES: usize = 1 << 17;
|
||||
fn compact(r: &mut Vec<(u32, u32)>) {
|
||||
r.sort_unstable();
|
||||
let mut out: Vec<(u32, u32)> = Vec::with_capacity(r.len());
|
||||
for &(s, e) in r.iter() {
|
||||
#[derive(Default)]
|
||||
pub(super) struct Coverage {
|
||||
ranges: Vec<(u32, u32)>,
|
||||
mappings: usize,
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
impl Coverage {
|
||||
pub(super) const MAX_MAPPINGS: usize = 4 * 0x11_0000;
|
||||
pub(super) const MAX_RANGES: usize = 1 << 17;
|
||||
|
||||
/// Add the code points `f` maps. False once a bound is reached: later faces are left out.
|
||||
pub(super) fn add(&mut self, f: &skrifa::FontRef<'_>) -> bool {
|
||||
f.charmap().mappings().all(|(cp, _)| self.push(cp))
|
||||
}
|
||||
|
||||
/// Add one mapped code point. False once a bound is reached.
|
||||
pub(super) fn push(&mut self, cp: u32) -> bool {
|
||||
if self.mappings >= Self::MAX_MAPPINGS {
|
||||
return false;
|
||||
}
|
||||
self.mappings += 1;
|
||||
match self.ranges.last_mut() {
|
||||
Some(last) if last.1.checked_add(1) == Some(cp) => last.1 = cp,
|
||||
Some(last) if last.0 <= cp && cp <= last.1 => {}
|
||||
_ => {
|
||||
if self.ranges.len() >= Self::MAX_RANGES {
|
||||
self.compact();
|
||||
// A compaction must free a quarter of the cap, or a crafted file could make
|
||||
// every later mapping sort all the ranges again.
|
||||
if self.ranges.len() > Self::MAX_RANGES / 4 * 3 {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
self.ranges.push((cp, cp));
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
fn compact(&mut self) {
|
||||
self.ranges.sort_unstable();
|
||||
let mut out: Vec<(u32, u32)> = Vec::with_capacity(self.ranges.len());
|
||||
for &(s, e) in self.ranges.iter() {
|
||||
match out.last_mut() {
|
||||
Some(last) if s <= last.1.saturating_add(1) => last.1 = last.1.max(e),
|
||||
_ => out.push((s, e)),
|
||||
}
|
||||
}
|
||||
*r = out;
|
||||
self.ranges = out;
|
||||
}
|
||||
let count = match FileRef::new(data) {
|
||||
Ok(FileRef::Font(_)) => 1,
|
||||
Ok(FileRef::Collection(c)) => c.len().min(MAX_FACES),
|
||||
Err(_) => 0,
|
||||
};
|
||||
let mut ranges: Vec<(u32, u32)> = Vec::new();
|
||||
let mut budget = MAX_MAPPINGS;
|
||||
'faces: for i in 0..count {
|
||||
let Ok(f) = skrifa::FontRef::from_index(data, i) else { continue };
|
||||
for (cp, _) in f.charmap().mappings() {
|
||||
budget = match budget.checked_sub(1) {
|
||||
Some(b) => b,
|
||||
None => break 'faces,
|
||||
};
|
||||
match ranges.last_mut() {
|
||||
Some(last) if last.1.checked_add(1) == Some(cp) => last.1 = cp,
|
||||
Some(last) if last.0 <= cp && cp <= last.1 => {}
|
||||
_ => {
|
||||
if ranges.len() >= MAX_RANGES {
|
||||
compact(&mut ranges);
|
||||
if ranges.len() >= MAX_RANGES {
|
||||
break 'faces;
|
||||
}
|
||||
}
|
||||
ranges.push((cp, cp));
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn finish(mut self) -> Box<[(u32, u32)]> {
|
||||
self.compact();
|
||||
self.ranges.into_boxed_slice()
|
||||
}
|
||||
}
|
||||
|
||||
/// The code points the faces of the font file at `path` map, as sorted, disjoint, inclusive
|
||||
/// ranges, read from their character maps (`cmap`) alone: Apple Color Emoji's 180 MB cost a few
|
||||
/// kilobytes. Empty when the file can't be read.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) fn file_coverage(path: &std::path::Path) -> Box<[(u32, u32)]> {
|
||||
/// The longest character map read (a format 12 map of every code point is 13 MB).
|
||||
const MAX_CMAP: u32 = 16 << 20;
|
||||
let mut coverage = Coverage::default();
|
||||
let Some(mut file) = TableReader::open(path) else { return coverage.finish() };
|
||||
// The faces of a collection often share one map: each is read once.
|
||||
let mut read: Vec<(u32, u32)> = Vec::new();
|
||||
for face in 0..file.faces.len() {
|
||||
let Some(at) = file.locate(face, b"cmap") else { continue };
|
||||
if read.contains(&at) {
|
||||
continue;
|
||||
}
|
||||
read.push(at);
|
||||
let Some(cmap) = file.read(at, MAX_CMAP) else { continue };
|
||||
// A font holding just the map, to read it as the font itself would.
|
||||
let font = mini_font(&[(*b"cmap", cmap)]);
|
||||
let Ok(f) = skrifa::FontRef::new(&font) else { continue };
|
||||
if !coverage.add(&f) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
compact(&mut ranges);
|
||||
ranges.into_boxed_slice()
|
||||
coverage.finish()
|
||||
}
|
||||
|
||||
/// An installed font file's bytes, `None` when it can't be read or is larger than
|
||||
|
||||
@@ -145,43 +145,15 @@ const COLOR_BITMAP_TABLES: [&[u8; 4]; 2] = [b"sbix", b"CBDT"];
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) fn file_face_names(path: &std::path::Path) -> Vec<Found> {
|
||||
use crate::ui_fallback::OUTLINE_TABLES;
|
||||
use std::io::{Read, Seek, SeekFrom};
|
||||
/// Caps on what a (possibly damaged) file can make the scan read.
|
||||
const MAX_FACES: u32 = 256;
|
||||
/// The longest `name`, `OS/2` or `fvar` table read.
|
||||
const MAX_TABLE: u32 = 1 << 20;
|
||||
let Ok(mut file) = std::fs::File::open(path) else { return vec![] };
|
||||
let mut read_at = |offset: u64, len: usize| -> Option<Vec<u8>> {
|
||||
let mut buf = vec![0; len];
|
||||
file.seek(SeekFrom::Start(offset)).ok()?;
|
||||
file.read_exact(&mut buf).ok()?;
|
||||
Some(buf)
|
||||
};
|
||||
let be32 = |b: &[u8], at: usize| b.get(at..at + 4).and_then(|s| s.try_into().ok()).map(u32::from_be_bytes);
|
||||
let Some(head) = read_at(0, 12) else { return vec![] };
|
||||
// A collection lists where each face's table directory starts.
|
||||
let starts: Vec<u32> = if head.starts_with(b"ttcf") {
|
||||
let n = be32(&head, 8).unwrap_or(0).min(MAX_FACES) as usize;
|
||||
read_at(12, n * 4).map(|b| b.as_chunks::<4>().0.iter().map(|c| u32::from_be_bytes(*c)).collect()).unwrap_or_default()
|
||||
} else {
|
||||
vec![0]
|
||||
};
|
||||
starts
|
||||
.into_iter()
|
||||
.filter_map(|start| {
|
||||
let dir = read_at(start.into(), 12)?;
|
||||
let tables = u16::from_be_bytes(dir.get(4..6)?.try_into().ok()?) as usize;
|
||||
let records = read_at(u64::from(start) + 12, tables * 16)?;
|
||||
if !records.as_chunks::<16>().0.iter().any(|r| OUTLINE_TABLES.iter().chain(&COLOR_BITMAP_TABLES).any(|t| r.starts_with(*t))) {
|
||||
let Some(mut file) = TableReader::open(path) else { return vec![] };
|
||||
(0..file.faces.len())
|
||||
.filter_map(|face| {
|
||||
if !OUTLINE_TABLES.iter().chain(&COLOR_BITMAP_TABLES).any(|t| file.locate(face, t).is_some()) {
|
||||
return None;
|
||||
}
|
||||
let mut table = |tag: &[u8; 4]| -> Option<Vec<u8>> {
|
||||
let rec = records.as_chunks::<16>().0.iter().find(|r| r.starts_with(tag))?;
|
||||
let (offset, len) = (be32(rec, 8)?, be32(rec, 12)?);
|
||||
if len > MAX_TABLE {
|
||||
return None;
|
||||
}
|
||||
read_at(offset.into(), len as usize)
|
||||
};
|
||||
let mut table = |tag: &[u8; 4]| file.locate(face, tag).and_then(|at| file.read(at, MAX_TABLE));
|
||||
let name = table(b"name")?;
|
||||
// Variable fonts: the named instances; OS/2: the code pages (East Asian fonts).
|
||||
let mut tables: Vec<([u8; 4], Vec<u8>)> = table(b"OS/2").map(|t| (*b"OS/2", t)).into_iter().collect();
|
||||
@@ -195,6 +167,79 @@ pub(super) fn file_face_names(path: &std::path::Path) -> Vec<Found> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// A font file (or collection) read table by table instead of whole: the font folder scan and
|
||||
/// the fallback coverage index open hundreds of files, many of them megabytes long (CJK
|
||||
/// collections run to 20 MB and more, Apple Color Emoji to 180 MB).
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) struct TableReader {
|
||||
file: std::fs::File,
|
||||
/// Each face's table records (tag, checksum, offset, length), for the faces whose table
|
||||
/// directory could be read.
|
||||
pub(super) faces: Vec<Vec<[u8; 16]>>,
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
impl TableReader {
|
||||
/// Most faces read from a (possibly damaged) collection.
|
||||
const MAX_FACES: u32 = 256;
|
||||
|
||||
/// Open the font file at `path` and read its table directories; `None` when it can't be read.
|
||||
pub(super) fn open(path: &std::path::Path) -> Option<TableReader> {
|
||||
let file = std::fs::File::open(path).ok()?;
|
||||
let mut reader = TableReader { file, faces: Vec::new() };
|
||||
let head = reader.read_at(0, 12)?;
|
||||
// A collection lists where each face's table directory starts.
|
||||
let starts: Vec<u32> = if head.starts_with(b"ttcf") {
|
||||
let n = be32(&head, 8).unwrap_or(0).min(Self::MAX_FACES) as usize;
|
||||
reader.read_at(12, n * 4).map(|b| b.as_chunks::<4>().0.iter().map(|c| u32::from_be_bytes(*c)).collect()).unwrap_or_default()
|
||||
} else {
|
||||
vec![0]
|
||||
};
|
||||
for start in starts {
|
||||
if let Some(records) = reader.directory(start) {
|
||||
reader.faces.push(records);
|
||||
}
|
||||
}
|
||||
Some(reader)
|
||||
}
|
||||
|
||||
/// The table records of the face whose table directory starts at `start`.
|
||||
fn directory(&mut self, start: u32) -> Option<Vec<[u8; 16]>> {
|
||||
let dir = self.read_at(start.into(), 12)?;
|
||||
let tables = u16::from_be_bytes(dir.get(4..6)?.try_into().ok()?) as usize;
|
||||
let records = self.read_at(u64::from(start) + 12, tables * 16)?;
|
||||
Some(records.as_chunks::<16>().0.to_vec())
|
||||
}
|
||||
|
||||
/// Where face `face`'s table `tag` is: (offset, length).
|
||||
pub(super) fn locate(&self, face: usize, tag: &[u8; 4]) -> Option<(u32, u32)> {
|
||||
let rec = self.faces.get(face)?.iter().find(|r| r.starts_with(tag))?;
|
||||
Some((be32(rec, 8)?, be32(rec, 12)?))
|
||||
}
|
||||
|
||||
/// The table at `(offset, length)`; `None` when it is longer than `max_len` or can't be read.
|
||||
pub(super) fn read(&mut self, (offset, len): (u32, u32), max_len: u32) -> Option<Vec<u8>> {
|
||||
if len > max_len {
|
||||
return None;
|
||||
}
|
||||
self.read_at(offset.into(), len as usize)
|
||||
}
|
||||
|
||||
fn read_at(&mut self, offset: u64, len: usize) -> Option<Vec<u8>> {
|
||||
use std::io::{Read, Seek, SeekFrom};
|
||||
let mut buf = vec![0; len];
|
||||
self.file.seek(SeekFrom::Start(offset)).ok()?;
|
||||
self.file.read_exact(&mut buf).ok()?;
|
||||
Some(buf)
|
||||
}
|
||||
}
|
||||
|
||||
/// The big-endian `u32` at `at` in `b`.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn be32(b: &[u8], at: usize) -> Option<u32> {
|
||||
b.get(at..at.checked_add(4)?).and_then(|s| s.try_into().ok()).map(u32::from_be_bytes)
|
||||
}
|
||||
|
||||
/// A font file holding just `tables` (sorted by tag), each padded to four bytes.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
pub(super) fn mini_font(tables: &[([u8; 4], Vec<u8>)]) -> Vec<u8> {
|
||||
|
||||
@@ -305,13 +305,11 @@ fn fallback_cache_is_dropped_when_a_face_loads_by_its_legacy_family_name() {
|
||||
assert!(!cache.map.contains_key(&(missing, latin.id())), "answers from before the load are dropped");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fallback_reads_each_installed_font_file_once_however_many_characters_miss() {
|
||||
// #605: every distinct character no font covers read every installed font file again.
|
||||
let dir = font_dir("coverage");
|
||||
// The installed Regular also maps U+30000 (no bundled font does): its last cmap group, the
|
||||
// single character U+1F916, moved there (still the highest, so the groups stay sorted).
|
||||
let mut regular = renamed("SourceSans3-Regular.ttf");
|
||||
/// A bundled Source Sans 3 Regular renamed `family` (13 characters) that also maps U+30000 (no
|
||||
/// bundled font does): its last cmap group, the single character U+1F916, moved there (still the
|
||||
/// highest, so the groups stay sorted).
|
||||
fn mapping_u30000(family: &str) -> Vec<u8> {
|
||||
let mut regular = renamed_to("SourceSans3-Regular.ttf", family);
|
||||
let (from, to) = ([0x0001_F916_u32.to_be_bytes(); 2].concat(), [0x0003_0000_u32.to_be_bytes(); 2].concat());
|
||||
let mut patched = 0;
|
||||
while let Some(at) = regular.windows(from.len()).position(|w| w == from) {
|
||||
@@ -319,7 +317,14 @@ fn fallback_reads_each_installed_font_file_once_however_many_characters_miss() {
|
||||
patched += 1;
|
||||
}
|
||||
assert!(patched > 0);
|
||||
std::fs::write(dir.join("Sysfont-Regular.ttf"), regular).unwrap();
|
||||
regular
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fallback_reads_each_installed_font_file_once_however_many_characters_miss() {
|
||||
// #605: every distinct character no font covers read every installed font file again.
|
||||
let dir = font_dir("coverage");
|
||||
std::fs::write(dir.join("Sysfont-Regular.ttf"), mapping_u30000(FAMILY)).unwrap();
|
||||
let db = FontDb::with_font_dirs(vec![dir]);
|
||||
let latin = db.face(FALLBACK_FAMILY, "Regular");
|
||||
let found = db.fallback_for('\u{30000}', latin.id()).expect("the installed font maps it");
|
||||
@@ -333,7 +338,7 @@ fn fallback_reads_each_installed_font_file_once_however_many_characters_miss() {
|
||||
}
|
||||
let index = db.coverage.lock().unwrap();
|
||||
assert_eq!(index.files.len(), 2, "Regular and Bold are cataloged");
|
||||
assert_eq!(index.reads, 2, "each file read once");
|
||||
assert_eq!(index.reads, 2, "each file's character map read once");
|
||||
}
|
||||
|
||||
/// A bundled Source Sans 3 `file` renamed `family` whose last cmap group (the single character
|
||||
@@ -421,6 +426,45 @@ fn a_family_partly_loaded_by_a_character_fallback_is_loaded_whole_for_a_run() {
|
||||
assert_eq!(db.read_faces().iter().filter(|f| f.family == "Sysfont Famly").count(), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_preferred_fallback_family_loads_only_when_it_maps_the_character() {
|
||||
// A character no loaded font covers loaded every installed family in the fallback list up
|
||||
// to one that covers it, and kept them all: an emoji loaded every CJK family a Mac has,
|
||||
// about 500 MB. Malgun Gothic comes before Apple Symbols in that list.
|
||||
let dir = font_dir("preferred");
|
||||
std::fs::write(dir.join("Malgun.ttf"), renamed_to("SourceSans3-Regular.ttf", "Malgun Gothic")).unwrap();
|
||||
std::fs::write(dir.join("Symbols.ttf"), mapping_u30000("Apple Symbols")).unwrap();
|
||||
let db = FontDb::with_font_dirs(vec![dir.clone()]);
|
||||
let latin = db.face(FALLBACK_FAMILY, "Regular");
|
||||
let found = db.fallback_for('\u{30000}', latin.id()).expect("Apple Symbols maps it");
|
||||
assert_eq!(found.family, "Apple Symbols");
|
||||
assert!(!db.is_loaded("Malgun Gothic"), "a family that lacks the character isn't loaded for it");
|
||||
assert_eq!(db.coverage.lock().unwrap().reads, 2, "only the two families' character maps were read");
|
||||
// The fallback order is unchanged: when both map it, the first in the list is chosen.
|
||||
std::fs::write(dir.join("Malgun.ttf"), mapping_u30000("Malgun Gothic")).unwrap();
|
||||
let db = FontDb::with_font_dirs(vec![dir]);
|
||||
let found = db.fallback_for('\u{30000}', latin.id()).expect("both map it");
|
||||
assert_eq!(found.family, "Malgun Gothic");
|
||||
assert!(!db.is_loaded("Apple Symbols"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_preferred_fallback_family_in_a_very_large_file_is_still_found() {
|
||||
// The coverage index reads character maps, not whole files, so a preferred family is found
|
||||
// whatever its size (PingFang is 75 MB, Apple Color Emoji 180 MB): here a font padded past
|
||||
// the limit on files the index loads by itself.
|
||||
let dir = font_dir("large");
|
||||
let mut data = mapping_u30000("Apple Symbols");
|
||||
data.resize(data.len() + SYS_FALLBACK_MAX_FILE as usize, 0);
|
||||
std::fs::write(dir.join("Symbols.ttf"), &data).unwrap();
|
||||
drop(data);
|
||||
let db = FontDb::with_font_dirs(vec![dir.clone()]);
|
||||
let latin = db.face(FALLBACK_FAMILY, "Regular");
|
||||
let found = db.fallback_for('\u{30000}', latin.id()).map(|f| f.family.clone());
|
||||
std::fs::remove_file(dir.join("Symbols.ttf")).unwrap();
|
||||
assert_eq!(found.as_deref(), Some("Apple Symbols"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn screen_hinting_runs_a_tricky_fonts_instructions_with_the_monochrome_target() {
|
||||
// FreeType's "tricky" fonts (old CJK fonts listed by name, such as DynaLab's "cpop") assemble
|
||||
@@ -455,20 +499,111 @@ fn screen_hinting_runs_a_tricky_fonts_instructions_with_the_monochrome_target()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn coverage_ranges_hold_exactly_the_mapped_characters() {
|
||||
fn coverage_holds_exactly_the_mapped_characters() {
|
||||
let dir = font_dir("coverage-ranges");
|
||||
let data = renamed("SourceSans3-Regular.ttf");
|
||||
let ranges = coverage_ranges(&data);
|
||||
let ranges = file_coverage(&dir.join("Sysfont-Regular.ttf"));
|
||||
assert!(ranges.windows(2).all(|w| w[0].1 + 1 < w[1].0), "sorted, disjoint and merged");
|
||||
let font = skrifa::FontRef::new(&data).unwrap();
|
||||
let mapped: Vec<u32> = font.charmap().mappings().map(|(cp, _)| cp).collect();
|
||||
assert!(ranges.len() < mapped.len() / 4, "ranges, not a set of characters");
|
||||
assert!(mapped.iter().all(|cp| ranges_hold(&ranges, *cp)));
|
||||
for cp in [0x0, 0x9, 0x0E01, 0x17000, 0x10_FFFF] {
|
||||
for cp in [0x0, 0x9, 0x0E01, 0x17000, 0x3_0000, 0x10_FFFF] {
|
||||
assert_eq!(ranges_hold(&ranges, cp), font.charmap().map(cp).is_some(), "U+{cp:04X}");
|
||||
}
|
||||
// Damaged data indexes as nothing.
|
||||
assert!(coverage_ranges(b"ttcf\0\x01\0\0\xff\xff\xff\xff").is_empty());
|
||||
assert!(coverage_ranges(&data[..100]).is_empty());
|
||||
// A collection: what its faces map together.
|
||||
std::fs::write(dir.join("both.ttc"), collection(&[data.clone(), mapping_u30000(FAMILY)])).unwrap();
|
||||
let both = file_coverage(&dir.join("both.ttc"));
|
||||
assert!(ranges_hold(&both, 0x3_0000) && mapped.iter().all(|cp| ranges_hold(&both, *cp)));
|
||||
// Damaged, cut short, not a font or missing: nothing.
|
||||
std::fs::write(dir.join("short.ttf"), &data[..100]).unwrap();
|
||||
for name in ["damaged.ttf", "short.ttf", "readme.txt", "missing.ttf"] {
|
||||
assert!(file_coverage(&dir.join(name)).is_empty(), "{name}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn coverage_stops_when_a_compaction_frees_too_little() {
|
||||
// A crafted file whose faces interleave their code points made every mapping past the cap
|
||||
// sort all the ranges again, freeing one: a compaction must free a quarter of the cap.
|
||||
let cap = u32::try_from(Coverage::MAX_RANGES).unwrap();
|
||||
let mut c = Coverage::default();
|
||||
// One face maps every third code point, one range short of the cap; the next face maps the
|
||||
// code points after them: the first fills the cap, the second compacts it and frees one.
|
||||
assert!((0..cap - 1).all(|i| c.push(3 * i)));
|
||||
assert!(c.push(1));
|
||||
assert!(!c.push(4), "a compaction that frees one range ends the file's coverage");
|
||||
// A compaction that frees enough goes on.
|
||||
let mut c = Coverage::default();
|
||||
assert!((0..cap / 2).all(|i| c.push(2 * i)) && (0..cap / 2).all(|i| c.push(2 * i + 1)));
|
||||
assert!(c.push(cap + 1), "the compaction merges every range");
|
||||
assert_eq!(&*c.finish(), &[(0, cap - 1), (cap + 1, cap + 1)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_rescan_reads_a_replaced_font_files_character_maps_again() {
|
||||
// A font updated in place since its character maps were read: what the update maps counts.
|
||||
let dir = font_dir("replaced");
|
||||
let db = FontDb::with_font_dirs(vec![dir.clone()]);
|
||||
assert!(!db.family_maps(FAMILY, '\u{30000}'));
|
||||
// The update is a few bytes longer, so it differs however coarse the file times are.
|
||||
let mut data = mapping_u30000(FAMILY);
|
||||
data.extend_from_slice(&[0; 4]);
|
||||
std::fs::write(dir.join("Sysfont-Regular.ttf"), data).unwrap();
|
||||
assert!(!db.family_maps(FAMILY, '\u{30000}'), "the index answers until the folders are scanned again");
|
||||
db.load_system_fonts();
|
||||
assert!(db.family_maps(FAMILY, '\u{30000}'));
|
||||
assert_eq!(db.coverage.lock().unwrap().reads, 3, "the unchanged Bold file isn't read again");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_rescan_keeps_the_character_maps_a_fallback_search_read() {
|
||||
// Files indexed by a fallback search, not only by a family lookup, keep their character maps
|
||||
// through a rescan: #605's hundreds of files aren't read again after each font folder change.
|
||||
let dir = font_dir("rescan-fallback");
|
||||
std::fs::write(dir.join("Sysfont-Regular.ttf"), mapping_u30000(FAMILY)).unwrap();
|
||||
let db = FontDb::with_font_dirs(vec![dir]);
|
||||
let latin = db.face(FALLBACK_FAMILY, "Regular");
|
||||
assert!(db.fallback_for('\u{30000}', latin.id()).is_some(), "the installed font maps it");
|
||||
assert_eq!(db.coverage.lock().unwrap().reads, 2, "the Bold file and then the Regular");
|
||||
db.load_system_fonts();
|
||||
// Nothing maps it: the search reaches the Bold file, which isn't loaded, and asks its ranges.
|
||||
assert!(db.fallback_for('\u{F0001}', latin.id()).is_none());
|
||||
assert_eq!(db.coverage.lock().unwrap().reads, 2, "the rescan kept both files' character maps");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn coverage_of_installed_fonts_is_what_their_loaded_faces_map() {
|
||||
// Read from the character maps alone, as the whole file maps. Uses installed fonts when
|
||||
// there are some, collections among them.
|
||||
let paths: Vec<&Path> = [
|
||||
"/System/Library/Fonts/Helvetica.ttc",
|
||||
"/System/Library/Fonts/Hiragino Sans GB.ttc",
|
||||
"/System/Library/Fonts/Supplemental/Arial Unicode.ttf",
|
||||
"C:\\Windows\\Fonts\\arial.ttf",
|
||||
"C:\\Windows\\Fonts\\msyh.ttc",
|
||||
"/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
|
||||
"/usr/share/fonts/noto/NotoSans-Regular.ttf",
|
||||
]
|
||||
.iter()
|
||||
.map(Path::new)
|
||||
.filter(|p| p.exists())
|
||||
.collect();
|
||||
if paths.is_empty() {
|
||||
eprintln!("no known font installed: nothing to check");
|
||||
}
|
||||
for path in paths {
|
||||
let data = std::fs::read(path).unwrap();
|
||||
let faces = match FileRef::new(&data).unwrap() {
|
||||
FileRef::Font(_) => 1,
|
||||
FileRef::Collection(c) => c.len(),
|
||||
};
|
||||
let mut whole = Coverage::default();
|
||||
for i in 0..faces {
|
||||
assert!(whole.add(&skrifa::FontRef::from_index(&data, i).unwrap()));
|
||||
}
|
||||
assert_eq!(file_coverage(path), whole.finish(), "{}", path.display());
|
||||
}
|
||||
}
|
||||
|
||||
/// A bundled font renamed by a `name` table holding just its family names: (Windows language id,
|
||||
|
||||
Reference in new issue
Block a user