It makes networked noise! (Poorly, for now)

1 files changed, 122 insertions, 0 deletions

diff --git a/src/client.rs b/src/client.rs
new file mode 100644
index 0000000..1a0c69f
--- /dev/null
+++ b/src/client.rs
@@ -0,0 +1,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;
+    }
+}