picori 0.1.0

Picori is a library for decompilation, modding, and rom-hacking with focus on GameCube and Wii games.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! Parse GameCube master disc ([GCM][`crate::gcm`]) files.
//!
//! [GCM][`crate::gcm`] is a direct 1-to-1 copy of the a GameCube disc. It contains the
//! executable code, the data files, and the file system table.
//!
//! # Parse
//!
//! Parse from binary stream by calling [`Gcm::from_binary`]. On error a
//! [Error][`crate::Error`] is return. Otherwise, the parsing succeeded and you
//! get back a [`Gcm`] struct.
//!
//! ## Example
//!
//! This is an example of how to parse a `.gcm`/`.iso` file.
//!
//! ```no_run
//! # use std::fs::File;
//! # use picori::Result;
//! fn main() -> Result<()> {
//!     let mut file = File::open("game.iso")?;
//!     let _ = picori::Gcm::from_binary(&mut file)?;
//!     Ok(())
//! }
//! ```

pub mod apploader;
pub mod bi2;
pub mod boot;
pub mod executable;
pub mod fst;

#[doc(inline)]
pub use apploader::*;
#[doc(inline)]
pub use bi2::*;
#[doc(inline)]
pub use boot::*;
#[doc(inline)]
pub use executable::*;
#[doc(inline)]
pub use fst::Fst;

use crate::helper::{ensure, ParseProblem, Parser, ProblemLocation, Seeker};
use crate::Result;

/// `.gcm` file object. 
/// 
/// Because `.gcm` files take up a lot of space, the [`Gcm`]
/// only contains information about the boot, bi2, apploader, executable, and
/// file string table. File specific data is not included. To get the data for a
/// specific file, use [`Gcm::fst`] to find the file entry. Then use
/// [`fst::Entry::File::offset`] and [`fst::Entry::File::size`] to read the file
/// data yourself.
pub struct Gcm {
    boot:       Boot,
    bi2:        Bi2,
    apploader:  Apploader,
    executable: Executable,
    fst:        Fst,
}

impl Gcm {
    /// Parse GCM file from binary stream.
    pub fn from_binary<D: Parser + Seeker>(reader: &mut D) -> Result<Gcm> {
        let position = reader.position()?;

        let boot = Boot::from_binary(reader)?;
        ensure!(
            position + 0x440 == reader.position()?,
            ParseProblem::InvalidData("invalid boot", std::panic::Location::current())
        );

        let bi2 = Bi2::from_binary(reader)?;
        ensure!(
            position + 0x2440 == reader.position()?,
            ParseProblem::InvalidData("invalid bi2", std::panic::Location::current())
        );

        let apploader = Apploader::from_binary(reader)?;
        ensure!(
            position + 0x2460 + (apploader.data.len() as u64) == reader.position()?,
            ParseProblem::InvalidData("invalid apploader", std::panic::Location::current())
        );

        reader.goto(position + boot.main_executable_offset as u64)?;
        let executable = Executable::from_binary(reader)?;

        reader.goto(position + boot.fst_offset as u64)?;
        let fst = Fst::from_binary(reader, boot.fst_size as usize)?;

        Ok(Gcm {
            boot,
            bi2,
            apploader,
            executable,
            fst,
        })
    }

    /// Get reference to [`Boot`] struct.
    pub fn boot(&self) -> &Boot { &self.boot }

    /// Get reference to [`Bi2`] struct.
    pub fn bi2(&self) -> &Bi2 { &self.bi2 }

    /// Get reference to [`Apploader`] struct.
    pub fn apploader(&self) -> &Apploader { &self.apploader }

    /// Get reference to [`Executable`] struct.
    pub fn executable(&self) -> &Executable { &self.executable }

    /// Get reference to [`Fst`] struct.
    pub fn fst(&self) -> &Fst { &self.fst }
}