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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! [GCM][`crate::gcm`] Boot Header (`boot.bin`). This is the first 0x440 bytes
//! of the GCM image.

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

/// [`Boot`] Console Type.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum ConsoleType {
    /// Nintendo GameCube.
    GameCube,
}

/// [GCM][`crate::gcm`] Boot Header (`boot.bin`) object.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Boot {
    /// Console.
    pub console: ConsoleType,

    /// Game code.
    pub game_code: [u8; 2],

    /// Region code.
    pub country_code: u8,

    /// Maker code.
    pub maker_code: [u8; 2],

    /// Disc number.
    pub disc_id: u8,

    /// Version.
    pub version: u8,

    /// Audio streaming.
    pub audio_streaming: u8,

    /// Stream buffer size.
    pub streaming_buffer_size: u8,

    /// Game name.
    pub game_name: String,

    /// Debug monitor offset (unknown purpose).
    pub debug_monitor_offset: u32,

    /// Debug monitor address (unknown purpose).
    pub debug_monitor_address: u32,

    /// Main executable offset from the start of the file.
    pub main_executable_offset: u32,

    /// FST offset from the start of the file.
    pub fst_offset: u32,

    /// FST size for this disc.
    pub fst_size: u32,

    /// FST max size. FST is shared between all discs and this is
    /// the total size of the FST when all discs are combined.
    pub fst_max_size: u32,

    /// User position (unknown purpose).
    pub user_position: u32,

    /// User length (unknown purpose).
    pub user_length: u32,

    /// Unknown0 (unknown purpose).
    pub unknown0: u32,
}

impl Boot {
    /// Parse GCM Boot.
    pub fn from_binary<D: Parser>(input: &mut D) -> Result<Self> {
        let console = input.u8()?;
        let game_code = input.u8_array::<2>()?;
        let country_code = input.u8()?;
        let maker_code = input.u8_array::<2>()?;
        let disc_id = input.u8()?;
        let version = input.u8()?;
        let audio_streaming = input.u8()?;
        let streaming_buffer_size = input.u8()?;
        let _reserved0 = input.u8_array::<0x12>()?;
        let magic = input.bu32()?;
        let game_name = input.str::<0x3E0, Ascii>()?;
        let debug_monitor_offset = input.bu32()?;
        let debug_monitor_address = input.bu32()?;
        let _reserved1 = input.u8_array::<0x18>()?;
        let main_executable_offset = input.bu32()?;
        let fst_offset = input.bu32()?;
        let fst_size = input.bu32()?;
        let fst_max_size = input.bu32()?;
        let user_position = input.bu32()?;
        let user_length = input.bu32()?;
        let unknown0 = input.bu32()?;
        let _reserved2 = input.u8_array::<0x4>()?;

        ensure!(
            magic == 0xC2339F3D,
            ParseProblem::InvalidHeader("invalid magic", std::panic::Location::current())
        );

        let console = match console {
            0x47 => ConsoleType::GameCube,
            _ => Err(ParseProblem::InvalidHeader(
                "invalid console type",
                std::panic::Location::current(),
            ))?,
        };

        Ok(Self {
            console,
            game_code,
            country_code,
            maker_code,
            disc_id,
            version,
            audio_streaming,
            streaming_buffer_size,
            game_name,
            debug_monitor_offset,
            debug_monitor_address,
            main_executable_offset,
            fst_offset,
            fst_size,
            fst_max_size,
            user_position,
            user_length,
            unknown0,
        })
    }
}