10 files changed, 316 insertions, 22 deletions

diff --git a/src/synth/adsr.rs b/src/synth/adsr.rs
new file mode 100644
index 0000000..ca7be9c
--- /dev/null
+++ b/src/synth/adsr.rs
@@ -0,0 +1,122 @@
+use super::*;
+
+#[derive(Debug,Clone,Copy,PartialEq,Eq)]
+pub enum Phase {
+    Delay,
+    Attack,
+    Hold,
+    Decay,
+    Sustain,
+    Release,
+}
+
+#[derive(Debug)]
+pub struct DAHDSR {
+    pub delay: GenBox,
+    pub attack: GenBox,
+    pub hold: GenBox,
+    pub decay: GenBox,
+    pub sustain: GenBox,
+    pub release: GenBox,
+    pub gate: GenBox,
+    pub phase: Phase,
+    pub cur: f32,
+    pub attack_cd: f32,
+    pub decay_cd: f32,
+    pub buf: SampleBuffer,
+}
+
+impl Generator for DAHDSR {
+    fn eval<'a>(&'a mut self, params: &Parameters) -> &'a SampleBuffer {
+        self.buf.rate = Rate::Sample;
+
+        let delay = self.delay.eval(params).first();
+        let attack = self.attack.eval(params).first();
+        let hold = self.attack.eval(params).first();
+        let decay = self.decay.eval(params).first();
+        let sustain = self.sustain.eval(params).first();
+        let release = self.release.eval(params).first();
+        let gate = self.gate.eval(params).first();
+
+        if gate >= 0.5 {
+            if self.phase == Phase::Release {
+                self.phase = Phase::Delay;
+                self.attack_cd = delay;
+                self.cur = 0.0;
+            }
+        } else{
+            self.phase = Phase::Release;
+        }
+
+        for samp in self.buf.samples.iter_mut() {
+            match self.phase {
+                Phase::Delay => {
+                    self.attack_cd -= 1.0;
+                    if self.attack_cd <= 0.0 {
+                        self.phase = Phase::Attack;
+                    }
+                },
+                Phase::Attack => {
+                    self.cur += attack;
+                    if self.cur >= 1.0 {
+                        self.cur = 1.0;
+                        self.phase = Phase::Hold;
+                        self.decay_cd = hold;
+                    }
+                },
+                Phase::Hold => {
+                    self.decay_cd -= 1.0;
+                    if self.decay_cd <= 0.0 {
+                        self.phase = Phase::Decay;
+                    }
+                },
+                Phase::Decay => {
+                    self.cur -= decay;
+                    if self.cur <= sustain {
+                        self.cur = sustain;
+                        self.phase = Phase::Sustain;
+                    }
+                },
+                Phase::Sustain => {
+                    self.cur = sustain;
+                },
+                Phase::Release => {
+                    self.cur -= release;
+                    if self.cur < 0.0 {
+                        self.cur = 0.0;
+                    }
+                },
+            }
+            *samp = self.cur;
+        }
+
+        &self.buf
+    }
+    fn buffer(&self) -> &SampleBuffer { &self.buf }
+    fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
+        mem::replace(&mut self.buf, buf)
+    }
+}
+
+pub struct DAHDSRFactory;
+
+impl GeneratorFactory for DAHDSRFactory {
+    fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+        Ok(Box::new(DAHDSR {
+            delay: params.remove_param("delay", 1)?.into_gen()?,
+            attack: params.remove_param("attack", 2)?.into_gen()?,
+            hold: params.remove_param("hold", 3)?.into_gen()?,
+            decay: params.remove_param("decay", 4)?.into_gen()?,
+            sustain: params.remove_param("sustain", 5)?.into_gen()?,
+            release: params.remove_param("release", 6)?.into_gen()?,
+            gate: params.remove_param("gate", 0)?.into_gen()?,
+            phase: Phase::Release,
+            cur: 0.0,
+            attack_cd: 0.0,
+            decay_cd: 0.0,
+            buf: SampleBuffer::new(params.env.default_buffer_size),
+        }))
+    }
+}
+
+pub static Factory: DAHDSRFactory = DAHDSRFactory;
diff --git a/src/synth/lut.rs b/src/synth/lut.rs
new file mode 100644
index 0000000..73b5efa
--- /dev/null
+++ b/src/synth/lut.rs
@@ -0,0 +1,84 @@
+use super::*;
+
+#[derive(Debug)]
+pub struct Lut {
+    pub freq: GenBox,
+    pub phase: f32,
+    pub lut: Vec<Sample>,
+    pub buf: SampleBuffer,
+}
+
+impl Generator for Lut {
+    fn eval<'a>(&'a mut self, params: &Parameters) -> &'a SampleBuffer {
+        self.buf.rate = Rate::Sample;
+
+        let pvel = self.freq.eval(params).first() / params.env.sample_rate;
+        for i in 0..self.buf.len() {
+            self.buf[i] = self.lut[(((self.phase + pvel * (i as f32)) % 1.0) * (self.lut.len() as f32)) as usize];
+        }
+
+        self.phase = (self.phase + pvel * (self.buf.len() as f32)) % 1.0;
+        &self.buf
+    }
+    fn buffer(&self) -> &SampleBuffer { &self.buf }
+    fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
+        mem::replace(&mut self.buf, buf)
+    }
+}
+
+pub struct LutDataFactory;
+
+impl GeneratorFactory for LutDataFactory {
+    fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+        Ok(Box::new(Lut {
+            freq: params.remove_param("freq", 0)?.into_gen()?,
+            phase: params.get_param("phase", 1, &mut ParamValue::Float(0.0)).as_f32()?,
+            buf: SampleBuffer::new(params.env.default_buffer_size),
+            lut: {
+                let mut lut: Vec<Sample> = Vec::new();
+                let mut i = 0;
+
+                while let Ok(samp) = params.get_req_param("_", 2 + i).and_then(|pv| pv.as_f32()) {
+                    lut.push(samp);
+                    i += 1;
+                }
+
+                if lut.is_empty() {
+                    return Err(GenFactoryError::MissingRequiredParam("samples".to_string(), 2));
+                }
+
+                lut
+            },
+        }))
+    }
+}
+
+pub static FactoryLutData: LutDataFactory = LutDataFactory;
+
+pub struct LutGenFactory;
+
+impl GeneratorFactory for LutGenFactory {
+    fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+        eprintln!("LutGenFactory::new({:?})", params);
+        Ok(Box::new(Lut {
+            freq: params.remove_param("freq", 2)?.into_gen()?,
+            phase: params.get_param("phase", 3, &mut ParamValue::Float(0.0)).as_f32()?,
+            buf: SampleBuffer::new(params.env.default_buffer_size),
+            lut: {
+                let mut gen = params.remove_param("gen", 0)?.into_gen()?;
+                let samps = params.get_req_param("samples", 1)?.as_f32()?;
+                let var = params.get_param("var", 4, &mut ParamValue::String("lut_freq".to_string())).as_string()?;
+                let mut genparams = Parameters { env: params.env.clone(), ..Default::default() };
+                genparams.env.sample_rate = samps;
+                genparams.vars.insert(var, 1.0);
+
+                gen.set_buffer(SampleBuffer::new(samps as usize));
+                gen.eval(&genparams);
+
+                gen.set_buffer(SampleBuffer::new(0)).samples
+            },
+        }))
+    }
+}
+
+pub static FactoryLutGen: LutGenFactory = LutGenFactory;
diff --git a/src/synth/mod.rs b/src/synth/mod.rs
index 55268a7..862ca38 100644
--- a/src/synth/mod.rs
+++ b/src/synth/mod.rs
@@ -249,6 +249,7 @@ pub enum ParamKind {
     Generator,
 }
 
+#[derive(Debug)]
 pub enum ParamValue {
     Integer(isize),
     Float(f32),
@@ -266,21 +267,21 @@ impl ParamValue {
         }
     }
 
-    pub fn as_isize(&self) -> Result<isize, GenFactoryError> {
+    pub fn as_isize(&mut self) -> Result<isize, GenFactoryError> {
         match *self {
             ParamValue::Integer(v) => Ok(v),
             ParamValue::Float(v) => Ok(v as isize),
             ParamValue::String(ref v) => v.parse().map_err(|_| GenFactoryError::CannotConvert(ParamKind::String, ParamKind::Integer)),
-            ParamValue::Generator(_) => Err(GenFactoryError::CannotConvert(ParamKind::Generator, ParamKind::Integer)),
+            ParamValue::Generator(ref mut g) => Ok(g.eval(&Default::default()).first() as isize),
         }
     }
 
-    pub fn as_f32(&self) -> Result<f32, GenFactoryError> {
+    pub fn as_f32(&mut self) -> Result<f32, GenFactoryError> {
         match *self {
             ParamValue::Integer(v) => Ok(v as f32),
             ParamValue::Float(v) => Ok(v),
             ParamValue::String(ref v) => v.parse().map_err(|_| GenFactoryError::CannotConvert(ParamKind::String, ParamKind::Float)),
-            ParamValue::Generator(_) => Err(GenFactoryError::CannotConvert(ParamKind::Generator, ParamKind::Float)),
+            ParamValue::Generator(ref mut g) => Ok(g.eval(&Default::default()).first()),
         }
     }
 
@@ -309,25 +310,30 @@ impl<'a> From<&'a ParamValue> for ParamKind {
     }
 }
 
-#[derive(Default)]
+#[derive(Debug,Default)]
 pub struct FactoryParameters {
     pub env: Environment,
     pub vars: HashMap<String, ParamValue>,
 }
 
 impl FactoryParameters {
-    pub fn get_param<'a, 'b : 'a>(&'a self, name: &str, position: usize, default: &'b ParamValue) -> &'a ParamValue {
-        (
-            self.vars.get(name).or_else(||
-                self.vars.get(&position.to_string()).or(Some(default))
-            )
-        ).unwrap()
+    pub fn get_param<'a, 'b : 'a>(&'a mut self, name: &str, position: usize, default: &'b mut ParamValue) -> &'a mut ParamValue {
+        let position = position.to_string();
+
+        match (self.vars.contains_key(name), self.vars.contains_key(&position)) {
+            (true, _) => self.vars.get_mut(name).unwrap(),
+            (false, true) => self.vars.get_mut(&position).unwrap(),
+            (false, false) => default,
+        }
     }
 
-    pub fn get_req_param(&self, name: &str, position: usize) -> Result<&ParamValue, GenFactoryError> {
-        match self.vars.get(name).or_else(|| self.vars.get(&position.to_string())) {
-            Some(v) => Ok(v),
-            None => Err(GenFactoryError::MissingRequiredParam(name.to_string(), position)),
+    pub fn get_req_param(&mut self, name: &str, position: usize) -> Result<&mut ParamValue, GenFactoryError> {
+        let pos = position.to_string();
+
+        match (self.vars.contains_key(name), self.vars.contains_key(&pos)) {
+            (true, _) => Ok(self.vars.get_mut(name).unwrap()),
+            (false, true) => Ok(self.vars.get_mut(&pos).unwrap()),
+            (false, false) => Err(GenFactoryError::MissingRequiredParam(name.to_string(), position)),
         }
     }
 
@@ -367,6 +373,10 @@ pub mod rel;
 pub use self::rel::{Rel, RelOp};
 pub mod logic;
 pub use self::logic::IfElse;
+pub mod util;
+pub use self::util::{ControlRate, SampleRate};
+pub mod lut;
+pub use self::lut::Lut;
 pub mod sine;
 pub use self::sine::Sine;
 pub mod saw;
@@ -377,8 +387,8 @@ pub mod square;
 pub use self::square::Square;
 pub mod noise;
 pub use self::noise::Noise;
-//pub mod adsr;
-//pub use self::adsr::ADSR;
+pub mod adsr;
+pub use self::adsr::DAHDSR;
 
 pub fn all_factories() -> HashMap<String, &'static GeneratorFactory> {
     let mut ret = HashMap::new();
@@ -390,11 +400,16 @@ pub fn all_factories() -> HashMap<String, &'static GeneratorFactory> {
     ret.insert("reciprocate".to_string(), &self::math::FactoryReciprocate as &GeneratorFactory);
     ret.insert("rel".to_string(), &self::rel::Factory as &GeneratorFactory);
     ret.insert("ifelse".to_string(), &self::logic::Factory as &GeneratorFactory);
+    ret.insert("controlrate".to_string(), &self::util::FactoryControlRate as &GeneratorFactory);
+    ret.insert("samplerate".to_string(), &self::util::FactorySampleRate as &GeneratorFactory);
+    ret.insert("lutdata".to_string(), &self::lut::FactoryLutData as &GeneratorFactory);
+    ret.insert("lutgen".to_string(), &self::lut::FactoryLutGen as &GeneratorFactory);
     ret.insert("sine".to_string(), &self::sine::Factory as &GeneratorFactory);
     ret.insert("saw".to_string(), &self::saw::Factory as &GeneratorFactory);
     ret.insert("triangle".to_string(), &self::triangle::Factory as &GeneratorFactory);
     ret.insert("square".to_string(), &self::square::Factory as &GeneratorFactory);
     ret.insert("noise".to_string(), &self::noise::Factory as &GeneratorFactory);
+    ret.insert("dahdsr".to_string(), &self::adsr::Factory as &GeneratorFactory);
 
     ret
 }
diff --git a/src/synth/param.rs b/src/synth/param.rs
index b020574..602be1d 100644
--- a/src/synth/param.rs
+++ b/src/synth/param.rs
@@ -24,7 +24,7 @@ impl GeneratorFactory for ParamFactory {
     fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
         Ok(Box::new(Param {
             name: params.get_req_param("name", 0)?.as_string()?,
-            default: params.get_param("default", 1, &ParamValue::Float(0.0)).as_f32()?,
+            default: params.get_param("default", 1, &mut ParamValue::Float(0.0)).as_f32()?,
             buf: SampleBuffer::new(1),
         }))
     }
diff --git a/src/synth/rel.rs b/src/synth/rel.rs
index e3c4216..d2fbb70 100644
--- a/src/synth/rel.rs
+++ b/src/synth/rel.rs
@@ -11,6 +11,19 @@ pub enum RelOp {
     Less,
 }
 
+impl RelOp {
+    pub fn to_param_string(&self) -> &'static str {
+        match *self {
+            RelOp::Greater => ">",
+            RelOp::GreaterEqual => ">=",
+            RelOp::Equal => "==",
+            RelOp::NotEqual => "!=",
+            RelOp::LessEqual => "<=",
+            RelOp::Less => "<",
+        }
+    }
+}
+
 /* TODO
 impl<T: PartialEq<isize>> From<T> for RelOp {
     fn from(i: T) -> RelOp {
diff --git a/src/synth/saw.rs b/src/synth/saw.rs
index 054b3c8..3e30ca6 100644
--- a/src/synth/saw.rs
+++ b/src/synth/saw.rs
@@ -31,7 +31,7 @@ impl GeneratorFactory for SawFactory {
     fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
         Ok(Box::new(Saw {
             freq: params.remove_param("freq", 0)?.into_gen()?,
-            phase: params.get_param("phase", 1, &ParamValue::Float(0.0)).as_f32()?,
+            phase: params.get_param("phase", 1, &mut ParamValue::Float(0.0)).as_f32()?,
             buf: SampleBuffer::new(params.env.default_buffer_size),
         }))
     }
diff --git a/src/synth/sine.rs b/src/synth/sine.rs
index 66f29ef..4476d4a 100644
--- a/src/synth/sine.rs
+++ b/src/synth/sine.rs
@@ -34,7 +34,7 @@ impl GeneratorFactory for SineFactory {
     fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
         Ok(Box::new(Sine {
             freq: params.remove_param("freq", 0)?.into_gen()?,
-            phase: params.get_param("phase", 1, &ParamValue::Float(0.0)).as_f32()?,
+            phase: params.get_param("phase", 1, &mut ParamValue::Float(0.0)).as_f32()?,
             buf: SampleBuffer::new(params.env.default_buffer_size),
         }))
     }
diff --git a/src/synth/square.rs b/src/synth/square.rs
index 9b4374f..4b01e07 100644
--- a/src/synth/square.rs
+++ b/src/synth/square.rs
@@ -35,7 +35,7 @@ impl GeneratorFactory for SquareFactory {
     fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
         Ok(Box::new(Square {
             freq: params.remove_param("freq", 0)?.into_gen()?,
-            phase: params.get_param("phase", 1, &ParamValue::Float(0.0)).as_f32()?,
+            phase: params.get_param("phase", 1, &mut ParamValue::Float(0.0)).as_f32()?,
             buf: SampleBuffer::new(params.env.default_buffer_size),
         }))
     }
diff --git a/src/synth/triangle.rs b/src/synth/triangle.rs
index 19a2296..944c539 100644
--- a/src/synth/triangle.rs
+++ b/src/synth/triangle.rs
@@ -39,7 +39,7 @@ impl GeneratorFactory for TriangleFactory {
     fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
         Ok(Box::new(Triangle {
             freq: params.remove_param("freq", 0)?.into_gen()?,
-            phase: params.get_param("phase", 1, &ParamValue::Float(0.0)).as_f32()?,
+            phase: params.get_param("phase", 1, &mut ParamValue::Float(0.0)).as_f32()?,
             buf: SampleBuffer::new(params.env.default_buffer_size),
         }))
     }
diff --git a/src/synth/util.rs b/src/synth/util.rs
new file mode 100644
index 0000000..5bde721
--- /dev/null
+++ b/src/synth/util.rs
@@ -0,0 +1,60 @@
+use super::*;
+
+#[derive(Debug)]
+pub struct ControlRate {
+    pub value: GenBox,
+    pub buf: SampleBuffer,
+}
+
+impl ControlRate {
+    pub fn new(mut gen: GenBox) -> ControlRate {
+        gen.set_buffer(SampleBuffer::new(1));
+        ControlRate { value: gen, buf: SampleBuffer::new(1) }
+    }
+}
+
+impl Generator for ControlRate {
+    fn eval<'a>(&'a mut self, params: &Parameters) -> &'a SampleBuffer {
+        self.buf.rate = Rate::Control;
+        self.buf.update_from(self.value.eval(params));
+        &self.buf
+    }
+    fn buffer(&self) -> &SampleBuffer { &self.buf }
+    fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer { mem::replace(&mut self.buf, buf) }
+}
+
+pub struct ControlRateFactory;
+
+impl GeneratorFactory for ControlRateFactory {
+    fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+        Ok(Box::new(ControlRate::new(params.remove_param("gen", 0)?.into_gen()?)))
+    }
+}
+
+pub static FactoryControlRate: ControlRateFactory = ControlRateFactory;
+
+#[derive(Debug)]
+pub struct SampleRate {
+    pub buf: SampleBuffer,
+}
+
+impl Generator for SampleRate {
+    fn eval<'a>(&'a mut self, params: &Parameters) -> &'a SampleBuffer {
+        self.buf.set(params.env.sample_rate);
+        &self.buf
+    }
+    fn buffer(&self) -> &SampleBuffer { &self.buf }
+    fn set_buffer(&mut self, buf: SampleBuffer) -> SampleBuffer {
+        mem::replace(&mut self.buf, buf)
+    }
+}
+
+pub struct SampleRateFactory;
+
+impl GeneratorFactory for SampleRateFactory {
+    fn new(&self, params: &mut FactoryParameters) -> Result<GenBox, GenFactoryError> {
+        Ok(Box::new(SampleRate { buf: SampleBuffer::new(1) }))
+    }
+}
+
+pub static FactorySampleRate: SampleRateFactory = SampleRateFactory;