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
|
use std::net::{UdpSocket};
use std::{io, mem};
use synth::*;
use proto::*;
pub struct Voice {
pub gen: GenBox,
pub params: Parameters,
}
pub struct Client {
pub socket: UdpSocket,
pub voices: Vec<Voice>,
pub env: Environment,
pub frames: usize,
pub buf: SampleBuffer,
}
macro_rules! dprintln {
( $( $x:expr ),* ) => { eprintln!( $( $x ),* ) }
}
impl Client {
pub fn new(socket: UdpSocket, gens: Vec<GenBox>, env: Environment) -> io::Result<Client> {
socket.set_nonblocking(true)?;
let buf = SampleBuffer::new(env.default_buffer_size);
let voices = gens.into_iter().map(|g| Voice { gen: g, params: Parameters { env: env.clone(), ..Default::default() } }).collect();
Ok(Client {
socket: socket,
voices: voices,
env: env,
frames: 0,
buf: buf,
})
}
pub fn pump(&mut self, out_buffer: &mut Vec<u8>) -> bool {
if self.voices.len() == 0 {
return false;
}
let mut buffer: [u8; Command::SIZE] = unsafe { mem::uninitialized() };
loop {
match self.socket.recv_from(&mut buffer) {
Ok((bytes, sender)) => {
if bytes != Command::SIZE {
dprintln!("Dropping packet: wrong number of bytes (got {}, expected {})", bytes, Command::SIZE);
continue;
}
let cmd = Command::from(&buffer);
dprintln!("Packet {:?} from {:?}", (&buffer as &[u8]), sender);
match cmd {
Command::KeepAlive => {},
Command::Ping{..} => {
self.socket.send_to(&buffer, sender);
},
Command::Quit => {
return false;
},
Command::Play{voice, freq, amp, ..} => {
if (voice as usize) >= self.voices.len() {
dprintln!("Dropping packet: tried to send to voice {} >= number of voices {}", voice, self.voices.len());
continue;
}
let dur = cmd.duration().unwrap();
let frac_secs = (dur.as_secs() as f32) + (dur.subsec_nanos() as f32) / 1.0e9;
let frames = frac_secs * (self.env.sample_rate as f32);
dprintln!("Playing on voice {} freq {} amp {} from frame {} until frame {}", voice, freq, amp, self.frames, (self.frames as f32) + frames);
let mut vars = &mut self.voices[voice as usize].params.vars;
*vars.entry("v_deadline".to_string()).or_insert_with(Default::default) = (self.frames as f32) + frames;
*vars.entry("v_freq".to_string()).or_insert_with(Default::default) = freq as f32;
*vars.entry("v_amp".to_string()).or_insert_with(Default::default) = amp;
},
Command::Caps{..} => {
let reply = Command::Caps {
voices: self.voices.len() as u32,
tp: ['S' as u8, 'Y' as u8, 'N' as u8, 'F' as u8],
ident: [0u8; 24],
};
let mut reply_buffer: [u8; Command::SIZE] = [0u8; Command::SIZE];
reply.write_into(&mut reply_buffer);
self.socket.send_to(&reply_buffer, sender);
},
Command::PCM{..} => { /* TODO */ },
Command::Unknown{data} => {
dprintln!("Dropping packet: unknown data {:?}", (&data as &[u8]));
},
}
},
Err(err) => {
if err.kind() == io::ErrorKind::WouldBlock {
break;
}
return false;
},
}
}
for voice in self.voices.iter_mut() {
*voice.params.vars.entry("v_frame".to_string()).or_insert_with(Default::default) = self.frames as f32;
}
let (first, next) = self.voices.split_at_mut(1);
self.buf.update_from(first[0].gen.eval(&first[0].params));
for voice in next {
self.buf.sum_into(voice.gen.eval(&voice.params));
}
let current = out_buffer.len();
out_buffer.reserve_exact(self.buf.size() - current);
unsafe { out_buffer.set_len(self.buf.size()); }
self.buf.write_bytes(out_buffer);
self.frames += self.buf.len();
return true;
}
}
|
