glyf.rs

use crate::error::Error;
use crate::opentype::{read_i16, read_u8, read_u16, read_u32};
use crate::outline::{Outline, Segment};


#[derive(Debug, Clone, Copy)]
pub struct Glyf {
    glyf_at: usize,
    loca_at: usize,
    long_loca: bool,
    count: usize,
}


const NEST_LIMIT: usize = 5;

const ARG_WORD: u16 = 0x0001;
const ARG_XY: u16 = 0x0002;
const HAS_SCALE: u16 = 0x0008;
const MORE: u16 = 0x0020;
const HAS_XY_SCALE: u16 = 0x0040;
const HAS_MATRIX: u16 = 0x0080;

const ON_CURVE: u8 = 0x01;
const X_SHORT: u8 = 0x02;
const Y_SHORT: u8 = 0x04;
const REPEAT: u8 = 0x08;
const X_SAME: u8 = 0x10;
const Y_SAME: u8 = 0x20;


pub fn new(glyf_at: usize, loca_at: usize, long_loca: bool, count: usize) -> Glyf {
    Glyf {glyf_at, loca_at, long_loca, count}
}


fn range(data: &[u8], glyf: &Glyf, glyph: u16) -> Result<Option<(usize, usize)>, Error> {
    let index = glyph as usize;

    if index >= glyf.count {
        return Ok(None);
    }

    let (start, end) = if glyf.long_loca {
        (
            read_u32(data, glyf.loca_at + index * 4)? as usize,
            read_u32(data, glyf.loca_at + index * 4 + 4)? as usize,
        )
    } else {
        (
            read_u16(data, glyf.loca_at + index * 2)? as usize * 2,
            read_u16(data, glyf.loca_at + index * 2 + 2)? as usize * 2,
        )
    };

    if end <= start {
        return Ok(None);
    }

    Ok(Some((glyf.glyf_at + start, glyf.glyf_at + end)))
}


pub fn outline(data: &[u8], glyf: &Glyf, glyph: u16) -> Result<Outline, Error> {
    let mut found = Outline::default();
    read_into(data, glyf, glyph, 0.0, 0.0, &mut found, 0)?;

    Ok(found)
}


fn read_into(
    data: &[u8],
    glyf: &Glyf,
    glyph: u16,
    shift_x: f64,
    shift_y: f64,
    found: &mut Outline,
    depth: usize,
) -> Result<(), Error> {
    if depth > NEST_LIMIT {
        return Err(Error::font("composite glyphs nest too deeply", 0));
    }

    let (start, end) = match range(data, glyf, glyph)? {
        Some(found) => found,
        None => return Ok(()),
    };
    let contours = read_i16(data, start)?;

    if contours >= 0 {
        return simple(data, start, contours as usize, shift_x, shift_y, found);
    }

    composite(data, glyf, start, end, shift_x, shift_y, found, depth)
}


fn simple(
    data: &[u8],
    start: usize,
    contours: usize,
    shift_x: f64,
    shift_y: f64,
    found: &mut Outline,
) -> Result<(), Error> {
    if contours == 0 {
        return Ok(());
    }

    let ends_at = start + 10;
    let point_count = read_u16(data, ends_at + (contours - 1) * 2)? as usize + 1;
    let instruction_at = ends_at + contours * 2;
    let mut at = instruction_at + 2 + read_u16(data, instruction_at)? as usize;

    let mut flags = Vec::with_capacity(point_count);

    while flags.len() < point_count {
        let flag = read_u8(data, at)?;
        at += 1;
        flags.push(flag);

        if flag & REPEAT != 0 {
            let times = read_u8(data, at)?;
            at += 1;

            for _ in 0..times {
                if flags.len() >= point_count {
                    break;
                }

                flags.push(flag);
            }
        }
    }

    let mut x = Vec::with_capacity(point_count);
    let mut value = 0i32;

    for flag in &flags {
        if flag & X_SHORT != 0 {
            let step = read_u8(data, at)? as i32;
            at += 1;
            value += if flag & X_SAME != 0 {step} else {-step};

        } else if flag & X_SAME == 0 {
            value += read_i16(data, at)? as i32;
            at += 2;
        }

        x.push(value as f64 + shift_x);
    }

    let mut y = Vec::with_capacity(point_count);
    value = 0;

    for flag in &flags {
        if flag & Y_SHORT != 0 {
            let step = read_u8(data, at)? as i32;
            at += 1;
            value += if flag & Y_SAME != 0 {step} else {-step};

        } else if flag & Y_SAME == 0 {
            value += read_i16(data, at)? as i32;
            at += 2;
        }

        y.push(value as f64 + shift_y);
    }

    let mut first = 0usize;

    for index in 0..contours {
        let last = read_u16(data, ends_at + index * 2)? as usize;

        if last >= point_count || last < first {
            return Err(Error::font("contour end point out of range", ends_at));
        }

        write_contour(&flags[first..=last], &x[first..=last], &y[first..=last], found);
        first = last + 1;
    }

    Ok(())
}


fn write_contour(flags: &[u8], x: &[f64], y: &[f64], found: &mut Outline) {
    let count = flags.len();

    if count == 0 {
        return;
    }

    let on = |index: usize| flags[index % count] & ON_CURVE != 0;
    let point = |index: usize| (x[index % count], y[index % count]);
    let middle = |first: (f64, f64), second: (f64, f64)| {
        ((first.0 + second.0) / 2.0, (first.1 + second.1) / 2.0)
    };

    let start_index = (0..count).find(|index| on(*index));
    let start = match start_index {
        Some(index) => point(index),
        None => middle(point(0), point(1)),
    };
    let begin = start_index.map_or(1, |index| index + 1);

    found.segment.push(Segment::Move {x: start.0, y: start.1});

    let mut control: Option<(f64, f64)> = None;

    for step in 0..count {
        let index = begin + step;
        let here = point(index);

        if on(index) {
            match control.take() {
                Some(hold) => found.segment.push(Segment::Quadratic {
                    x1: hold.0,
                    y1: hold.1,
                    x: here.0,
                    y: here.1,
                }),
                None => found.segment.push(Segment::Line {x: here.0, y: here.1}),
            }

            continue;
        }

        if let Some(hold) = control {
            let between = middle(hold, here);
            found.segment.push(Segment::Quadratic {
                x1: hold.0,
                y1: hold.1,
                x: between.0,
                y: between.1,
            });
        }

        control = Some(here);
    }

    if let Some(hold) = control {
        found.segment.push(Segment::Quadratic {
            x1: hold.0,
            y1: hold.1,
            x: start.0,
            y: start.1,
        });
    }

    found.segment.push(Segment::Close);
}


#[allow(clippy::too_many_arguments)]
fn composite(
    data: &[u8],
    glyf: &Glyf,
    start: usize,
    end: usize,
    shift_x: f64,
    shift_y: f64,
    found: &mut Outline,
    depth: usize,
) -> Result<(), Error> {
    let mut at = start + 10;

    loop {
        if at + 4 > end {
            return Ok(());
        }

        let flags = read_u16(data, at)?;
        let glyph = read_u16(data, at + 2)?;
        at += 4;

        let (dx, dy) = if flags & ARG_WORD != 0 {
            let first = read_i16(data, at)? as f64;
            let second = read_i16(data, at + 2)? as f64;
            at += 4;
            (first, second)
        } else {
            let first = read_u8(data, at)? as i8 as f64;
            let second = read_u8(data, at + 1)? as i8 as f64;
            at += 2;
            (first, second)
        };

        // Only the offset is used; scale and rotation are skipped
        if flags & HAS_SCALE != 0 {
            at += 2;
        } else if flags & HAS_XY_SCALE != 0 {
            at += 4;
        } else if flags & HAS_MATRIX != 0 {
            at += 8;
        }

        let (move_x, move_y) = if flags & ARG_XY != 0 {(dx, dy)} else {(0.0, 0.0)};
        read_into(data, glyf, glyph, shift_x + move_x, shift_y + move_y, found, depth + 1)?;

        if flags & MORE == 0 {
            return Ok(());
        }
    }
}


#[cfg(test)]
mod tests {
    use super::*;
    use crate::opentype::{character_map, glyph_count, head, require};
    use crate::outline::bounds;

    fn font() -> Option<(Vec<u8>, Glyf, f64)> {
        let path = "/System/Library/Fonts/Supplemental/Times New Roman.ttf";
        let data = std::fs::read(path).ok()?;
        let (head_at, _) = require(&data, "head").unwrap();
        let shape = head(&data, head_at).unwrap();
        let (maxp_at, _) = require(&data, "maxp").unwrap();
        let count = glyph_count(&data, maxp_at).unwrap();
        let (glyf_at, _) = require(&data, "glyf").unwrap();
        let (loca_at, _) = require(&data, "loca").unwrap();

        Some((data, new(glyf_at, loca_at, shape.long_loca, count), shape.units_per_em))
    }

    #[test]
    fn reads_a_letter_from_a_truetype_font() {
        let Some((data, glyf, units)) = font() else {
            return;
        };
        let (cmap_at, _) = require(&data, "cmap").unwrap();
        let map = character_map(&data, cmap_at).unwrap();
        let (_, bottom, _, top) = bounds(&outline(&data, &glyf, map[&'x']).unwrap());
        assert!(bottom.abs() < 0.03 * units);
        assert!(top > 0.3 * units && top < 0.6 * units, "height of x: {top}");
    }

    #[test]
    fn a_descender_reaches_below_the_baseline() {
        let Some((data, glyf, units)) = font() else {
            return;
        };
        let (cmap_at, _) = require(&data, "cmap").unwrap();
        let map = character_map(&data, cmap_at).unwrap();
        let (_, bottom, _, _) = bounds(&outline(&data, &glyf, map[&'y']).unwrap());
        assert!(bottom < -0.1 * units, "depth of y: {bottom}");
    }

    #[test]
    fn every_glyph_can_be_read() {
        let Some((data, glyf, _)) = font() else {
            return;
        };

        for glyph in 0..glyf.count {
            let result = outline(&data, &glyf, glyph as u16);
            assert!(result.is_ok(), "cannot read glyph {glyph}: {:?}", result.err());
        }
    }

    #[test]
    fn a_contour_with_no_point_on_the_curve() {
        let flags = [0u8; 4];
        let x = [100.0, 0.0, -100.0, 0.0];
        let y = [0.0, 100.0, 0.0, -100.0];
        let mut found = Outline::default();
        write_contour(&flags, &x, &y, &mut found);
        assert_eq!(found.segment, vec![
            Segment::Move {x: 50.0, y: 50.0},
            Segment::Quadratic {x1: 0.0, y1: 100.0, x: -50.0, y: 50.0},
            Segment::Quadratic {x1: -100.0, y1: 0.0, x: -50.0, y: -50.0},
            Segment::Quadratic {x1: 0.0, y1: -100.0, x: 50.0, y: -50.0},
            Segment::Quadratic {x1: 100.0, y1: 0.0, x: 50.0, y: 50.0},
            Segment::Close,
        ]);
    }
}