read_fonts/tables/

glyf.rs

//! The [glyf (Glyph Data)](https://docs.microsoft.com/en-us/typography/opentype/spec/glyf) table

pub mod bytecode;
mod hint_reliant;
pub mod outline;

pub use hint_reliant::is_hint_reliant;

use bytemuck::AnyBitPattern;
use core::ops::{Add, AddAssign, Div, Mul, MulAssign, Sub};
use types::{F26Dot6, Point};

include!("../../generated/generated_glyf.rs");

/// Number of "phantom" points appended to the end of a glyph outline.
///
/// These are not part of the glyph's contours. They carry the horizontal and
/// vertical side bearings and advances so that variation deltas and the
/// TrueType interpreter can adjust glyph metrics along with the outline.
///
/// See [phantom points](https://learn.microsoft.com/en-us/typography/opentype/spec/tt_instructing_glyphs#phantom-points).
pub const PHANTOM_POINT_COUNT: usize = 4;

/// Marker bits for point flags that are set during variation delta
/// processing and hinting.
#[derive(Copy, Clone, PartialEq, Eq, Default, Debug)]
pub struct PointMarker(u8);

impl PointMarker {
    /// Marker for points that have an explicit delta in a glyph variation
    /// tuple.
    pub const HAS_DELTA: Self = Self(0x4);

    /// Marker that signifies that the x coordinate of a point has been touched
    /// by an IUP hinting instruction.
    pub const TOUCHED_X: Self = Self(0x10);

    /// Marker that signifies that the y coordinate of a point has been touched
    /// by an IUP hinting instruction.
    pub const TOUCHED_Y: Self = Self(0x20);

    /// Marker that signifies that the both coordinates of a point has been touched
    /// by an IUP hinting instruction.
    pub const TOUCHED: Self = Self(Self::TOUCHED_X.0 | Self::TOUCHED_Y.0);

    /// Marks this point as a candidate for weak interpolation.
    ///
    /// Used by the automatic hinter.
    pub const WEAK_INTERPOLATION: Self = Self(0x2);

    /// Marker for points where the distance to next point is very small.
    ///
    /// Used by the automatic hinter.
    pub const NEAR: PointMarker = Self(0x8);
}

impl core::ops::BitOr for PointMarker {
    type Output = Self;

    fn bitor(self, rhs: Self) -> Self::Output {
        Self(self.0 | rhs.0)
    }
}

/// Flags describing the properties of a point.
///
/// Some properties, such as on- and off-curve flags are intrinsic to the point
/// itself. Others, designated as markers are set and cleared while an outline
/// is being transformed during variation application and hinting.
#[derive(
    Copy, Clone, PartialEq, Eq, Default, Debug, bytemuck::AnyBitPattern, bytemuck::NoUninit,
)]
#[repr(transparent)]
pub struct PointFlags(u8);

impl PointFlags {
    // Note: OFF_CURVE_QUAD is signified by the absence of both ON_CURVE
    // and OFF_CURVE_CUBIC bits, per FreeType and TrueType convention.
    const ON_CURVE: u8 = SimpleGlyphFlags::ON_CURVE_POINT.bits;
    const OFF_CURVE_CUBIC: u8 = SimpleGlyphFlags::CUBIC.bits;
    const CURVE_MASK: u8 = Self::ON_CURVE | Self::OFF_CURVE_CUBIC;

    /// Creates a new on curve point flag.
    pub const fn on_curve() -> Self {
        Self(Self::ON_CURVE)
    }

    /// Creates a new off curve quadratic point flag.
    pub const fn off_curve_quad() -> Self {
        Self(0)
    }

    /// Creates a new off curve cubic point flag.
    pub const fn off_curve_cubic() -> Self {
        Self(Self::OFF_CURVE_CUBIC)
    }

    /// Creates a point flag from the given bits. These are truncated
    /// to ignore markers.
    pub const fn from_bits(bits: u8) -> Self {
        Self(bits & Self::CURVE_MASK)
    }

    /// Returns true if this is an on curve point.
    #[inline]
    pub const fn is_on_curve(self) -> bool {
        self.0 & Self::ON_CURVE != 0
    }

    /// Returns true if this is an off curve quadratic point.
    #[inline]
    pub const fn is_off_curve_quad(self) -> bool {
        self.0 & Self::CURVE_MASK == 0
    }

    /// Returns true if this is an off curve cubic point.
    #[inline]
    pub const fn is_off_curve_cubic(self) -> bool {
        self.0 & Self::CURVE_MASK == Self::OFF_CURVE_CUBIC
    }

    pub const fn is_off_curve(self) -> bool {
        self.is_off_curve_quad() || self.is_off_curve_cubic()
    }

    /// Flips the state of the on curve flag.
    ///
    /// This is used for the TrueType `FLIPPT` instruction.
    pub fn flip_on_curve(&mut self) {
        self.0 ^= 1;
    }

    /// Enables the on curve flag.
    ///
    /// This is used for the TrueType `FLIPRGON` instruction.
    pub fn set_on_curve(&mut self) {
        self.0 |= Self::ON_CURVE;
    }

    /// Disables the on curve flag.
    ///
    /// This is used for the TrueType `FLIPRGOFF` instruction.
    pub fn clear_on_curve(&mut self) {
        self.0 &= !Self::ON_CURVE;
    }

    /// Returns true if the given marker is set for this point.
    pub fn has_marker(self, marker: PointMarker) -> bool {
        self.0 & marker.0 != 0
    }

    /// Applies the given marker to this point.
    pub fn set_marker(&mut self, marker: PointMarker) {
        self.0 |= marker.0;
    }

    /// Clears the given marker for this point.
    pub fn clear_marker(&mut self, marker: PointMarker) {
        self.0 &= !marker.0
    }

    /// Returns a copy with all markers cleared.
    pub const fn without_markers(self) -> Self {
        Self(self.0 & Self::CURVE_MASK)
    }

    /// Returns the underlying bits.
    pub const fn to_bits(self) -> u8 {
        self.0
    }
}

/// Trait for types that are usable for TrueType point coordinates.
pub trait PointCoord:
    Copy
    + Default
    // You could bytemuck with me
    + AnyBitPattern
    // You could compare me
    + PartialEq
    + PartialOrd
    // You could do math with me
    + Add<Output = Self>
    + AddAssign
    + Sub<Output = Self>
    + Div<Output = Self>
    + Mul<Output = Self>
    + MulAssign {
    fn from_fixed(x: Fixed) -> Self;
    fn from_i32(x: i32) -> Self;
    fn to_f32(self) -> f32;
    fn midpoint(self, other: Self) -> Self;
}

impl<'a> SimpleGlyph<'a> {
    /// Returns the total number of points.
    pub fn num_points(&self) -> usize {
        self.end_pts_of_contours()
            .last()
            .map(|last| last.get() as usize + 1)
            .unwrap_or(0)
    }

    /// Returns true if the contours in the simple glyph may overlap.
    pub fn has_overlapping_contours(&self) -> bool {
        // Checks the first flag for the OVERLAP_SIMPLE bit.
        // Spec says: "When used, it must be set on the first flag byte for
        // the glyph."
        FontData::new(self.glyph_data())
            .read_at::<SimpleGlyphFlags>(0)
            .map(|flag| flag.contains(SimpleGlyphFlags::OVERLAP_SIMPLE))
            .unwrap_or_default()
    }

    /// Reads points and flags into the provided buffers.
    ///
    /// Drops all flag bits except on-curve and cubic. The lengths of the
    /// buffers must equal the value returned by [num_points](Self::num_points).
    ///
    /// ## Performance
    ///
    /// As the name implies, this is faster than using the iterator returned by
    /// [points](Self::points) so should be used when it is possible to
    /// preallocate buffers.
    pub fn read_points_fast<C: PointCoord>(
        &self,
        points: &mut [Point<C>],
        flags: &mut [PointFlags],
    ) -> Result<(), ReadError> {
        let n_points = self.num_points();
        if points.len() != n_points || flags.len() != n_points {
            return Err(ReadError::InvalidArrayLen);
        }
        if n_points == 0 {
            return Ok(());
        }
        let mut cursor = FontData::new(self.glyph_data()).cursor();
        // The flag run can use two bytes per point (a flag plus its repeat
        // count), so the encoded flags may be longer than n_points; read over
        // all the available data and stop once every point has a flag.
        let flags_data = cursor.read_array::<u8>(cursor.remaining_bytes())?;
        let mut flags_iter = flags_data.iter().copied();
        // Keep track of the actual number of flag bytes read so that we can
        // create a new cursor for reading coordinates
        let mut read_flags_bytes = 0;
        let mut i = 0;
        while let Some(flag_bits) = flags_iter.next() {
            read_flags_bytes += 1;
            if SimpleGlyphFlags::from_bits_truncate(flag_bits)
                .contains(SimpleGlyphFlags::REPEAT_FLAG)
            {
                let count = (flags_iter.next().ok_or(ReadError::OutOfBounds)? as usize + 1)
                    .min(n_points - i);
                read_flags_bytes += 1;
                for f in &mut flags[i..i + count] {
                    f.0 = flag_bits;
                }
                i += count;
            } else {
                flags[i].0 = flag_bits;
                i += 1;
            }
            if i == n_points {
                break;
            }
        }
        // This used to use a `Cursor` but that implies saturating
        // arithmetic, bounds checking and `Result` building for each byte
        // read.
        //
        // A byte slice iterator is just a pointer comparison and is
        // significantly faster.
        let coords = self
            .glyph_data()
            .get(read_flags_bytes..)
            .ok_or(ReadError::OutOfBounds)?;
        let mut bytes = coords.iter();
        let mut x = 0i32;
        for (&point_flags, point) in flags.iter().zip(points.as_mut()) {
            let mut delta = 0i32;
            let flag = SimpleGlyphFlags::from_bits_truncate(point_flags.0);
            if flag.contains(SimpleGlyphFlags::X_SHORT_VECTOR) {
                delta = *bytes.next().ok_or(ReadError::OutOfBounds)? as i32;
                if !flag.contains(SimpleGlyphFlags::X_IS_SAME_OR_POSITIVE_X_SHORT_VECTOR) {
                    delta = -delta;
                }
            } else if !flag.contains(SimpleGlyphFlags::X_IS_SAME_OR_POSITIVE_X_SHORT_VECTOR) {
                let hi = *bytes.next().ok_or(ReadError::OutOfBounds)?;
                let lo = *bytes.next().ok_or(ReadError::OutOfBounds)?;
                delta = i16::from_be_bytes([hi, lo]) as i32;
            }
            x = x.wrapping_add(delta);
            point.x = C::from_i32(x);
        }
        let mut y = 0i32;
        for (point_flags, point) in flags.iter_mut().zip(points.as_mut()) {
            let mut delta = 0i32;
            let flag = SimpleGlyphFlags::from_bits_truncate(point_flags.0);
            if flag.contains(SimpleGlyphFlags::Y_SHORT_VECTOR) {
                delta = *bytes.next().ok_or(ReadError::OutOfBounds)? as i32;
                if !flag.contains(SimpleGlyphFlags::Y_IS_SAME_OR_POSITIVE_Y_SHORT_VECTOR) {
                    delta = -delta;
                }
            } else if !flag.contains(SimpleGlyphFlags::Y_IS_SAME_OR_POSITIVE_Y_SHORT_VECTOR) {
                let hi = *bytes.next().ok_or(ReadError::OutOfBounds)?;
                let lo = *bytes.next().ok_or(ReadError::OutOfBounds)?;
                delta = i16::from_be_bytes([hi, lo]) as i32;
            }
            y = y.wrapping_add(delta);
            point.y = C::from_i32(y);
            point_flags.0 &= PointFlags::CURVE_MASK;
        }
        Ok(())
    }

    /// Returns an iterator over the points in the glyph.
    ///
    /// ## Performance
    ///
    /// This is slower than [read_points_fast](Self::read_points_fast) but
    /// provides access to the points without requiring a preallocated buffer.
    pub fn points(&self) -> impl Iterator<Item = CurvePoint> + 'a + Clone {
        self.points_impl()
            .unwrap_or_else(|| PointIter::new(&[], &[], &[]))
    }

    fn points_impl(&self) -> Option<PointIter<'a>> {
        let end_points = self.end_pts_of_contours();
        let n_points = end_points.last()?.get().checked_add(1)?;
        let data = self.glyph_data();
        let lens = resolve_coords_len(data, n_points).ok()?;
        let total_len = lens.flags + lens.x_coords + lens.y_coords;
        if data.len() < total_len as usize {
            return None;
        }

        let (flags, data) = data.split_at(lens.flags as usize);
        let (x_coords, y_coords) = data.split_at(lens.x_coords as usize);

        Some(PointIter::new(flags, x_coords, y_coords))
    }
}

/// Point with associated on-curve and cubic flags in a simple glyph.
///
/// This type is a simpler representation of the data in the blob.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct CurvePoint {
    /// X coordinate.
    pub x: i16,
    /// Y coordinate.
    pub y: i16,
    /// True if this is an on-curve point.
    pub on_curve: bool,
    /// True if the CUBIC flag is set, including on on-curve points.
    pub cubic: bool,
}

impl CurvePoint {
    /// Construct a new `CurvePoint`
    pub fn new(x: i16, y: i16, on_curve: bool) -> Self {
        Self {
            x,
            y,
            on_curve,
            cubic: false,
        }
    }

    /// Convenience method to construct an on-curve point
    pub fn on_curve(x: i16, y: i16) -> Self {
        Self::new(x, y, true)
    }

    /// Convenience method to construct an off-curve point
    pub fn off_curve(x: i16, y: i16) -> Self {
        Self::new(x, y, false)
    }

    /// Constructs a cubic off-curve control point.
    pub fn off_curve_cubic(x: i16, y: i16) -> Self {
        Self {
            cubic: true,
            ..Self::off_curve(x, y)
        }
    }
}

#[derive(Clone)]
struct PointIter<'a> {
    flags: Cursor<'a>,
    x_coords: Cursor<'a>,
    y_coords: Cursor<'a>,
    flag_repeats: u16,
    cur_flags: SimpleGlyphFlags,
    cur_x: i16,
    cur_y: i16,
}

impl Iterator for PointIter<'_> {
    type Item = CurvePoint;
    fn next(&mut self) -> Option<Self::Item> {
        self.advance_flags()?;
        self.advance_points();
        Some(CurvePoint {
            x: self.cur_x,
            y: self.cur_y,
            on_curve: self.cur_flags.contains(SimpleGlyphFlags::ON_CURVE_POINT),
            cubic: self.cur_flags.contains(SimpleGlyphFlags::CUBIC),
        })
    }
}

impl<'a> PointIter<'a> {
    fn new(flags: &'a [u8], x_coords: &'a [u8], y_coords: &'a [u8]) -> Self {
        Self {
            flags: FontData::new(flags).cursor(),
            x_coords: FontData::new(x_coords).cursor(),
            y_coords: FontData::new(y_coords).cursor(),
            flag_repeats: 0,
            cur_flags: SimpleGlyphFlags::empty(),
            cur_x: 0,
            cur_y: 0,
        }
    }

    fn advance_flags(&mut self) -> Option<()> {
        if self.flag_repeats == 0 {
            self.cur_flags = SimpleGlyphFlags::from_bits_truncate(self.flags.read().ok()?);
            self.flag_repeats = self
                .cur_flags
                .contains(SimpleGlyphFlags::REPEAT_FLAG)
                .then(|| self.flags.read::<u8>().ok())
                .flatten()
                .unwrap_or(0) as u16
                + 1;
        }
        self.flag_repeats -= 1;
        Some(())
    }

    fn advance_points(&mut self) {
        let x_short = self.cur_flags.contains(SimpleGlyphFlags::X_SHORT_VECTOR);
        let x_same_or_pos = self
            .cur_flags
            .contains(SimpleGlyphFlags::X_IS_SAME_OR_POSITIVE_X_SHORT_VECTOR);
        let y_short = self.cur_flags.contains(SimpleGlyphFlags::Y_SHORT_VECTOR);
        let y_same_or_pos = self
            .cur_flags
            .contains(SimpleGlyphFlags::Y_IS_SAME_OR_POSITIVE_Y_SHORT_VECTOR);

        let delta_x = match (x_short, x_same_or_pos) {
            (true, false) => -(self.x_coords.read::<u8>().unwrap_or(0) as i16),
            (true, true) => self.x_coords.read::<u8>().unwrap_or(0) as i16,
            (false, false) => self.x_coords.read::<i16>().unwrap_or(0),
            _ => 0,
        };

        let delta_y = match (y_short, y_same_or_pos) {
            (true, false) => -(self.y_coords.read::<u8>().unwrap_or(0) as i16),
            (true, true) => self.y_coords.read::<u8>().unwrap_or(0) as i16,
            (false, false) => self.y_coords.read::<i16>().unwrap_or(0),
            _ => 0,
        };

        self.cur_x = self.cur_x.wrapping_add(delta_x);
        self.cur_y = self.cur_y.wrapping_add(delta_y);
    }
}

//taken from ttf_parser https://docs.rs/ttf-parser/latest/src/ttf_parser/tables/glyf.rs.html#1-677
/// Resolves coordinate arrays length.
///
/// The length depends on *Simple Glyph Flags*, so we have to process them all to find it.
fn resolve_coords_len(data: &[u8], points_total: u16) -> Result<FieldLengths, ReadError> {
    let mut cursor = FontData::new(data).cursor();
    let mut flags_left = u32::from(points_total);
    //let mut repeats;
    let mut x_coords_len = 0;
    let mut y_coords_len = 0;
    //let mut flags_seen = 0;
    while flags_left > 0 {
        let flags: SimpleGlyphFlags = cursor.read()?;

        // The number of times a glyph point repeats.
        let repeats = if flags.contains(SimpleGlyphFlags::REPEAT_FLAG) {
            let repeats: u8 = cursor.read()?;
            u32::from(repeats) + 1
        } else {
            1
        };

        if repeats > flags_left {
            return Err(ReadError::MalformedData("repeat count too large in glyf"));
        }

        // Non-obfuscated code below.
        // Branchless version is surprisingly faster.
        //
        // if flags.x_short() {
        //     // Coordinate is 1 byte long.
        //     x_coords_len += repeats;
        // } else if !flags.x_is_same_or_positive_short() {
        //     // Coordinate is 2 bytes long.
        //     x_coords_len += repeats * 2;
        // }
        // if flags.y_short() {
        //     // Coordinate is 1 byte long.
        //     y_coords_len += repeats;
        // } else if !flags.y_is_same_or_positive_short() {
        //     // Coordinate is 2 bytes long.
        //     y_coords_len += repeats * 2;
        // }
        let x_short = SimpleGlyphFlags::X_SHORT_VECTOR;
        let x_long = SimpleGlyphFlags::X_SHORT_VECTOR
            | SimpleGlyphFlags::X_IS_SAME_OR_POSITIVE_X_SHORT_VECTOR;
        let y_short = SimpleGlyphFlags::Y_SHORT_VECTOR;
        let y_long = SimpleGlyphFlags::Y_SHORT_VECTOR
            | SimpleGlyphFlags::Y_IS_SAME_OR_POSITIVE_Y_SHORT_VECTOR;
        x_coords_len += ((flags & x_short).bits() != 0) as u32 * repeats;
        x_coords_len += ((flags & x_long).bits() == 0) as u32 * repeats * 2;

        y_coords_len += ((flags & y_short).bits() != 0) as u32 * repeats;
        y_coords_len += ((flags & y_long).bits() == 0) as u32 * repeats * 2;

        flags_left -= repeats;
    }

    Ok(FieldLengths {
        flags: cursor.position()? as u32,
        x_coords: x_coords_len,
        y_coords: y_coords_len,
    })
    //Some((flags_len, x_coords_len, y_coords_len))
}

struct FieldLengths {
    flags: u32,
    x_coords: u32,
    y_coords: u32,
}

/// Transform for a composite component.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Transform {
    /// X scale factor.
    pub xx: F2Dot14,
    /// YX skew factor.
    pub yx: F2Dot14,
    /// XY skew factor.
    pub xy: F2Dot14,
    /// Y scale factor.
    pub yy: F2Dot14,
}

impl Default for Transform {
    fn default() -> Self {
        Self {
            xx: F2Dot14::from_f32(1.0),
            yx: F2Dot14::from_f32(0.0),
            xy: F2Dot14::from_f32(0.0),
            yy: F2Dot14::from_f32(1.0),
        }
    }
}

/// A reference to another glyph. Part of [CompositeGlyph].
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Component {
    /// Component flags.
    pub flags: CompositeGlyphFlags,
    /// Glyph identifier.
    pub glyph: GlyphId,
    /// Anchor for component placement.
    pub anchor: Anchor,
    /// Component transformation matrix.
    pub transform: Transform,
}

/// Anchor position for a composite component.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Anchor {
    Offset { x: i16, y: i16 },
    Point { base: u16, component: u16 },
}

impl<'a> CompositeGlyph<'a> {
    /// Returns an iterator over the components of the composite glyph.
    pub fn components(&self) -> impl Iterator<Item = Component> + 'a + Clone {
        ComponentIter {
            cur_flags: CompositeGlyphFlags::empty(),
            done: false,
            cursor: FontData::new(self.component_data()).cursor(),
        }
    }

    /// Returns an iterator that yields the glyph identifier and flags of each
    /// component in the composite glyph.
    pub fn component_glyphs_and_flags(
        &self,
    ) -> impl Iterator<Item = (GlyphId, CompositeGlyphFlags)> + 'a + Clone {
        ComponentGlyphIdFlagsIter {
            cur_flags: CompositeGlyphFlags::empty(),
            done: false,
            cursor: FontData::new(self.component_data()).cursor(),
        }
    }

    /// Returns the component count and TrueType interpreter instructions
    /// in a single pass.
    pub fn count_and_instructions(&self) -> (usize, Option<&'a [u8]>) {
        let mut iter = ComponentGlyphIdFlagsIter {
            cur_flags: CompositeGlyphFlags::empty(),
            done: false,
            cursor: FontData::new(self.component_data()).cursor(),
        };
        let mut count = 0;
        let mut has_instructions = false;
        for (_, flags) in iter.by_ref() {
            count += 1;
            // ISO OFF permits this flag on any component; instructions follow the last.
            has_instructions |= flags.contains(CompositeGlyphFlags::WE_HAVE_INSTRUCTIONS);
        }
        let instructions = if has_instructions {
            iter.cursor
                .read::<u16>()
                .ok()
                .map(|len| len as usize)
                .and_then(|len| iter.cursor.read_array(len).ok())
        } else {
            None
        };
        (count, instructions)
    }

    /// Returns the TrueType interpreter instructions.
    pub fn instructions(&self) -> Option<&'a [u8]> {
        self.count_and_instructions().1
    }
}

#[derive(Clone)]
struct ComponentIter<'a> {
    cur_flags: CompositeGlyphFlags,
    done: bool,
    cursor: Cursor<'a>,
}

fn read_component_glyph(cursor: &mut Cursor<'_>, flags: CompositeGlyphFlags) -> Option<GlyphId> {
    if flags.contains(CompositeGlyphFlags::GID_IS_24_BIT) {
        Some(GlyphId::new(cursor.read::<Uint24>().ok()?.to_u32()))
    } else {
        Some(cursor.read::<GlyphId16>().ok()?.into())
    }
}

impl Iterator for ComponentIter<'_> {
    type Item = Component;

    fn next(&mut self) -> Option<Self::Item> {
        if self.done {
            return None;
        }
        let flags: CompositeGlyphFlags = self.cursor.read().ok()?;
        self.cur_flags = flags;
        let glyph = read_component_glyph(&mut self.cursor, flags)?;
        let args_are_words = flags.contains(CompositeGlyphFlags::ARG_1_AND_2_ARE_WORDS);
        let args_are_xy_values = flags.contains(CompositeGlyphFlags::ARGS_ARE_XY_VALUES);
        let anchor = match (args_are_xy_values, args_are_words) {
            (true, true) => Anchor::Offset {
                x: self.cursor.read().ok()?,
                y: self.cursor.read().ok()?,
            },
            (true, false) => Anchor::Offset {
                x: self.cursor.read::<i8>().ok()? as _,
                y: self.cursor.read::<i8>().ok()? as _,
            },
            (false, true) => Anchor::Point {
                base: self.cursor.read().ok()?,
                component: self.cursor.read().ok()?,
            },
            (false, false) => Anchor::Point {
                base: self.cursor.read::<u8>().ok()? as _,
                component: self.cursor.read::<u8>().ok()? as _,
            },
        };
        let mut transform = Transform::default();
        if flags.contains(CompositeGlyphFlags::WE_HAVE_A_SCALE) {
            transform.xx = self.cursor.read().ok()?;
            transform.yy = transform.xx;
        } else if flags.contains(CompositeGlyphFlags::WE_HAVE_AN_X_AND_Y_SCALE) {
            transform.xx = self.cursor.read().ok()?;
            transform.yy = self.cursor.read().ok()?;
        } else if flags.contains(CompositeGlyphFlags::WE_HAVE_A_TWO_BY_TWO) {
            transform.xx = self.cursor.read().ok()?;
            transform.yx = self.cursor.read().ok()?;
            transform.xy = self.cursor.read().ok()?;
            transform.yy = self.cursor.read().ok()?;
        }
        self.done = !flags.contains(CompositeGlyphFlags::MORE_COMPONENTS);

        Some(Component {
            flags,
            glyph,
            anchor,
            transform,
        })
    }
}

/// Iterator that only returns glyph identifiers and flags for each component.
///
/// Significantly faster in cases where we're just processing the glyph
/// tree, counting components or accessing instructions.
#[derive(Clone)]
struct ComponentGlyphIdFlagsIter<'a> {
    cur_flags: CompositeGlyphFlags,
    done: bool,
    cursor: Cursor<'a>,
}

impl Iterator for ComponentGlyphIdFlagsIter<'_> {
    type Item = (GlyphId, CompositeGlyphFlags);

    fn next(&mut self) -> Option<Self::Item> {
        if self.done {
            return None;
        }
        let flags: CompositeGlyphFlags = self.cursor.read().ok()?;
        self.cur_flags = flags;
        let glyph = read_component_glyph(&mut self.cursor, flags)?;
        let args_are_words = flags.contains(CompositeGlyphFlags::ARG_1_AND_2_ARE_WORDS);
        if args_are_words {
            self.cursor.advance_by(4);
        } else {
            self.cursor.advance_by(2);
        }
        if flags.contains(CompositeGlyphFlags::WE_HAVE_A_SCALE) {
            self.cursor.advance_by(2);
        } else if flags.contains(CompositeGlyphFlags::WE_HAVE_AN_X_AND_Y_SCALE) {
            self.cursor.advance_by(4);
        } else if flags.contains(CompositeGlyphFlags::WE_HAVE_A_TWO_BY_TWO) {
            self.cursor.advance_by(8);
        }
        self.done = !flags.contains(CompositeGlyphFlags::MORE_COMPONENTS);
        Some((glyph, flags))
    }
}

impl Anchor {
    /// Compute the flags that describe this anchor
    pub fn compute_flags(&self) -> CompositeGlyphFlags {
        const I8_RANGE: Range<i16> = i8::MIN as i16..i8::MAX as i16 + 1;
        const U8_MAX: u16 = u8::MAX as u16;

        let mut flags = CompositeGlyphFlags::empty();
        match self {
            Anchor::Offset { x, y } => {
                flags |= CompositeGlyphFlags::ARGS_ARE_XY_VALUES;
                if !I8_RANGE.contains(x) || !I8_RANGE.contains(y) {
                    flags |= CompositeGlyphFlags::ARG_1_AND_2_ARE_WORDS;
                }
            }
            Anchor::Point { base, component } => {
                if base > &U8_MAX || component > &U8_MAX {
                    flags |= CompositeGlyphFlags::ARG_1_AND_2_ARE_WORDS;
                }
            }
        }
        flags
    }
}

impl Transform {
    /// Compute the flags that describe this transform
    pub fn compute_flags(&self) -> CompositeGlyphFlags {
        if self.yx != F2Dot14::ZERO || self.xy != F2Dot14::ZERO {
            CompositeGlyphFlags::WE_HAVE_A_TWO_BY_TWO
        } else if self.xx != self.yy {
            CompositeGlyphFlags::WE_HAVE_AN_X_AND_Y_SCALE
        } else if self.xx != F2Dot14::ONE {
            CompositeGlyphFlags::WE_HAVE_A_SCALE
        } else {
            CompositeGlyphFlags::empty()
        }
    }
}

impl PointCoord for F26Dot6 {
    fn from_fixed(x: Fixed) -> Self {
        x.to_f26dot6()
    }

    #[inline]
    fn from_i32(x: i32) -> Self {
        Self::from_i32(x)
    }

    #[inline]
    fn to_f32(self) -> f32 {
        self.to_f32()
    }

    #[inline]
    fn midpoint(self, other: Self) -> Self {
        // FreeType uses integer division on 26.6 to compute midpoints.
        // See: https://github.com/freetype/freetype/blob/de8b92dd7ec634e9e2b25ef534c54a3537555c11/src/base/ftoutln.c#L123
        Self::from_bits(midpoint_i32(self.to_bits(), other.to_bits()))
    }
}

impl PointCoord for Fixed {
    fn from_fixed(x: Fixed) -> Self {
        x
    }

    fn from_i32(x: i32) -> Self {
        Self::from_i32(x)
    }

    fn to_f32(self) -> f32 {
        self.to_f32()
    }

    fn midpoint(self, other: Self) -> Self {
        Self::from_bits(midpoint_i32(self.to_bits(), other.to_bits()))
    }
}

impl PointCoord for i32 {
    fn from_fixed(x: Fixed) -> Self {
        x.to_i32()
    }

    fn from_i32(x: i32) -> Self {
        x
    }

    fn to_f32(self) -> f32 {
        self as f32
    }

    fn midpoint(self, other: Self) -> Self {
        midpoint_i32(self, other)
    }
}

// Midpoint function that avoids overflow on large values.
#[inline(always)]
fn midpoint_i32(a: i32, b: i32) -> i32 {
    // Original overflowing code was: (a + b) / 2
    // Choose wrapping arithmetic here because we shouldn't ever
    // hit this outside of fuzzing or broken fonts _and_ this is
    // called from the outline to path conversion code which is
    // very performance sensitive
    a.wrapping_add(b) / 2
}

impl PointCoord for f32 {
    fn from_fixed(x: Fixed) -> Self {
        x.to_f32()
    }

    fn from_i32(x: i32) -> Self {
        x as f32
    }

    fn to_f32(self) -> f32 {
        self
    }

    fn midpoint(self, other: Self) -> Self {
        // HarfBuzz uses a lerp here so we copy the style to
        // preserve compatibility
        self + 0.5 * (other - self)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{FontRef, GlyphId, TableProvider};

    #[test]
    fn simple_glyph() {
        let font = FontRef::new(font_test_data::COLR_GRADIENT_RECT).unwrap();
        let loca = font.loca(None).unwrap();
        let glyf = font.glyf().unwrap();
        let glyph = loca
            .get(GlyphId::new(0), &glyf)
            .and_then(|g| g.into_glyph())
            .unwrap();
        assert_eq!(glyph.number_of_contours(), 2);
        let simple_glyph = if let Glyph::Simple(simple) = glyph {
            simple
        } else {
            panic!("expected simple glyph");
        };
        assert_eq!(
            simple_glyph
                .end_pts_of_contours()
                .iter()
                .map(|x| x.get())
                .collect::<Vec<_>>(),
            &[3, 7]
        );
        assert_eq!(
            simple_glyph
                .points()
                .map(|pt| (pt.x, pt.y, pt.on_curve))
                .collect::<Vec<_>>(),
            &[
                (5, 0, true),
                (5, 100, true),
                (45, 100, true),
                (45, 0, true),
                (10, 5, true),
                (40, 5, true),
                (40, 95, true),
                (10, 95, true),
            ]
        );
    }

    // Test helper to enumerate all TrueType glyphs in the given font
    fn all_glyphs(font_data: &[u8]) -> impl Iterator<Item = Option<Glyph<'_>>> {
        let font = FontRef::new(font_data).unwrap();
        let loca = font.loca(None).unwrap();
        let glyf = font.glyf().unwrap();
        let glyph_count = font.maxp().unwrap().num_glyphs() as u32;
        (0..glyph_count).map(move |gid| {
            loca.get(GlyphId::new(gid), &glyf)
                .and_then(|g| g.into_glyph())
        })
    }

    #[test]
    fn simple_glyph_overlapping_contour_flag() {
        let gids_with_overlap: Vec<_> = all_glyphs(font_test_data::VAZIRMATN_VAR)
            .enumerate()
            .filter_map(|(gid, glyph)| match glyph {
                Some(Glyph::Simple(glyph)) if glyph.has_overlapping_contours() => Some(gid),
                _ => None,
            })
            .collect();
        // Only GID 3 has the overlap bit set
        let expected_gids_with_overlap = vec![3];
        assert_eq!(expected_gids_with_overlap, gids_with_overlap);
    }

    #[test]
    fn composite_glyph_overlapping_contour_flag() {
        let gids_components_with_overlap: Vec<_> = all_glyphs(font_test_data::VAZIRMATN_VAR)
            .enumerate()
            .filter_map(|(gid, glyph)| match glyph {
                Some(Glyph::Composite(glyph)) => Some((gid, glyph)),
                _ => None,
            })
            .flat_map(|(gid, glyph)| {
                glyph
                    .components()
                    .enumerate()
                    .filter_map(move |(comp_ix, comp)| {
                        comp.flags
                            .contains(CompositeGlyphFlags::OVERLAP_COMPOUND)
                            .then_some((gid, comp_ix))
                    })
            })
            .collect();
        // Only GID 2, component 1 has the overlap bit set
        let expected_gids_components_with_overlap = vec![(2, 1)];
        assert_eq!(
            expected_gids_components_with_overlap,
            gids_components_with_overlap
        );
    }

    #[test]
    fn composite_instructions_flag_on_any_component() {
        use font_test_data::bebuffer::BeBuffer;

        let instructions = [0x40_u8, 0x01, 0x2A];
        for wide_first in [false, true] {
            for (first_flag, last_flag) in
                [(true, false), (false, true), (true, true), (false, false)]
            {
                let mut first_flags =
                    CompositeGlyphFlags::ARGS_ARE_XY_VALUES | CompositeGlyphFlags::MORE_COMPONENTS;
                let mut last_flags = CompositeGlyphFlags::ARGS_ARE_XY_VALUES;
                if wide_first {
                    first_flags |= CompositeGlyphFlags::GID_IS_24_BIT;
                }
                if first_flag {
                    first_flags |= CompositeGlyphFlags::WE_HAVE_INSTRUCTIONS;
                }
                if last_flag {
                    last_flags |= CompositeGlyphFlags::WE_HAVE_INSTRUCTIONS;
                }
                let mut buf = BeBuffer::new()
                    .push(-1_i16)
                    .extend([0_i16; 4])
                    .push(first_flags.bits());
                buf = if wide_first {
                    buf.push(Uint24::new(65536))
                } else {
                    buf.push(1_u16)
                };
                buf = buf
                    .extend([0_i8; 2])
                    .push(last_flags.bits())
                    .push(2_u16)
                    .extend([0_i8; 2]);
                let expected = (first_flag || last_flag).then_some(instructions.as_slice());
                if expected.is_some() {
                    buf = buf.push(instructions.len() as u16).extend(instructions);
                }
                let glyph = CompositeGlyph::read(buf.data().into()).unwrap();
                assert_eq!(glyph.components().count(), 2);
                assert_eq!(glyph.count_and_instructions(), (2, expected));
                assert_eq!(glyph.instructions(), expected);
            }
        }
    }

    #[test]
    fn compute_anchor_flags() {
        let anchor = Anchor::Offset { x: -128, y: 127 };
        assert_eq!(
            anchor.compute_flags(),
            CompositeGlyphFlags::ARGS_ARE_XY_VALUES
        );

        let anchor = Anchor::Offset { x: -129, y: 127 };
        assert_eq!(
            anchor.compute_flags(),
            CompositeGlyphFlags::ARGS_ARE_XY_VALUES | CompositeGlyphFlags::ARG_1_AND_2_ARE_WORDS
        );
        let anchor = Anchor::Offset { x: -1, y: 128 };
        assert_eq!(
            anchor.compute_flags(),
            CompositeGlyphFlags::ARGS_ARE_XY_VALUES | CompositeGlyphFlags::ARG_1_AND_2_ARE_WORDS
        );

        let anchor = Anchor::Point {
            base: 255,
            component: 20,
        };
        assert_eq!(anchor.compute_flags(), CompositeGlyphFlags::empty());

        let anchor = Anchor::Point {
            base: 256,
            component: 20,
        };
        assert_eq!(
            anchor.compute_flags(),
            CompositeGlyphFlags::ARG_1_AND_2_ARE_WORDS
        )
    }

    #[test]
    fn compute_transform_flags() {
        fn make_xform(xx: f32, yx: f32, xy: f32, yy: f32) -> Transform {
            Transform {
                xx: F2Dot14::from_f32(xx),
                yx: F2Dot14::from_f32(yx),
                xy: F2Dot14::from_f32(xy),
                yy: F2Dot14::from_f32(yy),
            }
        }

        assert_eq!(
            make_xform(1.0, 0., 0., 1.0).compute_flags(),
            CompositeGlyphFlags::empty()
        );
        assert_eq!(
            make_xform(2.0, 0., 0., 2.0).compute_flags(),
            CompositeGlyphFlags::WE_HAVE_A_SCALE
        );
        assert_eq!(
            make_xform(2.0, 0., 0., 1.0).compute_flags(),
            CompositeGlyphFlags::WE_HAVE_AN_X_AND_Y_SCALE
        );
        assert_eq!(
            make_xform(2.0, 0., 1.0, 1.0).compute_flags(),
            CompositeGlyphFlags::WE_HAVE_A_TWO_BY_TWO
        );
    }

    #[test]
    fn point_flags_and_marker_bits() {
        let bits = [
            PointFlags::OFF_CURVE_CUBIC,
            PointFlags::ON_CURVE,
            PointMarker::HAS_DELTA.0,
            PointMarker::TOUCHED_X.0,
            PointMarker::TOUCHED_Y.0,
        ];
        // Ensure bits don't overlap
        for (i, a) in bits.iter().enumerate() {
            for b in &bits[i + 1..] {
                assert_eq!(a & b, 0);
            }
        }
    }

    #[test]
    fn cubic_glyf() {
        let font = FontRef::new(font_test_data::CUBIC_GLYF).unwrap();
        let loca = font.loca(None).unwrap();
        let glyf = font.glyf().unwrap();
        let glyph = loca
            .get(GlyphId::new(2), &glyf)
            .and_then(|g| g.into_glyph())
            .unwrap();
        assert_eq!(glyph.number_of_contours(), 1);
        let simple_glyph = if let Glyph::Simple(simple) = glyph {
            simple
        } else {
            panic!("expected simple glyph");
        };
        assert_eq!(
            simple_glyph
                .points()
                .map(|pt| (pt.x, pt.y, pt.on_curve))
                .collect::<Vec<_>>(),
            &[
                (278, 710, true),
                (278, 470, true),
                (300, 500, false),
                (800, 500, false),
                (998, 470, true),
                (998, 710, true),
            ]
        );
    }

    // Minimized test case from https://issues.oss-fuzz.com/issues/382732980
    // Add with overflow when computing midpoint of 1084092352 and 1085243712
    // during outline -> path conversion
    #[test]
    fn avoid_midpoint_overflow() {
        let a = F26Dot6::from_bits(1084092352);
        let b = F26Dot6::from_bits(1085243712);
        let expected = (a + b).to_bits() / 2;
        // Don't panic!
        let midpoint = a.midpoint(b);
        assert_eq!(midpoint.to_bits(), expected);
    }

    // SimpleGlyph should not panic on truncated data.
    //
    // SimpleGlyph has a variable-length array (end_pts_of_contours) followed
    // by a scalar field (instruction_length). The MIN_SIZE validation only
    // checks that the fixed-size fields fit, but doesn't account for the
    // array's runtime length. This causes a panic when accessing fields
    // that come after the array if the data is truncated.
    #[test]
    fn simple_glyph_truncated_data() {
        use font_test_data::bebuffer::BeBuffer;

        // Build a SimpleGlyph with number_of_contours = 100
        // This means end_pts_of_contours should be 200 bytes,
        // pushing instruction_length to offset 210.
        // But we only provide 12 bytes (MIN_SIZE).
        let buf = BeBuffer::new()
            .push(100_i16) // number_of_contours = 100
            .push(0_i16) // x_min
            .push(0_i16) // y_min
            .push(0_i16) // x_max
            .push(0_i16) // y_max
            .push(0_u16); // would be first element of end_pts_of_contours

        // Parsing succeeds - we have MIN_SIZE (12) bytes
        let glyph = SimpleGlyph::read(buf.data().into()).unwrap();
        assert_eq!(glyph.number_of_contours(), 100);

        // return default value instead of panicking
        assert_eq!(glyph.instruction_length(), 0);
    }

    // The flags run can encode up to two bytes per point (a flag plus a repeat
    // count). read_points_fast must agree with the points() iterator even when
    // the flags section is longer than the point count.
    #[test]
    fn read_points_fast_long_flags() {
        use font_test_data::bebuffer::BeBuffer;
        // 1 contour, 3 points. Each point is its own REPEAT_FLAG entry with a
        // repeat count of 0, so the flags section is 6 bytes for 3 points and
        // there are no coordinate bytes. flag 0x39 = ON_CURVE | REPEAT_FLAG |
        // X_IS_SAME_OR_POSITIVE | Y_IS_SAME_OR_POSITIVE.
        let buf = BeBuffer::new()
            .push(1_i16) // number_of_contours
            .extend([0_i16; 4]) // bounding box
            .push(2_u16) // end_pts_of_contours[0] => 3 points
            .push(0_u16) // instruction_length
            .extend([0x39u8, 0x00, 0x39, 0x00, 0x39, 0x00]);

        let glyph = SimpleGlyph::read(buf.data().into()).unwrap();
        assert_eq!(glyph.num_points(), 3);

        let expected: Vec<_> = glyph.points().map(|p| (p.x as i32, p.y as i32)).collect();

        let mut points = vec![Point::default(); 3];
        let mut flags = vec![PointFlags::default(); 3];
        glyph
            .read_points_fast::<i32>(&mut points, &mut flags)
            .unwrap();
        let actual: Vec<_> = points.iter().map(|p| (p.x, p.y)).collect();

        assert_eq!(actual, expected);
    }

    #[test]
    fn point_iter_repeat_count_255_does_not_overflow() {
        // repeat byte 0xFF means the same flag applies to 256 points total
        let flags = [SimpleGlyphFlags::REPEAT_FLAG.bits(), 0xFF];
        // 256 coords of 2 bytes each
        let coords = [0u8; 256 * 2];
        let iter = PointIter::new(&flags, &coords, &coords);
        assert_eq!(iter.count(), 256);
    }

    #[test]
    fn read_points_fast_does_not_panic_on_empty_glyph_with_padding() {
        let glyph_bytes: &[u8] = &[
            0x00, 0x00, // numberOfContours = 0
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // bbox
            0x00, 0x00, // instructionLength = 0
            0x00, // trailing pad byte
        ];
        let glyph = SimpleGlyph::read(FontData::new(glyph_bytes)).expect("parses");
        assert_eq!(glyph.num_points(), 0);
        let mut points: Vec<Point<f32>> = vec![];
        let mut flags: Vec<PointFlags> = vec![];
        assert!(glyph.read_points_fast(&mut points, &mut flags).is_ok());
    }
}