gbsdiff 1.0.1

A tool for highlighting the differences in the execution of two GBS files.
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
135
136
137

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

//! This module deals with parsing GBS files.

use std::hint::unreachable_unchecked;

use parse_display::Display;

#[derive(Debug)]
pub struct Gbs<'gbs>(&'gbs [u8]);

impl<'gbs> Gbs<'gbs> {
    const HEADER_LEN: usize = 0x70;
    /// The driver should never access this area.
    pub const MIN_ROM_ADDR: u16 = 0x400;

    pub fn new(data: &'gbs [u8]) -> Result<Self, FormatError<'gbs>> {
        if data.len() < Self::HEADER_LEN {
            return Err(FormatError::TruncatedHeader(data.len()));
        }

        let magic = &data[0..3];
        if magic != b"GBS" {
            return Err(FormatError::BadMagic(magic));
        }

        let version = data[3];
        if version != 1 {
            return Err(FormatError::UnsupportedVersion(version));
        }

        let gbs = Self(data);
        if gbs.nb_songs() == 0 {
            return Err(FormatError::ZeroSongs);
        }

        let load_addr = gbs.addr(AddressKind::Load);
        if !(Self::MIN_ROM_ADDR..=0x4000).contains(&load_addr) {
            return Err(FormatError::BadAddress(AddressKind::Load, load_addr));
        }
        for kind in [AddressKind::Init, AddressKind::Play] {
            let addr = gbs.addr(kind);
            if !(load_addr..0x8000).contains(&addr) {
                return Err(FormatError::BadAddress(kind, addr));
            }
        }

        Ok(gbs)
    }

    fn read16(&self, ofs: usize) -> u16 {
        let raw = [self.0[ofs], self.0[ofs + 1]];
        u16::from_le_bytes(raw)
    }

    pub fn nb_songs(&self) -> u8 {
        self.0[4]
    }

    pub fn first_song(&self) -> u8 {
        self.0[5]
    }

    pub fn addr(&self, kind: AddressKind) -> u16 {
        self.read16(kind.ofs())
    }

    pub fn stack_ptr(&self) -> u16 {
        self.read16(12)
    }

    pub fn timer_mod(&self) -> u8 {
        self.0[14]
    }

    pub fn timer_div_bit(&self) -> u8 {
        match self.timer_ctrl() & 3 {
            0 => 9,
            1 => 3,
            2 => 5,
            3 => 7,
            _ => unsafe { unreachable_unchecked() },
        }
    }

    pub fn use_timer(&self) -> bool {
        self.timer_ctrl() & 4 != 0
    }

    pub fn double_speed(&self) -> bool {
        self.timer_ctrl() & 0x80 != 0
    }

    fn timer_ctrl(&self) -> u8 {
        self.0[15]
    }

    pub fn rom(&self) -> &[u8] {
        &self.0[0x70..]
    }
}

#[derive(Debug, Display)]
pub enum FormatError<'a> {
    #[display("expected at least 0x70 header bytes, got only {0}")]
    TruncatedHeader(usize),
    #[display("expected \"GBS\" magic, got \"{0:?}\"")]
    BadMagic(&'a [u8]),
    #[display("unsupported version {0}")]
    UnsupportedVersion(u8),
    #[display("zero songs specified")]
    ZeroSongs,
    #[display("bad {0} address ${1:04x}")]
    BadAddress(AddressKind, u16),
}

#[derive(Debug, Display, Clone, Copy)]
#[display(style = "lowercase")]
pub enum AddressKind {
    Load,
    Init,
    Play,
}

impl AddressKind {
    fn ofs(&self) -> usize {
        match self {
            Self::Load => 6,
            Self::Init => 8,
            Self::Play => 10,
        }
    }
}