larian_formats/

lsf.rs

use crate::{error::Result, format::Parser, reader::ReadSeek};
use std::io::{Read, Seek};

/// Reads a .lsf file with "magic number" LSOF.
pub type Reader<R> = crate::reader::Reader<Lsf, R>;

/// A successfully parsed .lsf file.
pub struct LsfData {
    names: Vec<Vec<String>>,
    nodes: Vec<NodeInfo>,
    attribute_entries: Vec<AttributeEntry>,
    value_bytes: Vec<u8>,
    #[allow(dead_code)]
    key_entries: Option<Vec<KeyEntry>>,
}

#[derive(Debug, Clone, Copy)]
enum ValueType {
    String,
    Int64,
    Bool,
}

impl ValueType {
    const fn from_u32(value: u32) -> Option<Self> {
        match value & 0b111_111 {
            19 => Some(Self::Bool),
            22 | 23 => Some(Self::String),
            32 => Some(Self::Int64),
            _anything_else => None,
        }
    }
}

impl LsfData {
    /// Prints a summary the data contained by the file to stdout.
    pub fn print_summary(&self) {
        let Some(mut current_node) = self.get_first() else {
            return;
        };

        loop {
            let NodeInfo {
                name_index_outer,
                name_index_inner,
                next_sibling_index,
                first_attribute_index,
                ..
            } = current_node;

            let name = &self.names[*name_index_outer][*name_index_inner];

            println!("{name}:");

            self.print_attribute_summary(*first_attribute_index);

            match u32::try_from(*next_sibling_index) {
                Ok(value) => {
                    current_node = &self.nodes[usize_from_u32!(value)];
                }
                Err(_) => {
                    return;
                }
            }
        }
    }

    fn get_first(&self) -> Option<&NodeInfo> {
        self.nodes.iter().find(|node| node.parent_index == -1)
    }

    fn print_attribute_summary(&self, first_attribute_index: usize) {
        let mut current_attribute = &self.attribute_entries[first_attribute_index];

        loop {
            let AttributeEntry {
                name_index_outer,
                name_index_inner,
                next_index,
                type_info,
                offset,
            } = current_attribute;

            let name = &self.names[*name_index_outer][*name_index_inner];

            print!("\t{name}: ");

            if let Some(value_type) = ValueType::from_u32(*type_info) {
                self.print_value(value_type, *offset, usize_from_u32!(type_info >> 6));
            }

            println!();

            match u32::try_from(*next_index) {
                Ok(value) => {
                    current_attribute = &self.attribute_entries[usize_from_u32!(value)];
                }
                Err(_) => {
                    return;
                }
            }
        }
    }

    fn print_value(&self, value_type: ValueType, offset: usize, length: usize) {
        let value_bytes = &self.value_bytes[offset..offset + length];

        match value_type {
            ValueType::String => {
                let end = value_bytes
                    .iter()
                    .copied()
                    .enumerate()
                    .find_map(|(i, byte)| (byte == 0).then_some(i))
                    .unwrap_or(value_bytes.len());

                print!("\"{}\"", String::from_utf8_lossy(&value_bytes[..end]));
            }
            ValueType::Int64 => match value_bytes.try_into().map(i64::from_le_bytes) {
                Ok(i) => print!("{i}"),
                Err(_) => print!("(i64 bytes) {value_bytes:?}"),
            },
            ValueType::Bool => match value_bytes {
                [0] => print!("false"),
                [1] => print!("true"),
                other => print!("(bool bytes) {other:?}"),
            },
        }
    }
}

/// Wrapper type describing the length of data both compressed and decompressed.
#[derive(Debug, Default, Clone)]
pub struct CompressionMetadata<T> {
    pub num_bytes_compressed: T,
    pub num_bytes_decompressed: T,
}

/// Describes a given "node" of the .lsf file.
#[derive(Debug, Clone)]
pub struct NodeInfo {
    /// The index corresponding to the list of names that contains the name of this node..
    pub name_index_outer: usize,

    /// The index of the name within the inner list.
    pub name_index_inner: usize,

    /// The index of the previous node in the .lsf file. The initial node will have a parent of -1.
    pub parent_index: i32,

    /// The index of the next node in the .lsf file. The final node will have -1 as the next index.
    pub next_sibling_index: i32,

    /// The index of the first attribute of the node.
    pub first_attribute_index: usize,
}

/// Describes an "attribute" of node within an .lsf file.
#[derive(Debug, Clone)]
pub struct AttributeEntry {
    /// The index corresponding to the list of names that contains the name of this node..
    pub name_index_outer: usize,

    /// The index of the name within the inner list.
    pub name_index_inner: usize,

    /// Identifies the type of data the attribute contains.
    pub type_info: u32,

    /// The index of the next attribute in the node. The final attribute will have -1 as the next
    /// index.
    pub next_index: i32,

    /// The offset into the packed value bytes that contains the start of this attribute's value.
    pub offset: usize,
}

/// Describes the metadata of a "key" in the .lsf file.
#[derive(Debug, Clone)]
pub struct KeyEntry {
    /// The index of the node this key corresponds to.
    pub node_index: usize,

    /// The index corresponding to the list of names that contains the name of this node..
    pub name_index_outer: usize,

    /// The index of the name within the inner list.
    pub name_index_inner: usize,
}

/// Contains the logic to parse an .lsf file.
#[derive(Default)]
pub struct Lsf {
    engine_version: u64,
    names_metadata: CompressionMetadata<u64>,
    keys_metadata: CompressionMetadata<u64>,
    nodes_metadata: CompressionMetadata<u64>,
    attributes_metadata: CompressionMetadata<u64>,
    values_metadata: CompressionMetadata<usize>,
    compression_flag_bytes: u32,
    extended_format: u32,
}

impl Parser for Lsf {
    const ID_BYTES: [u8; 4] = [b'L', b'S', b'O', b'F'];

    const MIN_SUPPORTED_VERSION: u32 = 7;

    type Output = LsfData;

    fn read(&mut self, reader: &mut ReadSeek<impl Read + Seek>) -> Result<Self::Output> {
        self.engine_version = reader.read_u64_from_le_bytes()?;
        self.names_metadata.num_bytes_decompressed = reader.read_u32_from_le_bytes()?.into();
        self.names_metadata.num_bytes_compressed = reader.read_u32_from_le_bytes()?.into();
        self.keys_metadata.num_bytes_decompressed = reader.read_u32_from_le_bytes()?.into();
        self.keys_metadata.num_bytes_compressed = reader.read_u32_from_le_bytes()?.into();
        self.nodes_metadata.num_bytes_decompressed = reader.read_u32_from_le_bytes()?.into();
        self.nodes_metadata.num_bytes_compressed = reader.read_u32_from_le_bytes()?.into();
        self.attributes_metadata.num_bytes_decompressed = reader.read_u32_from_le_bytes()?.into();
        self.attributes_metadata.num_bytes_compressed = reader.read_u32_from_le_bytes()?.into();
        self.values_metadata.num_bytes_decompressed = reader.read_usize_from_u32_le_bytes()?;
        self.values_metadata.num_bytes_compressed = reader.read_usize_from_u32_le_bytes()?;

        self.compression_flag_bytes = reader.read_u32_from_le_bytes()?;
        self.extended_format = reader.read_u32_from_le_bytes()?;

        let names = parse_names(reader)?;
        let nodes = self.parse_nodes(reader)?;
        let attribute_entries = self.parse_attribute_entries(reader)?;
        let value_bytes = self.parse_value_bytes(reader)?;
        let key_entries = self.parse_key_entries(reader)?;

        Ok(LsfData {
            names,
            nodes,
            attribute_entries,
            value_bytes,
            key_entries,
        })
    }
}

impl Lsf {
    fn parse_nodes(&self, reader: &mut ReadSeek<impl Read + Seek>) -> Result<Vec<NodeInfo>> {
        let starting_position = reader.stream_position()?;
        let mut nodes = Vec::new();

        while reader.stream_position()? <
            starting_position + self.nodes_metadata.num_bytes_decompressed
        {
            let name_index_inner = reader.read_u16_from_le_bytes()?.into();
            let name_index_outer = reader.read_u16_from_le_bytes()?.into();
            let parent_index = reader.read_i32_from_le_bytes()?;
            let next_sibling_index = reader.read_i32_from_le_bytes()?;
            let first_attribute_index = reader.read_usize_from_u32_le_bytes()?;

            nodes.push(NodeInfo {
                name_index_outer,
                name_index_inner,
                parent_index,
                next_sibling_index,
                first_attribute_index,
            });
        }

        Ok(nodes)
    }

    fn parse_attribute_entries(
        &self,
        reader: &mut ReadSeek<impl Read + Seek>,
    ) -> Result<Vec<AttributeEntry>> {
        let starting_position = reader.stream_position()?;
        let mut attributes = Vec::new();

        while reader.stream_position()? <
            starting_position + self.attributes_metadata.num_bytes_decompressed
        {
            let name_index_inner = reader.read_u16_from_le_bytes()?.into();
            let name_index_outer = reader.read_u16_from_le_bytes()?.into();
            let type_info = reader.read_u32_from_le_bytes()?;
            let next_index = reader.read_i32_from_le_bytes()?;
            let offset = reader.read_usize_from_u32_le_bytes()?;

            attributes.push(AttributeEntry {
                name_index_outer,
                name_index_inner,
                type_info,
                next_index,
                offset,
            });
        }

        Ok(attributes)
    }

    fn parse_value_bytes(&self, reader: &mut ReadSeek<impl Read + Seek>) -> Result<Vec<u8>> {
        let mut bytes = vec![0_u8; self.values_metadata.num_bytes_decompressed];
        reader.read_exact(&mut bytes)?;

        Ok(bytes)
    }

    fn parse_key_entries(
        &self,
        reader: &mut ReadSeek<impl Read + Seek>,
    ) -> Result<Option<Vec<KeyEntry>>> {
        let starting_position = reader.stream_position()?;
        let mut key_entries = None;

        while reader.stream_position()? <
            starting_position + self.keys_metadata.num_bytes_decompressed
        {
            let node_index = reader.read_usize_from_u32_le_bytes()?;
            let name_index_inner = reader.read_u16_from_le_bytes()?.into();
            let name_index_outer = reader.read_u16_from_le_bytes()?.into();

            key_entries.get_or_insert_with(Vec::new).push(KeyEntry {
                node_index,
                name_index_outer,
                name_index_inner,
            });
        }

        Ok(key_entries)
    }
}

fn parse_names(reader: &mut ReadSeek<impl Read + Seek>) -> Result<Vec<Vec<String>>> {
    let num_entries = reader.read_usize_from_u32_le_bytes()?;

    (0..num_entries)
        .map(|_| {
            let num_names = reader.read_u16_from_le_bytes()?;
            (0..num_names)
                .map(|_| {
                    let num_bytes_in_name = usize::from(reader.read_u16_from_le_bytes()?);
                    let mut bytes = vec![0_u8; num_bytes_in_name];
                    reader.read_exact(&mut bytes)?;

                    Ok(String::from_utf8_lossy(&bytes).into_owned())
                })
                .collect()
        })
        .collect()
}