begin glyph processing

Cargo.lock

@@ -60,6 +60,26 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "bitfield"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "786e53b0c071573a28956cec19a92653e42de34c683e2f6e86c197a349fba318"
+dependencies = [
+ "bitfield-macros",
+]
+
+[[package]]
+name = "bitfield-macros"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07805405d3f1f3a55aab895718b488821d40458f9188059909091ae0935c344a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "clap"
 version = "4.5.21"
@@ -120,6 +140,7 @@ name = "font-explorer"
 version = "0.1.0"
 dependencies = [
  "bincode",
+ "bitfield",
  "clap",
  "log",
  "serde",
@@ -179,18 +200,18 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.89"
+version = "1.0.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
+checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.37"
+version = "1.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
 dependencies = [
  "proc-macro2",
 ]
@@ -234,9 +255,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.87"
+version = "2.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d"
+checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 bincode = "1.3.3"
+bitfield = "0.19.0"
 clap = { version = "4.5.21", features = ["derive"] }
 log = "0.4.26"
 serde = { version = "1.0.215", features = ["derive", "serde_derive"] }

src/font.rs

@@ -3,13 +3,15 @@ mod character_map;
 mod maximum_profile;
 mod font_header;
 mod index_to_location;
+mod glyph_data;
 mod search;
 
-use std::{fs::File, io::{BufReader, Read}};
+use std::{error::Error, fs::File, io::{BufReader, Read}};
 
 use bincode::Options;
 use character_map::CharacterMap;
 use font_header::FontHeader;
+use glyph_data::GlyphTable;
 use index_to_location::{IndexToLocation, IndexToLocationArgs};
 use log::{debug, info};
 use maximum_profile::MaximumProfile;
@@ -19,13 +21,28 @@ fn deserialize<R: Read, T: serde::de::DeserializeOwned>(reader: R) -> bincode::R
 	bincode::options().with_big_endian().with_fixint_encoding().deserialize_from::<R, T>(reader)
 }
 
+fn deserialize_vec<R: Read, T: serde::de::DeserializeOwned>(reader: &mut R, entries: usize) -> bincode::Result<Vec<T>> {
+	if entries == 0 {
+		return Ok(vec![]);
+	}
+
+	let mut data: Vec<T> = Vec::with_capacity(entries);
+
+	for _ in 0..entries {
+		data.push(deserialize::<_, T>(reader.by_ref())?);
+	}
+
+	Ok(data)
+}
+
 #[derive(Debug)]
 pub struct Font {
 	table_directory: TableDirectory,
 	font_header: FontHeader,
 	character_map: CharacterMap,
 	maximum_profile: MaximumProfile,
-	index_to_location: IndexToLocation
+	index_to_location: IndexToLocation,
+	glyph_table: GlyphTable
 }
 	
 impl Font {
@@ -47,27 +64,26 @@ impl Font {
 			num_glyphs: maximum_profile.num_glyphs()
 		}))?;
 
+		let glyph_table = table_directory.get_table(&file)?;
+
 		Ok(Font {
 			table_directory,
 			font_header,
 			character_map,
 			maximum_profile,
-			index_to_location
+			index_to_location,
+			glyph_table
 		})
 	}
 
-	pub fn get_data_for(&mut self, glyph: char) -> Result<(), &'static str> {
+	pub fn get_data_for(&mut self, glyph: char) -> Result<(), Box<dyn Error>> {
 		let Some(glyph_id) = self.character_map.get_char(glyph) else {
-			return Err("Failed to get glyph id for char");
+			return Err("Failed to get glyph id for char".into());
 		};
 
 		info!("glyph id for char '{glyph}' is {glyph_id}");
 
-		let Some(offset) = self.index_to_location.get_offset(glyph_id) else {
+		let glyph = self.glyph_table.get_glyph(glyph_id, &mut self.index_to_location)?;
-			return Err("Failed to get glyph offset for char");
-		};
-
-		info!("glyph has offset {offset}");
 
 		Ok(())
 	}

src/font/glyph_data.rs

@@ -0,0 +1,225 @@
+use std::{collections::HashMap, fs::File, io::{BufReader, Read, Seek, SeekFrom}, iter::zip};
+
+use bincode::{ErrorKind, Result};
+use bitfield::bitfield;
+use log::{debug, info};
+use serde::Deserialize;
+
+use super::{deserialize, deserialize_vec, index_to_location::IndexToLocation, table_directory::{FontTable, TableDirectoryRecord}};
+
+
+#[derive(Debug, Deserialize)]
+pub struct GlyphHeader {
+	num_countours: i16,
+
+	xmin: i16,
+	ymin: i16,
+	xmax: i16,
+	ymax: i16
+}
+
+bitfield! {
+	#[derive(Copy, Clone, Deserialize)]
+	struct GlyphFlagData(u8);
+	impl Debug;
+	on_curve, _: 0;
+	x_short, _: 1;
+	y_short, _: 2;
+	repeat, _: 3;
+	x_same_or_positive, _: 4;
+	y_same_or_positive, _: 5;
+	overlap_simple, _: 6;
+	reserved, _: 7;
+}
+
+#[derive(Debug)]
+struct GlyphFlag {
+	flags: GlyphFlagData,
+	repeat: u8
+}
+
+#[derive(Debug)]
+struct GlyphFlags<'a> {
+	flags: &'a Vec<GlyphFlag>,
+	current_item: usize,
+	repetitions: u16
+}
+
+impl<'a> GlyphFlags<'a> {
+	fn new(flags: &'a Vec<GlyphFlag>) -> GlyphFlags<'a> {
+		GlyphFlags { flags, current_item: 0, repetitions: 0 }
+	}
+}
+
+impl<'a> Iterator for GlyphFlags<'a> {
+	type Item = GlyphFlagData;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		if self.current_item >= self.flags.len() {
+			return None;
+		}
+
+		let current = &self.flags[self.current_item];
+
+		if self.repetitions < current.repeat as u16 {
+			self.repetitions += 1;
+			return Some(current.flags);
+		}
+
+		self.current_item += 1;
+		if self.current_item >= self.flags.len() {
+			return None;
+		}
+
+		let current = &self.flags[self.current_item];
+		self.repetitions = 0;
+
+		Some(current.flags)
+		
+	}
+}
+
+#[derive(Debug)]
+pub struct GlyphPoint {
+	x: i32,
+	y: i32,
+
+	on_curve: bool
+}
+
+#[derive(Debug)]
+pub struct SimpleGlyph {
+	header: GlyphHeader,
+	instructions: Vec<u8>,
+
+	points: Vec<GlyphPoint>
+}
+
+impl SimpleGlyph {
+	fn read_flags<R: Read + Seek>(reader: &mut R, num_points: usize) -> Result<Vec<GlyphFlag>> {
+		debug!("reading flags from position {}", reader.stream_position()?);
+		let mut flags: Vec<GlyphFlag> = vec![];
+
+		let mut points_processed: usize = 0;
+		while points_processed < num_points {
+			let flag: GlyphFlagData = deserialize(reader.by_ref())?;
+
+			let repetitions: u8 = if flag.repeat() { deserialize(reader.by_ref())? } else { 0 };
+			flags.push(GlyphFlag {
+				flags: flag,
+				repeat: repetitions
+			});
+
+			points_processed += repetitions as usize + 1;
+			debug!("Flag: {flag:#?}, repeated {repetitions} times, logical elements processed: {points_processed}")
+		}
+
+		// debug!("glyph flags: {flags:#?}");
+		Ok(flags)
+	}
+
+	fn read_coordinates<R: Read + Seek>(reader: &mut R, flags: GlyphFlags, is_y: bool) -> Result<Vec<(i32, bool)>> {
+		let mut coordinates: Vec<(i32, bool)> = vec![];
+		let mut current_coordinate = 0i32;
+
+		for flag in flags {
+			let short_vec = if is_y { flag.y_short() } else { flag.x_short() };
+			let same_or_positive = if is_y { flag.y_same_or_positive() } else { flag.x_same_or_positive() };
+
+			if short_vec {
+				let sign: i32 = if same_or_positive { 1 } else { -1 };
+				let delta = sign * (deserialize::<_, u8>(reader.by_ref())? as i32);
+
+				current_coordinate += delta;
+				coordinates.push((current_coordinate, flag.on_curve()));
+			} else {
+				if same_or_positive {
+					coordinates.push((current_coordinate, flag.on_curve()));
+				} else {
+					let delta: i16 = deserialize(reader.by_ref())?;
+					current_coordinate += delta as i32;
+					coordinates.push((current_coordinate, flag.on_curve()));
+				}
+			}
+		}
+
+		Ok(coordinates)
+	}
+
+	fn new<R: Read + Seek>(header: GlyphHeader, reader: &mut R) -> Result<SimpleGlyph> {
+		let end_points: Vec<u16> = deserialize_vec(reader, header.num_countours as usize)?;
+		debug!("glyph end points: {end_points:#?}");
+
+		let num_instructions: u16 = deserialize(reader.by_ref())?;
+		let instructions: Vec<u8> = deserialize_vec(reader, num_instructions as usize)?;
+		debug!("glyph instructions: {num_instructions}");
+
+		let flags = SimpleGlyph::read_flags(reader, *end_points.last().unwrap() as usize)?;
+
+		let x_coords = SimpleGlyph::read_coordinates(reader, GlyphFlags::new(&flags), false)?;
+		let y_coords = SimpleGlyph::read_coordinates(reader, GlyphFlags::new(&flags), true)?;
+
+		let coordinates = zip(x_coords.iter().cloned(), y_coords.iter().cloned())
+			.map(|(x, y)| {
+				GlyphPoint {
+					x: x.0, y: y.0, on_curve: x.1
+				}
+			});
+
+		// coordinates.for_each(|point| debug!("({}, {}, {})", point.x, point.y, if point.on_curve { "on" } else { "off" }));
+
+		Ok(SimpleGlyph { header, instructions, points: coordinates.collect() })
+	}
+}
+
+#[derive(Debug)]
+pub enum GlyphData {
+	Simple(SimpleGlyph),
+	Composite
+}
+
+#[derive(Debug)]
+pub struct GlyphTable {
+	data_source: BufReader<File>,
+	offset: u32,
+
+	cache: HashMap<u16, GlyphData>
+}
+
+impl GlyphTable {
+	pub fn get_glyph(&mut self, glyph_id: u16, location: &mut IndexToLocation) -> Result<GlyphData>{
+		let Some(offset) = location.get_offset(glyph_id) else {
+			return Err(ErrorKind::Custom("Failed to look up glyph location".into()).into());
+		};
+
+		debug!("glyph has offset {offset}");
+		self.data_source.seek(SeekFrom::Start(self.offset as u64 + offset as u64))?;
+
+		debug!("reading glyph data from position {}", self.offset as u64 + offset as u64);
+
+		let header: GlyphHeader = deserialize(self.data_source.get_ref())?;
+		debug!("glyph header: {header:#?}");
+
+		if header.num_countours >= 0 {
+			Ok(GlyphData::Simple(SimpleGlyph::new(header, self.data_source.by_ref())?))
+		} else {
+			todo!();
+		}
+	}
+}
+
+impl FontTable for GlyphTable {
+	const TAG: &'static str = "glyf";
+	type InitData = ();
+
+	fn decode(reader: BufReader<File>, table: &TableDirectoryRecord, _: Option<Self::InitData>) -> bincode::Result<Self>
+		where Self: Sized 
+	{
+		Ok(GlyphTable {
+			data_source: reader,
+			offset: table.offset,
+
+			cache: HashMap::new()
+		})
+	}
+}

src/main.rs

@@ -37,7 +37,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         Ok(()) => {},
         Err(err) => {
             error!("{err}");
-            return Err(String::from(err).into());
+            return Err(err);
         }
     };