librsmsx 0.3.13

a MSX emulator written in rust, a port from gomsx
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

use super::sound::FREQUENCY;

pub struct ToneGenerator {
    amp: f32,
    freq: f32,
    // count: usize,
    active: bool,
    w_form: [i16; 32],
    index: f32,
}

const SQ_WAVE: [u8; 32] = [
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 255,
];
impl Default for ToneGenerator {
    fn default() -> Self {
        Self::new()
    }
}

impl ToneGenerator {
    pub fn new() -> Self {
        let mut sd = Self {
            amp: 0.0,
            freq: 0.0,
            // count: 0,
            active: false,
            w_form: [0; 32],
            index: 0.0,
        };
        sd.update_waveform(&SQ_WAVE);
        sd
    }

    pub fn update_waveform(&mut self, data: &[u8]) {
        // Set waveform of tone generator
        // TODO: implement
        for (i, item) in data.iter().enumerate() {
            self.w_form[i] = *item as i16 - 127;
        }
        // for i in 0..data.len() {
        //     self.w_form[i] = (data[i]) as i16 - 127;
        // }
    }
    pub fn set_volume(&mut self, volume: f32) {
        self.amp = volume / 2.0;
    }

    pub fn get_volume(&mut self) -> f32 {
        self.amp
    }

    pub fn set_frequency(&mut self, freq: f32) {
        self.freq = freq;
    }

    pub fn get_frequency(&mut self) -> f32 {
        self.freq
    }

    pub fn activate(&mut self, par: bool) {
        self.active = par;
    }

    pub fn feed_samples(&mut self, data: &mut [i16]) {
        if !self.active || self.freq == 0.0 || self.amp == 0.0 {
            return;
        }

        if self.freq > (FREQUENCY as f32 / 2.0) {
            return;
        }
        let n_samples = (FREQUENCY as f32) / (self.freq);
        let delta = 32.0 / n_samples;
        for item in data.iter_mut() {
            *item += ((self.w_form[self.index as usize] as f32) * self.amp) as i16;
            self.index += delta;
            while self.index >= 32.0 {
                self.index -= 32.0;
            }
        }
    }
}