font-subset 0.1.0

OpenType font subsetting
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! `hhea` table support.

use super::{Cursor, GlyphWithMetrics};
use crate::{
    alloc::Vec,
    write::{VecExt, WriteTable},
    ParseError, TableTag,
};

#[derive(Debug)]
pub(super) struct HorizontalGlyphStats {
    pub(super) advance_width_max: u16,
    pub(super) min_left_side_bearing: i16,
    pub(super) min_right_side_bearing: i16,
    pub(super) x_max_extent: i16,
}

impl Default for HorizontalGlyphStats {
    fn default() -> Self {
        Self {
            advance_width_max: 0,
            min_left_side_bearing: i16::MAX,
            min_right_side_bearing: i16::MAX,
            x_max_extent: i16::MIN,
        }
    }
}

impl HorizontalGlyphStats {
    pub(super) fn update(&mut self, glyph: &GlyphWithMetrics<'_>) {
        let Some(bbox) = glyph.inner.bounding_box() else {
            return;
        };
        self.advance_width_max = self.advance_width_max.max(glyph.advance);
        self.min_left_side_bearing = self.min_left_side_bearing.min(glyph.lsb);
        let extent = bbox.x_max - bbox.x_min + glyph.lsb;
        self.x_max_extent = self.x_max_extent.max(extent);

        let rsb = i32::from(glyph.advance) - i32::from(extent);
        if rsb < i32::from(i16::MIN) {
            self.min_right_side_bearing = i16::MIN;
        } else if let Ok(rsb) = i16::try_from(rsb) {
            self.min_right_side_bearing = self.min_right_side_bearing.min(rsb);
        }
    }
}

#[derive(Debug, Clone, Copy)]
pub(crate) struct HheaTable {
    pub(crate) ascender: i16,
    pub(crate) descender: i16,
    pub(crate) line_gap: i16,
    pub(crate) advance_width_max: u16,
    pub(crate) min_left_side_bearing: i16,
    pub(crate) min_right_side_bearing: i16,
    pub(crate) x_max_extent: i16,
    /// caretSlopeRise ..= metricDataFormat
    unparsed_after_extent: [u8; 16],
    pub(crate) number_of_h_metrics: u16,
}

impl HheaTable {
    const VERSION: u32 = 0x0001_0000;

    #[cfg_attr(
        feature = "tracing",
        tracing::instrument(level = "debug", err, skip_all, fields(range = ?cursor.range()))
    )]
    pub(super) fn parse(mut cursor: Cursor<'_>) -> Result<Self, ParseError> {
        cursor.read_u32_checked(|version| check_exact!(version, Self::VERSION))?;
        let ascender = cursor.read_i16()?;
        let descender = cursor.read_i16()?;
        let line_gap = cursor.read_i16()?;
        let advance_width_max = cursor.read_u16()?;
        let min_left_side_bearing = cursor.read_i16()?;
        let min_right_side_bearing = cursor.read_i16()?;
        let x_max_extent = cursor.read_i16()?;
        let unparsed_after_extent = cursor.read_byte_array::<16>()?;
        let number_of_h_metrics = cursor.read_u16()?;

        #[cfg(feature = "tracing")]
        tracing::debug!(
            advance_width_max,
            min_left_side_bearing,
            min_right_side_bearing,
            x_max_extent,
            number_of_h_metrics,
            "parsed basic info"
        );

        Ok(Self {
            ascender,
            descender,
            line_gap,
            advance_width_max,
            min_left_side_bearing,
            min_right_side_bearing,
            x_max_extent,
            unparsed_after_extent,
            number_of_h_metrics,
        })
    }

    #[cfg_attr(feature = "tracing", tracing::instrument(level = "debug", skip_all))]
    pub(crate) fn subset(&mut self, glyphs: &[GlyphWithMetrics<'_>], number_of_h_metrics: u16) {
        let mut glyph_stats = HorizontalGlyphStats::default();
        for glyph in glyphs {
            glyph_stats.update(glyph);
        }
        #[cfg(feature = "tracing")]
        tracing::debug!(?glyph_stats, "computed glyph stats");

        self.advance_width_max = glyph_stats.advance_width_max;
        self.x_max_extent = glyph_stats.x_max_extent;
        self.min_left_side_bearing = glyph_stats.min_left_side_bearing;
        self.min_right_side_bearing = glyph_stats.min_right_side_bearing;
        self.number_of_h_metrics = number_of_h_metrics;
    }
}

impl WriteTable for HheaTable {
    fn tag(&self) -> TableTag {
        TableTag::HHEA
    }

    fn write_to_vec(&self, buffer: &mut Vec<u8>) {
        buffer.write_u32(Self::VERSION);
        buffer.write_i16(self.ascender);
        buffer.write_i16(self.descender);
        buffer.write_i16(self.line_gap);
        buffer.write_u16(self.advance_width_max);
        buffer.write_i16(self.min_left_side_bearing);
        buffer.write_i16(self.min_right_side_bearing);
        buffer.write_i16(self.x_max_extent);
        buffer.extend_from_slice(&self.unparsed_after_extent);
        buffer.write_u16(self.number_of_h_metrics);
    }
}