glyph_core/

format.rs

use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use flate2::{read::ZlibDecoder, write::ZlibEncoder, Compression};
use std::io::{Read, Write};

use crate::error::GlyphError;

const MAGIC: [u8; 4] = *b"GLYF";
const VERSION: u32 = 1;

// Constants for performance tuning
const COMPRESSION_LEVEL: Compression = Compression::fast();
const INITIAL_BUFFER_SIZE: usize = 8192;
const CHANGE_BUFFER_CAPACITY: usize = 2048;
const LINE_BUFFER_CAPACITY: usize = 256;

#[derive(Debug, Clone)]
pub struct Frame {
    pub content: String,
    pub duration_ms: Option<u32>,
}

impl Frame {
    pub fn new(content: String) -> Self {
        Self {
            content,
            duration_ms: None,
        }
    }

    pub fn with_duration(content: String, duration_ms: u32) -> Self {
        Self {
            content,
            duration_ms: Some(duration_ms),
        }
    }

    // Optimize validation by using bytes directly
    fn validate_dimensions(&self, width: u32, height: u32) -> Result<(), GlyphError> {
        let bytes = self.content.as_bytes();
        let mut line_count = 0;
        let mut pos = 0;
        let mut line_width = 0;

        while pos < bytes.len() {
            match bytes[pos] {
                b'\n' => {
                    if line_width as u32 != width {
                        return Err(GlyphError::InvalidDimensions {
                            width: line_width as u32,
                            height,
                        });
                    }
                    line_count += 1;
                    line_width = 0;
                }
                _ => line_width += 1,
            }
            pos += 1;
        }

        // Handle last line if it doesn't end with newline
        if line_width > 0 {
            if line_width as u32 != width {
                return Err(GlyphError::InvalidDimensions {
                    width: line_width as u32,
                    height,
                });
            }
            line_count += 1;
        }

        if line_count as u32 != height {
            return Err(GlyphError::InvalidDimensions {
                width,
                height: line_count as u32,
            });
        }

        Ok(())
    }
}

#[derive(Debug)]
pub struct Glyph {
    pub width: u32,
    pub height: u32,
    pub default_duration_ms: u32,
    pub frames: Vec<Frame>,
}

impl Glyph {
    pub fn new(width: u32, height: u32, default_duration_ms: u32) -> Self {
        Self {
            width,
            height,
            default_duration_ms,
            frames: Vec::with_capacity(LINE_BUFFER_CAPACITY),
        }
    }

    pub fn add_frame(&mut self, frame: Frame) -> Result<(), GlyphError> {
        frame.validate_dimensions(self.width, self.height)?;
        self.frames.push(frame);
        Ok(())
    }

    pub fn frames(&self) -> &[Frame] {
        &self.frames
    }

    pub fn write<W: Write>(&self, writer: &mut W) -> Result<(), GlyphError> {
        // Write header
        writer.write_all(&MAGIC)?;
        writer.write_u32::<LittleEndian>(VERSION)?;
        writer.write_u32::<LittleEndian>(self.frames.len() as u32)?;
        writer.write_u32::<LittleEndian>(self.width)?;
        writer.write_u32::<LittleEndian>(self.height)?;
        writer.write_u32::<LittleEndian>(self.default_duration_ms)?;
        writer.write_all(&[0u8; 16])?; // Reserved bytes

        // Pre-allocate buffers for reuse
        let mut changes = Vec::with_capacity(CHANGE_BUFFER_CAPACITY);
        let mut changed_chars = Vec::with_capacity(CHANGE_BUFFER_CAPACITY);
        let mut compressed_buffer = Vec::with_capacity(INITIAL_BUFFER_SIZE);
        let mut utf8_buf = [0u8; 4];

        // Write frames
        for (i, frame) in self.frames.iter().enumerate() {
            // Write duration override flag and value if present
            writer.write_u8(frame.duration_ms.is_some() as u8)?;
            if let Some(duration) = frame.duration_ms {
                writer.write_u32::<LittleEndian>(duration)?;
            }

            if i == 0 {
                // First frame: full compressed data
                let mut encoder = ZlibEncoder::new(&mut compressed_buffer, COMPRESSION_LEVEL);
                encoder.write_all(frame.content.as_bytes())?;
                encoder.finish()?;

                writer.write_u32::<LittleEndian>(compressed_buffer.len() as u32)?;
                writer.write_all(&compressed_buffer)?;
                compressed_buffer.clear();
            } else {
                // Delta encoding for subsequent frames
                let prev_frame = &self.frames[i - 1];
                changes.clear();
                changed_chars.clear();

                // Compare bytes directly for better performance
                let prev_bytes = prev_frame.content.as_bytes();
                let curr_bytes = frame.content.as_bytes();
                let mut pos = 0;
                let mut byte_pos = 0;

                while byte_pos < curr_bytes.len() {
                    if byte_pos >= prev_bytes.len() || curr_bytes[byte_pos] != prev_bytes[byte_pos]
                    {
                        // Found a difference, decode the character
                        let mut char_len = 1;
                        while byte_pos + char_len < curr_bytes.len()
                            && (curr_bytes[byte_pos + char_len] & 0xC0) == 0x80
                        {
                            char_len += 1;
                        }
                        if let Some(c) =
                            std::str::from_utf8(&curr_bytes[byte_pos..byte_pos + char_len])
                                .ok()
                                .and_then(|s| s.chars().next())
                        {
                            changes.push(pos as u32);
                            changed_chars.push(c);
                        }
                    }

                    // Move to next character
                    if byte_pos < prev_bytes.len() {
                        let mut len = 1;
                        while byte_pos + len < prev_bytes.len()
                            && (prev_bytes[byte_pos + len] & 0xC0) == 0x80
                        {
                            len += 1;
                        }
                        byte_pos += len;
                    } else {
                        byte_pos += 1;
                    }
                    pos += 1;
                }

                // Compress changed characters efficiently
                let mut encoder = ZlibEncoder::new(&mut compressed_buffer, COMPRESSION_LEVEL);
                for &c in &changed_chars {
                    let len = c.encode_utf8(&mut utf8_buf).len();
                    encoder.write_all(&utf8_buf[..len])?;
                }
                encoder.finish()?;

                // Write delta data
                writer.write_u32::<LittleEndian>(compressed_buffer.len() as u32)?;
                writer.write_u32::<LittleEndian>(changes.len() as u32)?;
                writer.write_all(&compressed_buffer)?;
                compressed_buffer.clear();

                // Write change positions in a batch
                for chunk in changes.chunks(1024) {
                    for &pos in chunk {
                        writer.write_u32::<LittleEndian>(pos)?;
                    }
                }
            }
        }

        Ok(())
    }

    pub fn read<R: Read>(reader: &mut R) -> Result<Self, GlyphError> {
        // Pre-allocate fixed-size buffers
        let mut magic = [0u8; 4];
        let mut reserved = [0u8; 16];
        let mut u32_buf = [0u8; 4];

        // Read and verify magic number
        reader.read_exact(&mut magic)?;
        if magic != MAGIC {
            return Err(GlyphError::InvalidMagic);
        }

        // Read header using fixed buffer
        reader.read_exact(&mut u32_buf)?;
        let version = u32::from_le_bytes(u32_buf);
        if version != VERSION {
            return Err(GlyphError::InvalidVersion);
        }

        reader.read_exact(&mut u32_buf)?;
        let frame_count = u32::from_le_bytes(u32_buf);
        reader.read_exact(&mut u32_buf)?;
        let width = u32::from_le_bytes(u32_buf);
        reader.read_exact(&mut u32_buf)?;
        let height = u32::from_le_bytes(u32_buf);
        reader.read_exact(&mut u32_buf)?;
        let default_duration_ms = u32::from_le_bytes(u32_buf);

        // Skip reserved bytes
        reader.read_exact(&mut reserved)?;

        // Pre-calculate buffer sizes based on dimensions
        let frame_size = (width * height) as usize;
        let mut glyph = Glyph::new(width, height, default_duration_ms);
        let mut compressed_buffer = Vec::with_capacity(frame_size * 2);
        let mut content_buffer = String::with_capacity(frame_size);
        let mut prev_content = String::with_capacity(frame_size);
        let mut char_buf = Vec::with_capacity(frame_size);

        // Read frames
        for i in 0..frame_count {
            // Read duration override
            let has_duration = reader.read_u8()? != 0;
            let duration = if has_duration {
                reader.read_exact(&mut u32_buf)?;
                Some(u32::from_le_bytes(u32_buf))
            } else {
                None
            };

            content_buffer.clear();
            if i == 0 {
                // First frame: read full compressed data
                reader.read_exact(&mut u32_buf)?;
                let compressed_len = u32::from_le_bytes(u32_buf) as usize;
                compressed_buffer.resize(compressed_len, 0);
                reader.read_exact(&mut compressed_buffer)?;

                let mut decoder = ZlibDecoder::new(&compressed_buffer[..]);
                decoder
                    .read_to_string(&mut content_buffer)
                    .map_err(|e| GlyphError::DecompressionError(e.to_string()))?;

                prev_content.clear();
                prev_content.push_str(&content_buffer);
            } else {
                // Delta encoded frame
                reader.read_exact(&mut u32_buf)?;
                let compressed_len = u32::from_le_bytes(u32_buf) as usize;
                reader.read_exact(&mut u32_buf)?;
                let change_count = u32::from_le_bytes(u32_buf) as usize;

                // Read and decompress changed characters
                compressed_buffer.resize(compressed_len, 0);
                reader.read_exact(&mut compressed_buffer)?;

                let mut decoder = ZlibDecoder::new(&compressed_buffer[..]);
                char_buf.clear();
                decoder
                    .read_to_end(&mut char_buf)
                    .map_err(|e| GlyphError::DecompressionError(e.to_string()))?;

                let changed_chars = std::str::from_utf8(&char_buf)
                    .map_err(|e| GlyphError::DecompressionError(e.to_string()))?;

                if changed_chars.chars().count() != change_count {
                    return Err(GlyphError::FrameDataError(
                        "Mismatch in change count".to_string(),
                    ));
                }

                // Apply changes to previous frame efficiently
                content_buffer.push_str(&prev_content);
                let mut content_chars: Vec<char> = content_buffer.chars().collect();

                // Read and apply changes in chunks for better cache utilization
                let changed_chars_iter = changed_chars.chars();
                let mut positions = Vec::with_capacity(change_count);
                for _ in 0..change_count {
                    reader.read_exact(&mut u32_buf)?;
                    positions.push(u32::from_le_bytes(u32_buf) as usize);
                }

                for (pos, new_char) in positions.into_iter().zip(changed_chars_iter) {
                    if pos >= content_chars.len() {
                        return Err(GlyphError::FrameDataError(
                            "Invalid change position".to_string(),
                        ));
                    }
                    content_chars[pos] = new_char;
                }

                content_buffer.clear();
                content_buffer.extend(content_chars);
                prev_content.clear();
                prev_content.push_str(&content_buffer);
            }

            let frame = Frame {
                content: content_buffer.clone(),
                duration_ms: duration,
            };

            glyph.add_frame(frame)?;
        }

        Ok(glyph)
    }
}