@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.1

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

@@ -0,0 +1,325 @@
+use devalang_types::Value;
+use std::collections::HashMap;
+
+// Sample rate and channel constants used throughout the engine.
+const SAMPLE_RATE: u32 = 44100;
+const CHANNELS: u16 = 2;
+
+/// AudioEngine holds the generated interleaved stereo buffer and
+/// provides simple utilities to mix/merge buffers and export WAV files.
+///
+/// Notes:
+/// - Buffer is interleaved stereo (L,R,L,R...).
+/// - Methods are synchronous and operate on in-memory buffers.
+#[derive(Debug, Clone, PartialEq)]
+pub struct AudioEngine {
+    /// Master volume multiplier (not automatically applied by helpers).
+    pub volume: f32,
+    /// Interleaved i16 PCM buffer.
+    pub buffer: Vec<i16>,
+    /// Logical module name used for error traces/diagnostics.
+    pub module_name: String,
+    /// Simple diagnostic counter for inserted notes.
+    pub note_count: usize,
+}
+
+impl AudioEngine {
+    pub fn new(module_name: String) -> Self {
+        AudioEngine {
+            volume: 1.0,
+            buffer: vec![],
+            module_name,
+            note_count: 0,
+        }
+    }
+
+    pub fn get_buffer(&self) -> &[i16] {
+        &self.buffer
+    }
+
+    pub fn get_normalized_buffer(&self) -> Vec<f32> {
+        self.buffer.iter().map(|&s| (s as f32) / 32768.0).collect()
+    }
+
+    pub fn mix(&mut self, other: &AudioEngine) {
+        let max_len = self.buffer.len().max(other.buffer.len());
+        self.buffer.resize(max_len, 0);
+
+        for (i, &sample) in other.buffer.iter().enumerate() {
+            self.buffer[i] = self.buffer[i].saturating_add(sample);
+        }
+    }
+
+    pub fn merge_with(&mut self, other: AudioEngine) {
+        // If the other buffer is empty, simply return without warning (common for spawns that produced nothing)
+        if other.buffer.is_empty() {
+            return;
+        }
+
+        // If the other buffer is present but contains only zeros, warn and skip merge
+        if other.buffer.iter().all(|&s| s == 0) {
+            eprintln!("⚠️ Skipping merge: other buffer is silent");
+            return;
+        }
+
+        if self.buffer.iter().all(|&s| s == 0) {
+            self.buffer = other.buffer;
+            return;
+        }
+
+        self.mix(&other);
+    }
+
+    pub fn set_duration(&mut self, duration_secs: f32) {
+        let total_samples = (duration_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
+
+        if self.buffer.len() < total_samples {
+            self.buffer.resize(total_samples, 0);
+        }
+    }
+
+    pub fn generate_wav_file(&mut self, output_dir: &String) -> Result<(), String> {
+        if self.buffer.len() % (CHANNELS as usize) != 0 {
+            self.buffer.push(0);
+            println!("Completed buffer to respect stereo format.");
+        }
+
+        let spec = hound::WavSpec {
+            channels: CHANNELS,
+            sample_rate: SAMPLE_RATE,
+            bits_per_sample: 16,
+            sample_format: hound::SampleFormat::Int,
+        };
+
+        let mut writer = hound::WavWriter::create(output_dir, spec)
+            .map_err(|e| format!("Error creating WAV file: {}", e))?;
+
+        for sample in &self.buffer {
+            writer
+                .write_sample(*sample)
+                .map_err(|e| format!("Error writing sample: {:?}", e))?;
+        }
+
+        writer
+            .finalize()
+            .map_err(|e| format!("Error finalizing WAV: {:?}", e))?;
+
+        Ok(())
+    }
+
+    // Insert note moved here from original engine.rs
+    pub fn insert_note(
+        &mut self,
+        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>>,
+    ) {
+        // Keep internal logic; helpers called from helpers module
+        let attack = self.extract_f32(&synth_params, "attack").unwrap_or(0.0);
+        let decay = self.extract_f32(&synth_params, "decay").unwrap_or(0.0);
+        let sustain = self.extract_f32(&synth_params, "sustain").unwrap_or(1.0);
+        let release = self.extract_f32(&synth_params, "release").unwrap_or(0.0);
+        let attack_s = if attack > 10.0 {
+            attack / 1000.0
+        } else {
+            attack
+        };
+        let decay_s = if decay > 10.0 { decay / 1000.0 } else { decay };
+        let release_s = if release > 10.0 {
+            release / 1000.0
+        } else {
+            release
+        };
+        let sustain_level = if sustain > 1.0 {
+            (sustain / 100.0).clamp(0.0, 1.0)
+        } else {
+            sustain.clamp(0.0, 1.0)
+        };
+
+        let duration_ms = self
+            .extract_f32(&note_params, "duration")
+            .unwrap_or(duration_ms);
+        let velocity = self.extract_f32(&note_params, "velocity").unwrap_or(1.0);
+        let glide = self.extract_boolean(&note_params, "glide").unwrap_or(false);
+        let slide = self.extract_boolean(&note_params, "slide").unwrap_or(false);
+
+        let _amplitude = (i16::MAX as f32) * amp.clamp(0.0, 1.0) * velocity.clamp(0.0, 1.0);
+
+        let freq_start = freq;
+        let mut freq_end = freq;
+        let amp_start = amp * velocity.clamp(0.0, 1.0);
+        let mut amp_end = amp_start;
+
+        if glide {
+            if let Some(Value::Number(target_freq)) = note_params.get("target_freq") {
+                freq_end = *target_freq;
+            } else {
+                freq_end = freq * 1.5;
+            }
+        }
+
+        if slide {
+            if let Some(Value::Number(target_amp)) = note_params.get("target_amp") {
+                amp_end = *target_amp * velocity.clamp(0.0, 1.0);
+            } else {
+                amp_end = amp_start * 0.5;
+            }
+        }
+
+        let sample_rate = SAMPLE_RATE as f32;
+        let channels = CHANNELS as usize;
+
+        let total_samples = ((duration_ms / 1000.0) * sample_rate) as usize;
+        let start_sample = ((start_time_ms / 1000.0) * sample_rate) as usize;
+
+        let (volume_env, pan_env, pitch_env) =
+            crate::core::audio::engine::helpers::env_maps_from_automation(&automation);
+
+        let mut stereo_samples: Vec<i16> = Vec::with_capacity(total_samples * 2);
+        let fade_len = (sample_rate * 0.01) as usize; // 10 ms fade
+
+        let attack_samples = (attack_s * sample_rate) as usize;
+        let decay_samples = (decay_s * sample_rate) as usize;
+        let release_samples = (release_s * sample_rate) as usize;
+        let sustain_samples = if total_samples > attack_samples + decay_samples + release_samples {
+            total_samples - attack_samples - decay_samples - release_samples
+        } else {
+            0
+        };
+
+        for i in 0..total_samples {
+            let t = ((start_sample + i) as f32) / sample_rate;
+
+            // Glide
+            let current_freq = if glide {
+                freq_start + ((freq_end - freq_start) * (i as f32)) / (total_samples as f32)
+            } else {
+                freq
+            };
+
+            // Pitch automation (in semitones), applied as frequency multiplier
+            let pitch_semi = crate::core::audio::engine::helpers::eval_env_map(
+                &pitch_env,
+                (i as f32) / (total_samples as f32),
+                0.0,
+            );
+            let current_freq = current_freq * (2.0_f32).powf(pitch_semi / 12.0);
+
+            // Slide
+            let current_amp = if slide {
+                amp_start + ((amp_end - amp_start) * (i as f32)) / (total_samples as f32)
+            } else {
+                amp_start
+            };
+
+            let mut value =
+                crate::core::audio::engine::helpers::oscillator_sample(&waveform, current_freq, t);
+
+            // ADSR envelope
+            let envelope = crate::core::audio::engine::helpers::adsr_envelope_value(
+                i,
+                attack_samples,
+                decay_samples,
+                sustain_samples,
+                release_samples,
+                sustain_level,
+            );
+
+            // Fade in/out
+            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 {
+                    // ensure last sample becomes exactly zero to avoid clicks
+                    value *= ((total_samples - 1 - i) as f32) / ((fade_len - 1) as f32);
+                }
+            }
+
+            value *= envelope;
+            let mut sample_val = value * (i16::MAX as f32) * current_amp;
+
+            let vol_mul = crate::core::audio::engine::helpers::eval_env_map(
+                &volume_env,
+                (i as f32) / (total_samples as f32),
+                1.0,
+            )
+            .clamp(0.0, 10.0);
+            sample_val *= vol_mul;
+
+            let pan_val = crate::core::audio::engine::helpers::eval_env_map(
+                &pan_env,
+                (i as f32) / (total_samples as f32),
+                0.0,
+            )
+            .clamp(-1.0, 1.0);
+            let (left_gain, right_gain) = crate::core::audio::engine::helpers::pan_gains(pan_val);
+
+            let left = (sample_val * left_gain)
+                .round()
+                .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+            let right = (sample_val * right_gain)
+                .round()
+                .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+
+            stereo_samples.push(left);
+            stereo_samples.push(right);
+        }
+
+        // Increment note counter for diagnostics
+        self.note_count = self.note_count.saturating_add(1);
+
+        crate::core::audio::engine::helpers::mix_stereo_samples_into_buffer(
+            self,
+            start_sample,
+            channels,
+            &stereo_samples,
+        );
+    }
+
+    // helper extraction functions left in this struct for now
+    fn extract_f32(&self, map: &HashMap<String, Value>, key: &str) -> Option<f32> {
+        match map.get(key) {
+            Some(Value::Number(n)) => Some(*n),
+            Some(Value::String(s)) => s.parse::<f32>().ok(),
+            Some(Value::Boolean(b)) => Some(if *b { 1.0 } else { 0.0 }),
+            _ => None,
+        }
+    }
+
+    fn extract_boolean(&self, map: &HashMap<String, Value>, key: &str) -> Option<bool> {
+        match map.get(key) {
+            Some(Value::Boolean(b)) => Some(*b),
+            Some(Value::Number(n)) => Some(*n != 0.0),
+            Some(Value::Identifier(s)) => {
+                if s == "true" {
+                    Some(true)
+                } else if s == "false" {
+                    Some(false)
+                } else {
+                    None
+                }
+            }
+            Some(Value::String(s)) => {
+                if s == "true" {
+                    Some(true)
+                } else if s == "false" {
+                    Some(false)
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }
+}

package/rust/core/audio/evaluator.rs

@@ -1,31 +1,310 @@
-use crate::core::{ shared::value::Value, store::variable::VariableTable };
-
-pub fn evaluate_condition_string(expr: &str, vars: &VariableTable) -> bool {
-    let tokens: Vec<&str> = expr.split_whitespace().collect();
-    if tokens.len() != 3 {
-        return false;
-    }
-
-    let left = tokens[0];
-    let op = tokens[1];
-    let right = tokens[2];
-
-    let left_val = match vars.get(left) {
-        Some(Value::Number(n)) => *n,
-        _ => {
-            return false;
-        }
-    };
-
-    let right_val: f32 = right.parse().unwrap_or(0.0);
-
-    match op {
-        ">" => left_val > right_val,
-        "<" => left_val < right_val,
-        ">=" => left_val >= right_val,
-        "<=" => left_val <= right_val,
-        "==" => (left_val - right_val).abs() < f32::EPSILON,
-        "!=" => (left_val - right_val).abs() > f32::EPSILON,
-        _ => false,
-    }
-}
+use crate::core::audio::special::{
+    find_and_eval_first_easing_call, find_and_eval_first_math_call, find_and_eval_first_mod_call,
+    resolve_env_atom,
+};
+use crate::core::store::variable::VariableTable;
+use devalang_types::Value;
+
+pub fn evaluate_condition_string(expr: &str, vars: &VariableTable) -> bool {
+    let tokens: Vec<&str> = expr.split_whitespace().collect();
+    if tokens.len() != 3 {
+        return false;
+    }
+
+    let left = tokens[0];
+    let op = tokens[1];
+    let right = tokens[2];
+
+    // Resolve left and right to numeric values where possible. Accept numbers, variables or env atoms.
+    fn resolve_for_cond(s: &str, vars: &VariableTable) -> Option<f32> {
+        if let Ok(n) = s.parse::<f32>() {
+            return Some(n);
+        }
+        if let Some(Value::Number(n)) = vars.get(s) {
+            return Some(*n);
+        }
+        if let Some(v) = resolve_env_atom(s, 120.0, 1.0) {
+            return Some(v);
+        }
+        None
+    }
+
+    let left_val = match resolve_for_cond(left, vars) {
+        Some(v) => v,
+        None => return false,
+    };
+
+    let right_val = match resolve_for_cond(right, vars) {
+        Some(v) => v,
+        None => return false,
+    };
+
+    match op {
+        ">" => left_val > right_val,
+        "<" => left_val < right_val,
+        ">=" => left_val >= right_val,
+        "<=" => left_val <= right_val,
+        "==" => {
+            // relative epsilon for floating comparisons
+            let diff = (left_val - right_val).abs();
+            let largest = left_val.abs().max(right_val.abs()).max(1.0);
+            diff <= (f32::EPSILON * largest)
+        }
+        "!=" => {
+            let diff = (left_val - right_val).abs();
+            let largest = left_val.abs().max(right_val.abs()).max(1.0);
+            diff > (f32::EPSILON * largest)
+        }
+        _ => false,
+    }
+}
+
+// Very small expression evaluator for `$env.*`, `$math.*` and variables.
+// Supports: +, -, *, / and simple parentheses, left-to-right (no precedence), and $math.(sin|cos)(expr)
+pub fn evaluate_numeric_expression(
+    expr: &str,
+    vars: &VariableTable,
+    env_bpm: f32,
+    env_beat: f32,
+) -> Option<f32> {
+    let expr = expr.replace(" ", "");
+
+    // Helper to resolve an atom to a number
+    fn resolve_atom(atom: &str, vars: &VariableTable, bpm: f32, beat: f32) -> Option<f32> {
+        if let Some(v) = resolve_env_atom(atom, bpm, beat) {
+            return Some(v);
+        }
+        if let Ok(n) = atom.parse::<f32>() {
+            return Some(n);
+        }
+        if let Some(Value::Number(n)) = vars.get(atom) {
+            return Some(*n);
+        }
+        None
+    }
+
+    // Shunting-like, simplified: first evaluate any $math.func(...) calls anywhere in the expression,
+    // then fold remaining parentheses and evaluate left-to-right.
+    fn eval(expr: &str, vars: &VariableTable, bpm: f32, beat: f32) -> Option<f32> {
+        // 1) Replace $math/$easing/$mod calls progressively with a max iteration guard
+        let mut s = expr.to_string();
+        let mut iterations = 0u32;
+        const MAX_ITER: u32 = 64;
+
+        // Evaluate modulators first (they may feed easing/math)
+        while iterations < MAX_ITER {
+            if let Some(next) =
+                find_and_eval_first_mod_call(&s, evaluate_numeric_expression, vars, bpm, beat)
+            {
+                s = next;
+                iterations += 1;
+                continue;
+            }
+            break;
+        }
+
+        iterations = 0;
+        while iterations < MAX_ITER {
+            if let Some(next) =
+                find_and_eval_first_easing_call(&s, evaluate_numeric_expression, vars, bpm, beat)
+            {
+                s = next;
+                iterations += 1;
+                continue;
+            }
+            break;
+        }
+
+        iterations = 0;
+        while iterations < MAX_ITER {
+            if let Some(next) =
+                find_and_eval_first_math_call(&s, evaluate_numeric_expression, vars, bpm, beat)
+            {
+                s = next;
+                iterations += 1;
+                continue;
+            }
+            break;
+        }
+
+        // 2) Evaluate remaining (pure) parentheses starting from innermost
+        if let Some(open) = s.rfind('(') {
+            if let Some(close_rel) = s[open..].find(')') {
+                // index relatif
+                let close = open + close_rel;
+                let inner = &s[open + 1..close];
+                let val = eval(inner, vars, bpm, beat)?;
+                let mut replaced = String::new();
+                replaced.push_str(&s[..open]);
+                replaced.push_str(&val.to_string());
+                replaced.push_str(&s[close + 1..]);
+                return eval(&replaced, vars, bpm, beat);
+            }
+        }
+
+        // Tokenize by operators left-to-right
+        let mut parts: Vec<String> = Vec::new();
+        let mut cur = String::new();
+        for ch in s.chars() {
+            if "+-*/".contains(ch) {
+                if !cur.is_empty() {
+                    parts.push(cur.clone());
+                    cur.clear();
+                }
+                parts.push(ch.to_string());
+            } else {
+                cur.push(ch);
+            }
+        }
+        if !cur.is_empty() {
+            parts.push(cur);
+        }
+        if parts.is_empty() {
+            return None;
+        }
+
+        // Resolve atoms and compute
+        let mut acc: Option<f32> = None;
+        let mut op: Option<char> = None;
+        for part in parts {
+            if part.len() == 1 && "+-*/".contains(part.chars().next().unwrap()) {
+                op = part.chars().next();
+                continue;
+            }
+            let val = if let Some(v) = resolve_atom(&part, vars, bpm, beat) {
+                v
+            } else if part.starts_with("$env.") {
+                // $env atom not handled by resolve_atom (when composed), try recursive eval
+                eval(&part, vars, bpm, beat)?
+            } else {
+                return None;
+            };
+
+            acc = Some(match (acc, op) {
+                (None, _) => val,
+                (Some(a), Some('+')) => a + val,
+                (Some(a), Some('-')) => a - val,
+                (Some(a), Some('*')) => a * val,
+                (Some(a), Some('/')) => {
+                    if val != 0.0 {
+                        a / val
+                    } else {
+                        return Some(f32::INFINITY);
+                    }
+                }
+                (Some(_), None) => val,
+                _ => {
+                    return None;
+                }
+            });
+        }
+
+        acc
+    }
+
+    eval(&expr, vars, env_bpm, env_beat)
+}
+
+pub fn evaluate_rhs_into_value(
+    raw: &str,
+    vars: &VariableTable,
+    env_bpm: f32,
+    env_beat: f32,
+) -> Value {
+    if let Some(num) = evaluate_numeric_expression(raw, vars, env_bpm, env_beat) {
+        Value::Number(num)
+    } else {
+        Value::String(raw.to_string())
+    }
+}
+
+// Evaluate a simple string concatenation expression like: "hello " + name + "!" + $env.beat
+// - Splits on + outside quotes
+// - Terms can be string literals (double quotes), variables (Number/String/Boolean), or numeric env/math expressions
+// Returns None if parsing fails (fallback to raw print)
+pub fn evaluate_string_expression(
+    expr: &str,
+    vars: &VariableTable,
+    env_bpm: f32,
+    env_beat: f32,
+) -> Option<String> {
+    // Quick reject if no '+' present
+    if !expr.contains('+') {
+        return None;
+    }
+
+    // Split by '+' outside of quotes
+    let mut parts: Vec<String> = Vec::new();
+    let mut cur = String::new();
+    let mut in_quotes = false;
+    let mut escape = false;
+    for ch in expr.chars() {
+        if escape {
+            cur.push(ch);
+            escape = false;
+            continue;
+        }
+        if ch == '\\' {
+            // escape next char
+            escape = true;
+            continue;
+        }
+        if ch == '"' {
+            in_quotes = !in_quotes;
+            cur.push(ch);
+            continue;
+        }
+        if ch == '+' && !in_quotes {
+            parts.push(cur.to_string());
+            cur.clear();
+            continue;
+        }
+        cur.push(ch);
+    }
+    if !cur.is_empty() {
+        parts.push(cur.to_string());
+    }
+    if parts.is_empty() {
+        return None;
+    }
+
+    // Resolve each part into a string
+    fn strip_quotes(s: &str) -> Option<String> {
+        let st = s.trim();
+        if st.len() >= 2 && st.starts_with('"') && st.ends_with('"') {
+            Some(st[1..st.len() - 1].to_string())
+        } else {
+            None
+        }
+    }
+
+    let mut out = String::new();
+    for p in parts {
+        if p.is_empty() {
+            continue;
+        }
+        if let Some(lit) = strip_quotes(&p) {
+            out.push_str(&lit);
+            continue;
+        }
+        // Try variables first
+        if let Some(val) = vars.get(&p) {
+            match val {
+                Value::String(s) => out.push_str(s),
+                Value::Number(n) => out.push_str(&format!("{}", n)),
+                Value::Boolean(b) => out.push_str(&format!("{}", b)),
+                other => out.push_str(&format!("{:?}", other)),
+            }
+            continue;
+        }
+        // Try env/math/numeric expression for this term
+        if let Some(n) = evaluate_numeric_expression(&p, vars, env_bpm, env_beat) {
+            out.push_str(&format!("{}", n));
+            continue;
+        }
+        // Bareword not resolved: include as-is (safe fallback)
+        out.push_str(&p);
+    }
+
+    Some(out)
+}