Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

5.5 KB
Raw Blame
use std::fs::File;
use std::io::{self, BufReader, Cursor, Read, Seek, SeekFrom};
use std::path::Path;
use std::sync::{Arc, Mutex};

use image::banner::Banner;
use image::dvd::{DVD_HEADER_SIZE, Header};
use image::rvz;
use indexed_deflate::{AccessPointSpan, DeflateIndexBuilder};
use zerocopy::FromBytes;

pub fn read_metadata(path: &Path) -> anyhow::Result<(Header, Option<Banner>)> {
    self::read_stream(self::open(path)?)
}

pub fn read_header(path: &Path) -> anyhow::Result<Header> {
    self::header_from_stream(self::open(path)?)
}

fn open(path: &Path) -> io::Result<ScanStream> {
    let file = File::open(path)?;
    let len = file.metadata()?.len();
    Ok(ScanStream::new(BufReader::new(file), len))
}

fn header_from_stream(stream: ScanStream) -> anyhow::Result<Header> {
    let mut stream = self::unwrap_zip(stream)?;
    let mut bytes = [0; DVD_HEADER_SIZE];
    stream.read_exact(&mut bytes)?;

    if bytes.starts_with(&rvz::RVZ_MAGIC) {
        bytes.copy_within(
            rvz::DISC_HEADER_OFFSET..rvz::DISC_HEADER_OFFSET + rvz::DISC_HEADER_SIZE,
            0,
        );
        bytes[rvz::DISC_HEADER_SIZE..].fill(0);
    }

    let header = Header::read_from_bytes(&bytes).unwrap();
    anyhow::ensure!(header.is_gc() || header.is_wii(), "invalid disc header");
    Ok(header)
}

fn unwrap_zip(mut stream: ScanStream) -> anyhow::Result<ScanStream> {
    let mut magic = [0; 4];
    stream.read_exact(&mut magic)?;
    stream.rewind()?;

    if &magic == b"PK\x03\x04" {
        return self::open_zip(stream);
    }
    Ok(stream)
}

fn read_stream(stream: ScanStream) -> anyhow::Result<(Header, Option<Banner>)> {
    let stream = self::unwrap_zip(stream)?;
    let disc = nod::Disc::new_stream(Box::new(stream))?;
    let mut partition = disc.open_partition_kind(nod::PartitionKind::Data)?;

    let mut bytes = [0; DVD_HEADER_SIZE];
    partition.read_exact(&mut bytes)?;
    if disc.header().is_wii() {
        image::dvd::unshift_wii_header_offsets(&mut bytes);
    }
    let header = Header::read_from_bytes(&bytes).unwrap();

    let banner = image::banner::extract(
        &header,
        |offset, buf| {
            partition.seek(SeekFrom::Start(offset as u64))?;
            partition.read_exact(buf)
        },
        crate::banner::decode,
    )?;
    Ok((header, banner))
}

fn open_zip(stream: ScanStream) -> anyhow::Result<ScanStream> {
    let file_len = stream.len;
    let mut archive = zip::ZipArchive::new(stream)?;
    let index = archive
        .file_names()
        .position(image::is_disc_entry)
        .ok_or_else(|| anyhow::anyhow!("no disc image found in ZIP"))?;

    let entry = archive.by_index_raw(index)?;
    anyhow::ensure!(!entry.encrypted(), "encrypted ZIP disc images are unsupported");
    let start = entry
        .data_start()
        .ok_or_else(|| anyhow::anyhow!("missing ZIP data offset"))?;
    let compressed = entry.compressed_size();
    let len = entry.size();
    let method = entry.compression();
    anyhow::ensure!(
        start <= file_len && compressed <= file_len - start,
        "truncated ZIP entry"
    );
    drop(entry);

    let range = nod::WindowedStream::new(BufReader::new(archive.into_inner()), start, compressed)?;
    match method {
        zip::CompressionMethod::Stored => {
            anyhow::ensure!(compressed == len, "invalid stored ZIP entry size");
            Ok(ScanStream::new(range, len))
        }
        zip::CompressionMethod::Deflated => {
            let span = AccessPointSpan::new(compressed.div_ceil(64).max(1024 * 1024));
            let reader = DeflateIndexBuilder::new(range, Cursor::new(Vec::new()), span)?;
            Ok(ScanStream::new(reader, len))
        }
        _ => anyhow::bail!("unsupported ZIP compression method: {method}"),
    }
}

trait ReadSeek: Read + Seek + Send {}
impl<T: Read + Seek + Send> ReadSeek for T {}

#[derive(Clone)]
struct ScanStream {
    reader: Arc<Mutex<SharedReader>>,
    position: u64,
    len: u64,
}

struct SharedReader {
    reader: Box<dyn ReadSeek>,
    position: Option<u64>,
}

impl ScanStream {
    fn new(reader: impl Read + Seek + Send + 'static, len: u64) -> Self {
        Self {
            reader: Arc::new(Mutex::new(SharedReader {
                reader: Box::new(reader),
                position: None,
            })),
            position: 0,
            len,
        }
    }
}

impl Read for ScanStream {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        let len = self.len.saturating_sub(self.position).min(buf.len() as u64) as usize;
        if len == 0 {
            return Ok(0);
        }

        let mut reader = self
            .reader
            .lock()
            .map_err(|_| io::Error::other("disc reader poisoned"))?;
        let in_place = reader.position == Some(self.position);
        reader.position = None;
        if !in_place {
            reader.reader.seek(SeekFrom::Start(self.position))?;
        }

        let read = reader.reader.read(&mut buf[..len])?;
        self.position += read as u64;
        reader.position = Some(self.position);
        Ok(read)
    }
}

impl Seek for ScanStream {
    fn seek(&mut self, from: SeekFrom) -> io::Result<u64> {
        let position = match from {
            SeekFrom::Start(offset) => Some(offset),
            SeekFrom::Current(offset) => self.position.checked_add_signed(offset),
            SeekFrom::End(offset) => self.len.checked_add_signed(offset),
        }
        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "invalid disc seek"))?;

        self.position = position;
        Ok(position)
    }
}