xmrs 0.10.3

A library to edit SoundTracker data with pleasure
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
135
136
137
138
139
140

use alloc::format;
use alloc::{vec, vec::Vec};

use crate::import::import_memory::{ImportMemory, MemoryType};
use crate::prelude::*;

use super::instr_helper::InstrHelper;
use super::one_sid::OneSid;
use super::pattern_helper::PatternHelper;
use super::sound_fx::SoundFx;

#[derive(Debug)]
pub struct SidModule {
    pub sid: OneSid,
    pub pattern_helper: PatternHelper,
    pub instruments: Vec<InstrRobSid>,
    pub soundfx: Vec<SoundFx>,
}

impl SidModule {
    pub fn to_modules(&self, original_instruments: bool) -> Vec<Module> {
        let mut modules: Vec<Module> = vec![];

        for song_number in 0..self.pattern_helper.songs.len() {
            let mut module = Module::default();
            module.name = format!("{} {}", self.sid.name, song_number);
            module.comment = format!(
                "{} - {} (song #{})",
                self.sid.copyright, self.sid.author, song_number
            );
            // SID conversion targets MOD-style memory / Amiga frequencies
            // (see ImportMemory call below), so we use the ProTracker
            // profile.
            module.profile = CompatibilityProfile::pt();
            module.default_tempo = 1 + self.sid.resetspd;

            let mut patterns = self.pattern_helper.get_patterns(song_number);
            PatternHelper::split_large_patterns(&mut patterns);
            let (patterns, pattern_order) = PatternHelper::cleanup_patterns(&patterns);
            let pattern_order = vec![pattern_order];

            let mut im = ImportMemory::default();
            module.pattern = im.unpack_patterns(
                FrequencyType::AmigaFrequencies,
                MemoryType::Mod,
                &pattern_order,
                &patterns,
            );

            module.pattern_order = pattern_order;

            let idst = InstrHelper::irss_to_instruments(&self.instruments, original_instruments);
            module.instrument = idst;

            modules.push(module);
        }

        modules
    }
}

impl SidModule {
    pub fn get_sid_commando() -> Self {
        let sid = OneSid::get_sid_commando();
        sid.to_sidmodule()
    }

    pub fn get_sid_crazy_comets() -> Self {
        let sid = OneSid::get_sid_crazy_comets();
        sid.to_sidmodule()
    }

    pub fn get_sid_last_v8() -> Self {
        let sid = OneSid::get_sid_last_v8();
        sid.to_sidmodule()
    }

    pub fn get_sid_monty_on_the_run() -> Self {
        let sid = OneSid::get_sid_monty_on_the_run();
        sid.to_sidmodule()
    }

    pub fn get_sid_thing_on_a_spring() -> Self {
        let sid = OneSid::get_sid_thing_on_a_spring();
        sid.to_sidmodule()
    }

    pub fn get_sid_zoid() -> Self {
        let sid = OneSid::get_sid_zoid();
        sid.to_sidmodule()
    }

    //--------------------------
    // WIP

    pub fn get_sid_ace_2() -> Self {
        let sid = OneSid::get_sid_ace_2();
        sid.to_sidmodule()
    }

    pub fn get_sid_delta() -> Self {
        let sid = OneSid::get_sid_delta();
        sid.to_sidmodule()
    }

    pub fn get_sid_human_race() -> Self {
        let sid = OneSid::get_sid_human_race();
        sid.to_sidmodule()
    }

    pub fn get_sid_international_karate() -> Self {
        let sid = OneSid::get_sid_international_karate();
        sid.to_sidmodule()
    }

    pub fn get_sid_lightforce() -> Self {
        let sid = OneSid::get_sid_lightforce();
        sid.to_sidmodule()
    }

    pub fn get_sid_sanxion_song_1() -> Self {
        let sid = OneSid::get_sid_sanxion_song_1();
        sid.to_sidmodule()
    }

    pub fn get_sid_sanxion_song_2() -> Self {
        let sid = OneSid::get_sid_sanxion_song_2();
        sid.to_sidmodule()
    }

    pub fn get_sid_spellbound() -> Self {
        let sid = OneSid::get_sid_spellbound();
        sid.to_sidmodule()
    }

    pub fn get_sid_thrust() -> Self {
        let sid = OneSid::get_sid_thrust();
        sid.to_sidmodule()
    }
}