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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
use std::{iter, cmp, slice, mem};
use std::ops::{Index, IndexMut};
use std::collections::HashMap;
use super::*;
#[derive(PartialEq,Eq,Clone,Copy)]
pub enum Rate {
Sample,
Control,
}
pub struct SampleBuffer {
pub samples: Vec<Sample>,
pub rate: Rate,
}
pub struct Environment {
pub sample_rate: f32,
pub default_buffer_size: usize,
}
impl Default for Environment {
fn default() -> Environment {
Environment {
sample_rate: 44100.0,
default_buffer_size: 64,
}
}
}
pub struct Parameters {
pub env: Environment,
pub vars: HashMap<String, f32>,
}
impl Default for Parameters {
fn default() -> Parameters {
Parameters {
env: Default::default(),
vars: HashMap::new(),
}
}
}
impl SampleBuffer {
pub fn new(sz: usize) -> SampleBuffer {
let mut samples = Vec::with_capacity(sz);
samples.extend(iter::repeat(0 as Sample).take(sz));
SampleBuffer {
samples: samples,
rate: Rate::Sample,
}
}
pub fn len(&self) -> usize {
self.samples.len()
}
pub fn first(&self) -> Sample {
*self.samples.first().unwrap()
}
pub fn set(&mut self, val: Sample) {
self.samples[0] = val;
self.rate = Rate::Control;
}
pub fn update_from(&mut self, other: &SampleBuffer) {
self.rate = other.rate;
match self.rate {
Rate::Sample => {
for i in 0..cmp::min(self.len(), other.len()) {
self.samples[i] = other.samples[i];
}
},
Rate::Control => {
self.samples[0] = other.samples[0];
},
}
}
pub fn sum_into(&mut self, other: &SampleBuffer) {
match self.rate {
Rate::Sample => {
for i in 0..cmp::min(self.len(), other.len()) {
self.samples[i] += match other.rate {
Rate::Sample => other.samples[i],
Rate::Control => other.samples[0],
};
}
},
Rate::Control => {
self.samples[0] += other.samples[0];
},
}
}
pub fn mul_into(&mut self, other: &SampleBuffer) {
match self.rate {
Rate::Sample => {
for i in 0..cmp::min(self.len(), other.len()) {
self.samples[i] *= match other.rate {
Rate::Sample => other.samples[i],
Rate::Control => other.samples[0],
};
}
},
Rate::Control => {
self.samples[0] *= other.samples[0];
},
}
}
pub fn zero(&mut self) {
for i in 0..self.len() {
self.samples[i] = 0.0;
}
}
pub fn bytes<'a>(&'a self) -> &'a [u8] {
unsafe {
slice::from_raw_parts(
self.samples.as_ptr() as *const u8,
self.samples.len() * mem::size_of::<Sample>(),
)
}
}
}
impl Index<usize> for SampleBuffer {
type Output = Sample;
fn index(&self, idx: usize) -> &Sample { &self.samples[idx] }
}
impl IndexMut<usize> for SampleBuffer {
fn index_mut(&mut self, idx: usize) -> &mut Sample { &mut self.samples[idx] }
}
pub trait Generator {
fn eval<'a>(&'a mut self, params: &Parameters) -> &'a SampleBuffer;
}
pub type GenBox = Box<Generator>;
pub mod param;
pub use self::param::Param;
pub mod math;
pub use self::math::{Add, Mul};
pub mod sine;
pub use self::sine::Sine;
//pub mod saw;
//pub use saw::Saw;
//pub mod triangle;
//pub use triangle::Triangle;
|
