Add support for variable fonts

.github/workflows/ci.yml

@@ -25,6 +25,8 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
       - run: cargo build
         name: Build
+      - run: cargo build --no-default-features
+        name: Build without default features
       - run: cargo test
         name: Run tests
 

Cargo.toml

@@ -23,9 +23,16 @@ repository = { workspace = true }
 readme = { workspace = true }
 license = { workspace = true }
 
+[features]
+default = ["variable-fonts"]
+variable-fonts = ["dep:skrifa", "dep:write-fonts", "dep:kurbo"]
+
 [dependencies]
 rustc-hash = "2.1"
+skrifa = { optional = true, version = "0.33" }
+kurbo = { optional = true, version = "0.11" }
+write-fonts = { optional = true, version = "0.39.1"}
 
 [dev-dependencies]
-skrifa = "0.29.0"
+skrifa = "0.33"
 ttf-parser = "0.25.1"

NOTICE

@@ -66,7 +66,9 @@ SOFTWARE.
 The SIL OPEN FONT LICENSE Version 1.1 applies to the following fonts:
 - fonts/ClickerScript-Regular.ttf
 - fonts/MPLUS1p-Regular.ttf
+- fonts/Cantarell-VF.otf
 - fonts/NotoSans-Regular.ttf
+- fonts/NotoSans-Regular_var.ttf
 - fonts/NotoSansCJKsc-Bold-subset1.otf
 - fonts/NotoSansCJKsc-Regular.otf
 - fonts/Syne-Regular_subset.oft (Copyright 2017 The Syne Project Authors (https://gitlab.com/bonjour-monde/fonderie/syne-typeface))

src/cff2.rs

@@ -0,0 +1,25 @@
+use crate::interjector::Interjector;
+use crate::Error::MalformedFont;
+use crate::{glyf, Context, MaxpData};
+use std::borrow::Cow;
+
+/// CFF2 fonts will currently be converted into TTF fonts.
+pub fn subset(ctx: &mut Context) -> crate::Result<()> {
+    let mut maxp_data = MaxpData::default();
+
+    let result = glyf::subset_with(ctx, |old_gid, ctx| {
+        let data = match &ctx.interjector {
+            // We reject CFF2 fonts earlier if `variable-fonts` feature is not enabled.
+            Interjector::Dummy(_) => unreachable!(),
+            #[cfg(feature = "variable-fonts")]
+            Interjector::Skrifa(s) => {
+                Cow::Owned(s.glyph_data(&mut maxp_data, old_gid).ok_or(MalformedFont)?)
+            }
+        };
+
+        Ok(data)
+    });
+
+    ctx.custom_maxp_data = Some(maxp_data);
+    result
+}

src/glyf.rs

@@ -46,7 +46,29 @@ pub fn closure(face: &Face, glyph_remapper: &mut GlyphRemapper) -> Result<()> {
 }
 
 pub fn subset(ctx: &mut Context) -> Result<()> {
-    let subsetted_entries = subset_glyf_entries(ctx)?;
+    let table = Table::new(&ctx.face).ok_or(MalformedFont)?;
+    let mut _maxp = MaxpData::default();
+
+    subset_with(ctx, |old_gid, ctx| {
+        let data = match &ctx.interjector {
+            Interjector::Dummy(_) => {
+                Cow::Borrowed(table.glyph_data(old_gid).ok_or(MalformedFont)?)
+            }
+            #[cfg(feature = "variable-fonts")]
+            Interjector::Skrifa(s) => {
+                Cow::Owned(s.glyph_data(&mut _maxp, old_gid).ok_or(MalformedFont)?)
+            }
+        };
+
+        Ok(data)
+    })
+}
+
+pub(crate) fn subset_with<'a>(
+    ctx: &mut Context<'a>,
+    glyph_data_fn: impl FnMut(u16, &Context<'a>) -> Result<Cow<'a, [u8]>>,
+) -> Result<()> {
+    let subsetted_entries = subset_glyf_entries(ctx, glyph_data_fn)?;
 
     let mut sub_glyf = Writer::new();
     let mut sub_loca = Writer::new();
@@ -112,29 +134,30 @@ impl<'a> Table<'a> {
     }
 }
 
-fn subset_glyf_entries<'a>(ctx: &mut Context<'a>) -> Result<Vec<Cow<'a, [u8]>>> {
-    let table = Table::new(&ctx.face).ok_or(MalformedFont)?;
-
+fn subset_glyf_entries<'a>(
+    ctx: &mut Context<'a>,
+    mut glyph_data_fn: impl FnMut(u16, &Context<'a>) -> Result<Cow<'a, [u8]>>,
+) -> Result<Vec<Cow<'a, [u8]>>> {
     let mut size = 0;
     let mut glyf_entries = vec![];
 
     for old_gid in ctx.mapper.remapped_gids() {
-        let glyph_data = table.glyph_data(old_gid).ok_or(MalformedFont)?;
+        let glyph_data = glyph_data_fn(old_gid, ctx)?;
 
         // Empty glyph.
         if glyph_data.is_empty() {
-            glyf_entries.push(Cow::Borrowed(glyph_data));
+            glyf_entries.push(glyph_data);
             continue;
         }
 
-        let mut r = Reader::new(glyph_data);
+        let mut r = Reader::new(&glyph_data);
         let num_contours = r.read::<i16>().ok_or(MalformedFont)?;
 
         let glyph_data = if num_contours < 0 {
-            Cow::Owned(remap_component_glyph(&ctx.mapper, glyph_data)?)
+            Cow::Owned(remap_component_glyph(&ctx.mapper, &glyph_data)?)
         } else {
             // Simple glyphs don't need any subsetting.
-            Cow::Borrowed(glyph_data)
+            glyph_data
         };
 
         let mut len = glyph_data.len();