dream_archive 0.1.4

Pure-Rust Bethesda BA2 and BSA archive reader, extractor, and writer
Documentation
use super::{
    Archive, ArchiveFile, ArchiveInfo, ArchiveVersion, Ba2CompressionFormat, Chunk, Entry, Error,
    FileHeader, Hash, PayloadFormat, Result, TextureHeader,
};
use crate::BString;
use crate::{dds, read::Cursor, storage::Storage};

const MAGIC: u32 = u32::from_le_bytes(*b"BTDX");
const GNRL: u32 = u32::from_le_bytes(*b"GNRL");
const DX10: u32 = u32::from_le_bytes(*b"DX10");
const GNMF: u32 = u32::from_le_bytes(*b"GNMF");

const FILE_HEADER_SIZE_GNRL: u16 = 0x10;
const FILE_HEADER_SIZE_DX10: u16 = 0x18;
const FILE_HEADER_SIZE_GNMF: u16 = 0x30;
const CHUNK_SENTINEL: u32 = 0xBAAD_F00D;

pub(super) fn parse(storage: Storage) -> Result<Archive> {
    let bytes = storage.as_bytes();
    let mut cursor = Cursor::new(bytes);
    let header = RawHeader::read(&mut cursor)?;
    let mut entries = Vec::new();
    entries.try_reserve_exact(header.file_count)?;
    for _ in 0..header.file_count {
        entries.push(read_entry_record(&mut cursor, header.format, bytes)?);
    }

    read_string_table(bytes, header.string_table_offset, &mut entries)?;

    Ok(Archive::from_parts(
        storage,
        ArchiveInfo {
            format: header.format,
            version: header.version,
            compression_format: header.compression_format,
            strings: header.string_table_offset != 0,
        },
        entries,
    ))
}

struct RawHeader {
    format: PayloadFormat,
    version: ArchiveVersion,
    file_count: usize,
    string_table_offset: u64,
    compression_format: Ba2CompressionFormat,
}

impl RawHeader {
    fn read(cursor: &mut Cursor<'_>) -> Result<Self> {
        let magic = cursor.u32()?;
        if magic != MAGIC {
            return Err(Error::InvalidMagic(magic));
        }
        let version = read_version(cursor.u32()?)?;
        let format = read_format(cursor.u32()?)?;
        let file_count = cursor.u32()? as usize;
        let string_table_offset = cursor.u64()?;
        if matches!(version, ArchiveVersion::v2 | ArchiveVersion::v3) {
            let _ = cursor.u64()?;
        }
        let compression_format = if version == ArchiveVersion::v3 && cursor.u32()? == 3 {
            Ba2CompressionFormat::LZ4
        } else {
            Ba2CompressionFormat::Zip
        };
        Ok(Self {
            format,
            version,
            file_count,
            string_table_offset,
            compression_format,
        })
    }
}

fn read_version(raw: u32) -> Result<ArchiveVersion> {
    match raw {
        1 => Ok(ArchiveVersion::v1),
        2 => Ok(ArchiveVersion::v2),
        3 => Ok(ArchiveVersion::v3),
        7 => Ok(ArchiveVersion::v7),
        8 => Ok(ArchiveVersion::v8),
        _ => Err(Error::InvalidVersion(raw)),
    }
}

fn read_format(raw: u32) -> Result<PayloadFormat> {
    match raw {
        GNRL => Ok(PayloadFormat::GNRL),
        DX10 => Ok(PayloadFormat::DX10),
        GNMF => Ok(PayloadFormat::GNMF),
        _ => Err(Error::InvalidFormat(raw)),
    }
}

fn read_entry_record(
    cursor: &mut Cursor<'_>,
    format: PayloadFormat,
    bytes: &[u8],
) -> Result<Entry> {
    let hash = Hash {
        file: cursor.u32()?,
        extension: cursor.u32()?,
        directory: cursor.u32()?,
    }
    .into();
    let _unknown = cursor.u8()?;
    let chunk_count = cursor.u8()? as usize;
    let file_header_size = cursor.u16()?;
    validate_file_header_size(format, file_header_size)?;
    let header = read_file_header(cursor, format)?;
    let mut chunks = Vec::new();
    chunks.try_reserve_exact(chunk_count)?;
    for _ in 0..chunk_count {
        chunks.push(read_chunk(cursor, format, bytes)?);
    }
    validate_entry_chunks(&header, &chunks)?;
    Ok(Entry::new(hash, ArchiveFile { header, chunks }))
}

fn validate_entry_chunks(header: &FileHeader, chunks: &[Chunk]) -> Result<()> {
    let FileHeader::DX10(texture) = *header else {
        return Ok(());
    };
    dds::validate_texture_header(texture)?;
    let mut seen_mips = vec![false; texture.mip_count.into()];
    for chunk in chunks {
        let Some(mips) = &chunk.mips else {
            return Err(Error::Dds("missing BA2 texture mip range"));
        };
        let first = *mips.start();
        let last = *mips.end();
        if first > last || last >= u16::from(texture.mip_count) {
            return Err(Error::Dds("invalid BA2 texture mip range"));
        }
        for mip in first..=last {
            let seen = &mut seen_mips[usize::from(mip)];
            if *seen {
                return Err(Error::Dds("duplicate BA2 texture mip range"));
            }
            *seen = true;
        }
        dds::validate_texture_mip_payload_size(texture, first, last, chunk.size().try_into()?)?;
    }
    if seen_mips.into_iter().all(|seen| seen) {
        Ok(())
    } else {
        Err(Error::Dds("missing BA2 texture mip range"))
    }
}

fn validate_file_header_size(format: PayloadFormat, size: u16) -> Result<()> {
    if matches!(
        (format, size),
        (PayloadFormat::GNRL, FILE_HEADER_SIZE_GNRL)
            | (PayloadFormat::DX10, FILE_HEADER_SIZE_DX10)
            | (PayloadFormat::GNMF, FILE_HEADER_SIZE_GNMF)
    ) {
        Ok(())
    } else {
        Err(Error::InvalidChunkSize(size))
    }
}

fn read_file_header(cursor: &mut Cursor<'_>, format: PayloadFormat) -> Result<FileHeader> {
    Ok(match format {
        PayloadFormat::GNRL => FileHeader::GNRL,
        PayloadFormat::DX10 => FileHeader::DX10(TextureHeader {
            height: cursor.u16()?,
            width: cursor.u16()?,
            mip_count: cursor.u8()?,
            format: cursor.u8()?,
            flags: cursor.u8()?,
            tile_mode: cursor.u8()?,
        }),
        PayloadFormat::GNMF => {
            let mut metadata = [0u32; 8];
            for slot in &mut metadata {
                *slot = cursor.u32()?;
            }
            FileHeader::GNMF(metadata)
        }
    })
}

fn read_chunk(cursor: &mut Cursor<'_>, format: PayloadFormat, bytes: &[u8]) -> Result<Chunk> {
    let offset = cursor.u64()?;
    let packed = cursor.u32()?;
    let size = cursor.u32()?;
    let mips = match format {
        PayloadFormat::GNRL => None,
        PayloadFormat::DX10 | PayloadFormat::GNMF => Some(cursor.u16()?..=cursor.u16()?),
    };
    let sentinel = cursor.u32()?;
    if sentinel != CHUNK_SENTINEL {
        return Err(Error::InvalidChunkSentinel(sentinel));
    }
    let chunk = Chunk::new(offset, packed, size, mips);
    let _ = chunk.stored_bytes(bytes)?;
    Ok(chunk)
}

fn read_string_table(bytes: &[u8], offset: u64, entries: &mut [Entry]) -> Result<()> {
    if offset == 0 {
        return Ok(());
    }
    let mut names = Cursor::new(bytes);
    names.seek(offset.try_into()?)?;
    for entry in entries {
        let len = names.u16()? as usize;
        entry.set_name(BString::new(names.bytes(len)?.to_vec()));
    }
    Ok(())
}