@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.3

package/rust/core/audio/engine/helpers.rs

@@ -1,170 +1,178 @@
-use devalang_types::Value;
-use std::collections::HashMap;
-
-type OptMap = Option<HashMap<String, Value>>;
-
-pub fn env_maps_from_automation(
-    automation: &Option<HashMap<String, Value>>,
-) -> (OptMap, OptMap, OptMap) {
-    if let Some(auto) = automation {
-        let vol = match auto.get("volume") {
-            Some(Value::Map(m)) => Some(m.clone()),
-            _ => None,
-        };
-        let pan = match auto.get("pan") {
-            Some(Value::Map(m)) => Some(m.clone()),
-            _ => None,
-        };
-        let pit = match auto.get("pitch") {
-            Some(Value::Map(m)) => Some(m.clone()),
-            _ => None,
-        };
-        (vol, pan, pit)
-    } else {
-        (None, None, None)
-    }
-}
-
-pub fn eval_env_map(
-    env_opt: &Option<HashMap<String, Value>>,
-    progress: f32,
-    default_val: f32,
-) -> f32 {
-    let env = match env_opt {
-        Some(m) => m,
-        None => {
-            return default_val;
-        }
-    };
-    let mut points: Vec<(f32, f32)> = Vec::with_capacity(env.len());
-    for (k, v) in env.iter() {
-        let key = if k.ends_with('%') {
-            &k[..k.len() - 1]
-        } else {
-            &k[..]
-        };
-        if let Ok(mut p) = key.parse::<f32>() {
-            p = (p / 100.0).clamp(0.0, 1.0);
-            let val = match v {
-                Value::Number(n) => *n,
-                Value::String(s) => s.parse::<f32>().unwrap_or(default_val),
-                Value::Identifier(s) => s.parse::<f32>().unwrap_or(default_val),
-                _ => default_val,
-            };
-            points.push((p, val));
-        }
-    }
-    if points.is_empty() {
-        return default_val;
-    }
-    points.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
-    let t = progress.clamp(0.0, 1.0);
-    if t <= points[0].0 {
-        return points[0].1;
-    }
-    if t >= points[points.len() - 1].0 {
-        return points[points.len() - 1].1;
-    }
-    for w in points.windows(2) {
-        let (p0, v0) = w[0];
-        let (p1, v1) = w[1];
-        if t >= p0 && t <= p1 {
-            let ratio = if (p1 - p0).abs() < f32::EPSILON {
-                0.0
-            } else {
-                (t - p0) / (p1 - p0)
-            };
-            return v0 + (v1 - v0) * ratio;
-        }
-    }
-    default_val
-}
-
-pub fn oscillator_sample(waveform: &str, current_freq: f32, t: f32) -> f32 {
-    let phase = 2.0 * std::f32::consts::PI * current_freq * t;
-    match waveform {
-        "sine" => phase.sin(),
-        "square" => {
-            if phase.sin() >= 0.0 {
-                1.0
-            } else {
-                -1.0
-            }
-        }
-        "saw" => 2.0 * (current_freq * t - (current_freq * t + 0.5).floor()),
-        "triangle" => (2.0 * (2.0 * (current_freq * t).fract() - 1.0)).abs() * 2.0 - 1.0,
-        _ => 0.0,
-    }
-}
-
-pub fn adsr_envelope_value(
-    i: usize,
-    attack_samples: usize,
-    decay_samples: usize,
-    sustain_samples: usize,
-    release_samples: usize,
-    sustain_level: f32,
-) -> f32 {
-    let attack_start = 0usize;
-    let decay_start = attack_samples;
-    let sustain_start = attack_samples + decay_samples;
-    let release_start = attack_samples + decay_samples + sustain_samples;
-
-    if i < attack_start + attack_samples && attack_samples > 0 {
-        let k = i - attack_start;
-        let denom = if attack_samples > 1 {
-            (attack_samples - 1) as f32
-        } else {
-            1.0
-        };
-        (k as f32) / denom
-    } else if i < decay_start + decay_samples && decay_samples > 0 {
-        let k = i - decay_start;
-        let denom = if decay_samples > 1 {
-            (decay_samples - 1) as f32
-        } else {
-            1.0
-        };
-        let ratio = (k as f32) / denom;
-        1.0 - (1.0 - sustain_level) * ratio
-    } else if i < sustain_start + sustain_samples {
-        sustain_level
-    } else if release_samples > 0 {
-        // release: interpolate from sustain_level down to 0 inclusive
-        let k = i.saturating_sub(release_start);
-        let denom = if release_samples > 1 {
-            (release_samples - 1) as f32
-        } else {
-            1.0
-        };
-        let ratio = (k as f32) / denom;
-        let val = sustain_level * (1.0 - ratio);
-        if val < 0.0 { 0.0 } else { val }
-    } else {
-        0.0
-    }
-}
-
-pub fn pan_gains(pan_val: f32) -> (f32, f32) {
-    let left_gain = 1.0 - pan_val.max(0.0);
-    let right_gain = 1.0 + pan_val.min(0.0);
-    (left_gain, right_gain)
-}
-
-pub fn mix_stereo_samples_into_buffer(
-    engine: &mut super::synth::AudioEngine,
-    start_sample: usize,
-    channels: usize,
-    stereo_samples: &[i16],
-) {
-    let offset = start_sample * channels;
-    let required_len = offset + stereo_samples.len();
-
-    if engine.buffer.len() < required_len {
-        engine.buffer.resize(required_len, 0);
-    }
-
-    for (i, sample) in stereo_samples.iter().enumerate() {
-        engine.buffer[offset + i] = engine.buffer[offset + i].saturating_add(*sample);
-    }
-}
+use devalang_types::Value;
+use std::collections::HashMap;
+
+type OptMap = Option<HashMap<String, Value>>;
+
+pub fn env_maps_from_automation(
+    automation: &Option<HashMap<String, Value>>,
+) -> (OptMap, OptMap, OptMap) {
+    if let Some(auto) = automation {
+        let vol = match auto.get("volume") {
+            Some(Value::Map(m)) => Some(m.clone()),
+            _ => None,
+        };
+        let pan = match auto.get("pan") {
+            Some(Value::Map(m)) => Some(m.clone()),
+            _ => None,
+        };
+        let pit = match auto.get("pitch") {
+            Some(Value::Map(m)) => Some(m.clone()),
+            _ => None,
+        };
+        (vol, pan, pit)
+    } else {
+        (None, None, None)
+    }
+}
+
+/// Convert an Option<HashMap<..>> into a HashMap (empty if None).
+pub fn env_map_to_hash(opt: &Option<HashMap<String, Value>>) -> HashMap<String, Value> {
+    match opt {
+        Some(m) => m.clone(),
+        None => HashMap::new(),
+    }
+}
+
+pub fn eval_env_map(
+    env_opt: &Option<HashMap<String, Value>>,
+    progress: f32,
+    default_val: f32,
+) -> f32 {
+    let env = match env_opt {
+        Some(m) => m,
+        None => {
+            return default_val;
+        }
+    };
+    let mut points: Vec<(f32, f32)> = Vec::with_capacity(env.len());
+    for (k, v) in env.iter() {
+        let key = if k.ends_with('%') {
+            &k[..k.len() - 1]
+        } else {
+            &k[..]
+        };
+        if let Ok(mut p) = key.parse::<f32>() {
+            p = (p / 100.0).clamp(0.0, 1.0);
+            let val = match v {
+                Value::Number(n) => *n,
+                Value::String(s) => s.parse::<f32>().unwrap_or(default_val),
+                Value::Identifier(s) => s.parse::<f32>().unwrap_or(default_val),
+                _ => default_val,
+            };
+            points.push((p, val));
+        }
+    }
+    if points.is_empty() {
+        return default_val;
+    }
+    points.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
+    let t = progress.clamp(0.0, 1.0);
+    if t <= points[0].0 {
+        return points[0].1;
+    }
+    if t >= points[points.len() - 1].0 {
+        return points[points.len() - 1].1;
+    }
+    for w in points.windows(2) {
+        let (p0, v0) = w[0];
+        let (p1, v1) = w[1];
+        if t >= p0 && t <= p1 {
+            let ratio = if (p1 - p0).abs() < f32::EPSILON {
+                0.0
+            } else {
+                (t - p0) / (p1 - p0)
+            };
+            return v0 + (v1 - v0) * ratio;
+        }
+    }
+    default_val
+}
+
+pub fn oscillator_sample(waveform: &str, current_freq: f32, t: f32) -> f32 {
+    let phase = 2.0 * std::f32::consts::PI * current_freq * t;
+    match waveform {
+        "sine" => phase.sin(),
+        "square" => {
+            if phase.sin() >= 0.0 {
+                1.0
+            } else {
+                -1.0
+            }
+        }
+        "saw" => 2.0 * (current_freq * t - (current_freq * t + 0.5).floor()),
+        "triangle" => (2.0 * (2.0 * (current_freq * t).fract() - 1.0)).abs() * 2.0 - 1.0,
+        _ => 0.0,
+    }
+}
+
+pub fn adsr_envelope_value(
+    i: usize,
+    attack_samples: usize,
+    decay_samples: usize,
+    sustain_samples: usize,
+    release_samples: usize,
+    sustain_level: f32,
+) -> f32 {
+    let attack_start = 0usize;
+    let decay_start = attack_samples;
+    let sustain_start = attack_samples + decay_samples;
+    let release_start = attack_samples + decay_samples + sustain_samples;
+
+    if i < attack_start + attack_samples && attack_samples > 0 {
+        let k = i - attack_start;
+        let denom = if attack_samples > 1 {
+            (attack_samples - 1) as f32
+        } else {
+            1.0
+        };
+        (k as f32) / denom
+    } else if i < decay_start + decay_samples && decay_samples > 0 {
+        let k = i - decay_start;
+        let denom = if decay_samples > 1 {
+            (decay_samples - 1) as f32
+        } else {
+            1.0
+        };
+        let ratio = (k as f32) / denom;
+        1.0 - (1.0 - sustain_level) * ratio
+    } else if i < sustain_start + sustain_samples {
+        sustain_level
+    } else if release_samples > 0 {
+        // release: interpolate from sustain_level down to 0 inclusive
+        let k = i.saturating_sub(release_start);
+        let denom = if release_samples > 1 {
+            (release_samples - 1) as f32
+        } else {
+            1.0
+        };
+        let ratio = (k as f32) / denom;
+        let val = sustain_level * (1.0 - ratio);
+        if val < 0.0 { 0.0 } else { val }
+    } else {
+        0.0
+    }
+}
+
+pub fn pan_gains(pan_val: f32) -> (f32, f32) {
+    let left_gain = 1.0 - pan_val.max(0.0);
+    let right_gain = 1.0 + pan_val.min(0.0);
+    (left_gain, right_gain)
+}
+
+pub fn mix_stereo_samples_into_buffer(
+    engine: &mut super::driver::AudioEngine,
+    start_sample: usize,
+    channels: usize,
+    stereo_samples: &[i16],
+) {
+    let offset = start_sample * channels;
+    let required_len = offset + stereo_samples.len();
+
+    if engine.buffer.len() < required_len {
+        engine.buffer.resize(required_len, 0);
+    }
+
+    for (i, sample) in stereo_samples.iter().enumerate() {
+        engine.buffer[offset + i] = engine.buffer[offset + i].saturating_add(*sample);
+    }
+}

package/rust/core/audio/engine/mod.rs

@@ -1,7 +1,56 @@
-pub mod helpers;
-pub mod sample;
-pub mod synth;
-
-pub use synth::AudioEngine;
-
-pub use helpers::*;
+pub mod driver;
+pub mod export;
+pub mod helpers;
+pub mod notes;
+pub mod sample;
+
+pub use driver::AudioEngine;
+
+pub use driver::CHANNELS;
+pub use driver::MidiNoteEvent;
+pub use driver::SAMPLE_RATE;
+pub use helpers::*;
+
+use crate::core::audio::interpreter::driver::run_audio_program;
+use crate::core::parser::statement::Statement;
+use crate::core::store::global::GlobalStore;
+use devalang_types::{FunctionTable, VariableTable};
+use std::collections::HashMap;
+
+/// Render audio for a set of parsed modules.
+///
+/// For each entry in `modules` (module path -> statements), create an
+/// AudioEngine, setup empty module-local VariableTable and FunctionTable,
+/// invoke the interpreter driver to schedule audio into the engine, and
+/// return a map of module name -> AudioEngine.
+pub fn render_audio_with_modules(
+    modules: HashMap<String, Vec<Statement>>,
+    _output_dir: &str,
+    global_store: &mut GlobalStore,
+) -> HashMap<String, AudioEngine> {
+    let mut result: HashMap<String, AudioEngine> = HashMap::new();
+
+    for (module_name, statements) in modules.into_iter() {
+        // Create engine named after module (used for diagnostics)
+        let mut engine = AudioEngine::new(module_name.clone());
+
+        // Create empty module-local tables; interpreter expects these as starting context
+        let module_vars = VariableTable::new();
+        let module_funcs = FunctionTable::new();
+
+        // Run interpreter which will populate the engine.buffer and midi events
+        let (_max_end_time, _cursor_time) = run_audio_program(
+            &statements,
+            &mut engine,
+            module_name.clone(),
+            module_name.clone(),
+            module_vars,
+            module_funcs,
+            global_store,
+        );
+
+        result.insert(module_name, engine);
+    }
+
+    result
+}

package/rust/core/audio/engine/notes/dsp.rs

@@ -0,0 +1,88 @@
+use crate::core::audio::engine::notes::params::NoteSetup;
+use devalang_types::Value;
+use std::collections::HashMap;
+
+pub fn render_notes_into_buffer(
+    engine: &mut crate::core::audio::engine::AudioEngine,
+    _waveform: &str,
+    _freq: f32,
+    _amp: f32,
+    _start_time_ms: f32,
+    _duration_ms: f32,
+    _synth_params: HashMap<String, Value>,
+    _note_params: HashMap<String, Value>,
+    _automation: Option<HashMap<String, Value>>,
+    setup: NoteSetup,
+) -> Vec<(usize, usize)> {
+    use crate::core::audio::engine::helpers;
+
+    let sample_rate = setup.sample_rate;
+    let channels = setup.channels;
+    let total_samples = setup.total_samples;
+    let start_sample = setup.start_sample;
+
+    let mut stereo_samples: Vec<i16> = Vec::with_capacity(total_samples * channels);
+    let fade_len = (sample_rate * 0.01) as usize; // 10ms fade
+
+    for i in 0..total_samples {
+        let t = ((start_sample + i) as f32) / sample_rate;
+
+        // simplified voice/unison and oscillator sampling
+        let mut value = helpers::oscillator_sample(_waveform, _freq, t);
+
+        // apply ADSR envelope
+        let envelope = helpers::adsr_envelope_value(
+            i,
+            setup.attack_samples,
+            setup.decay_samples,
+            if total_samples > setup.attack_samples + setup.decay_samples + setup.release_samples {
+                total_samples - setup.attack_samples - setup.decay_samples - setup.release_samples
+            } else {
+                0
+            },
+            setup.release_samples,
+            setup.sustain_level,
+        );
+
+        value *= envelope * (i16::MAX as f32) * _amp;
+
+        if fade_len > 0 && i < fade_len {
+            if fade_len == 1 {
+                value *= 0.0;
+            } else {
+                value *= (i as f32) / (fade_len as f32);
+            }
+        } else if fade_len > 0 && i >= total_samples.saturating_sub(fade_len) {
+            if fade_len == 1 {
+                value *= 0.0;
+            } else {
+                value *= ((total_samples - 1 - i) as f32) / ((fade_len - 1) as f32);
+            }
+        }
+
+        let (left_gain, right_gain) = helpers::pan_gains(0.0);
+        let left = (value * left_gain)
+            .round()
+            .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+        let right = (value * right_gain)
+            .round()
+            .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+
+        // push samples interleaved for channels=2, fallback zeros for other channel counts
+        if channels >= 2 {
+            stereo_samples.push(left);
+            stereo_samples.push(right);
+        } else if channels == 1 {
+            stereo_samples.push(((left as i32 + right as i32) / 2) as i16);
+        } else {
+            stereo_samples.push(left);
+            stereo_samples.push(right);
+        }
+    }
+
+    engine.note_count = engine.note_count.saturating_add(1);
+    helpers::mix_stereo_samples_into_buffer(engine, start_sample, channels, &stereo_samples);
+
+    // Return the inserted sample range for this note (start_sample, total_samples)
+    vec![(start_sample, stereo_samples.len())]
+}

package/rust/core/audio/engine/notes/mod.rs

@@ -0,0 +1,53 @@
+use devalang_types::Value;
+use std::collections::HashMap;
+
+pub mod dsp;
+pub mod params;
+
+// Minimal safe facade: parse the setup then call DSP renderer.
+
+pub fn insert_note_impl(
+    engine: &mut crate::core::audio::engine::AudioEngine,
+    owner: Option<String>,
+    waveform: String,
+    freq: f32,
+    amp: f32,
+    start_time_ms: f32,
+    duration_ms: f32,
+    synth_params: HashMap<String, Value>,
+    note_params: HashMap<String, Value>,
+    automation: Option<HashMap<String, Value>>,
+) -> Vec<(usize, usize)> {
+    let setup = params::build_note_setup(
+        engine,
+        &waveform,
+        freq,
+        amp,
+        start_time_ms,
+        duration_ms,
+        &synth_params,
+        &note_params,
+        &automation,
+    );
+
+    let ranges = dsp::render_notes_into_buffer(
+        engine,
+        &waveform,
+        freq,
+        amp,
+        start_time_ms,
+        duration_ms,
+        synth_params,
+        note_params,
+        automation,
+        setup,
+    );
+
+    if let Some(owner_name) = owner {
+        for (start, len) in ranges.iter() {
+            engine.record_last_note_range(&owner_name, *start, *len);
+        }
+    }
+
+    ranges
+}