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

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

@@ -1,325 +0,0 @@
-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/interpreter/arrow_call.rs

@@ -1,311 +0,0 @@
-use crate::core::{
-    audio::engine::AudioEngine,
-    parser::statement::{Statement, StatementKind},
-    plugin::runner::WasmPluginRunner,
-    store::{global::GlobalStore, variable::VariableTable},
-};
-use devalang_types::Value;
-use devalang_utils::logger::{LogLevel, Logger};
-
-use std::collections::HashMap;
-
-pub fn interprete_call_arrow_statement(
-    stmt: &Statement,
-    audio_engine: &mut AudioEngine,
-    variable_table: &VariableTable,
-    global_store: &GlobalStore,
-    base_bpm: f32,
-    base_duration: f32,
-    max_end_time: &mut f32,
-    mut cursor_time: Option<&mut f32>,
-    update_cursor: bool,
-) -> (f32, f32) {
-    let cursor_copy = cursor_time.as_ref().map(|c| **c).unwrap_or(0.0);
-
-    if let StatementKind::ArrowCall {
-        target,
-        method,
-        args,
-    } = &stmt.kind
-    {
-        let Some(Value::Statement(synth_stmt)) = variable_table.get(target) else {
-            let logger = Logger::new();
-            logger.log_message(
-                LogLevel::Error,
-                &format!("Synth '{}' not found in variable table", target),
-            );
-            return (*max_end_time, cursor_copy);
-        };
-
-        let Value::Map(synth_map) = &synth_stmt.value else {
-            let logger = Logger::new();
-            logger.log_message(
-                LogLevel::Error,
-                &format!("Invalid synth statement for '{}', expected a map.", target),
-            );
-            return (*max_end_time, cursor_copy);
-        };
-
-        let Some(Value::String(entity)) = synth_map.get("entity") else {
-            let logger = Logger::new();
-            logger.log_message(
-                LogLevel::Error,
-                &format!("Missing 'entity' key in synth '{}'.", target),
-            );
-            return (*max_end_time, cursor_copy);
-        };
-
-        if entity != "synth" {
-            let logger = Logger::new();
-            logger.log_message(
-                LogLevel::Error,
-                &format!("'{}' is not a synth, entity is '{}'.", target, entity),
-            );
-            return (*max_end_time, cursor_copy);
-        }
-
-        let Some(Value::Map(value_map)) = synth_map.get("value") else {
-            let logger = Logger::new();
-            logger.log_message(
-                LogLevel::Error,
-                &format!("Missing 'value' map in synth '{}'.", target),
-            );
-            return (*max_end_time, cursor_copy);
-        };
-
-        let waveform_str = match value_map.get("waveform") {
-            Some(Value::String(s)) => s.clone(),
-            Some(Value::Identifier(s)) => s.clone(),
-            _ => {
-                let logger = Logger::new();
-                logger.log_message(
-                    LogLevel::Error,
-                    &format!("Missing or invalid 'waveform' in synth '{}'.", target),
-                );
-                return (*max_end_time, cursor_copy);
-            }
-        };
-        let Some(Value::Map(params)) = value_map.get("parameters") else {
-            println!("❌ Missing or invalid 'parameters' in synth '{}'.", target);
-            return (*max_end_time, cursor_copy);
-        };
-
-        // Synth parameters
-        let synth_params = params.clone();
-        let amp = extract_f32(&synth_params, "amp", base_bpm).unwrap_or(1.0);
-
-        if method == "note" {
-            let filtered_args: Vec<_> = args
-                .iter()
-                .filter(|arg| !matches!(arg, Value::Unknown))
-                .collect();
-
-            let Some(Value::Identifier(note_name)) = filtered_args.first().map(|v| (*v).clone())
-            else {
-                println!(
-                    "❌ Invalid or missing argument for 'note' method on '{}'.",
-                    target
-                );
-                return (*max_end_time, cursor_copy);
-            };
-
-            let mut note_params = HashMap::new();
-            if let Some(arg1) = filtered_args.get(1) {
-                if let Value::Map(map) = (*arg1).clone() {
-                    for (key, value) in map {
-                        note_params.insert(key, value);
-                    }
-                }
-            }
-
-            // Note parameters and calculations
-            let amp_note = extract_f32(&note_params, "amp", base_bpm).unwrap_or(amp);
-            let duration_ms =
-                extract_f32(&note_params, "duration", base_bpm).unwrap_or(base_duration * 1000.0);
-
-            let duration_secs = duration_ms / 1000.0;
-            let final_freq = note_to_freq(&note_name);
-            let start_time = cursor_copy;
-            let end_time = start_time + duration_secs;
-
-            // Fetch automation map if present:
-            // - Global (per-synth): key "<target>__automation" => map with key "params"
-            // - Per-note: note parameter "automate" => map
-            let auto_key = format!("{}__automation", target);
-            let synth_automation = match variable_table.get(&auto_key) {
-                Some(Value::Map(map)) => match map.get("params") {
-                    Some(Value::Map(p)) => Some(p.clone()),
-                    _ => None,
-                },
-                _ => None,
-            };
-
-            let note_automation = match note_params.get("automate") {
-                Some(Value::Map(m)) => Some(m.clone()),
-                _ => None,
-            };
-
-            // Merge: per-note overrides synth automation per key (volume/pan/pitch)
-            let automation = match (synth_automation, note_automation) {
-                (Some(mut a), Some(n)) => {
-                    for (k, v) in n {
-                        a.insert(k, v);
-                    }
-                    Some(a)
-                }
-                (None, Some(n)) => Some(n),
-                (Some(a), None) => Some(a),
-                _ => None,
-            };
-
-            // If waveform references a plugin alias (e.g., alias.synth), use the WASM plugin runner
-            if waveform_str.contains('.') && waveform_str.ends_with(".synth") {
-                let alias = waveform_str.split('.').next().unwrap_or("");
-                if let Some(Value::String(uri)) = variable_table.get(alias) {
-                    if let Some(id) = uri.strip_prefix("devalang://plugin/") {
-                        let mut parts = id.split('.');
-                        let author = parts.next().unwrap_or("");
-                        let name = parts.next().unwrap_or("");
-                        let key = format!("{}:{}", author, name);
-                        if let Some((_info, wasm_bytes)) = global_store.plugins.get(&key) {
-                            // Prepare buffer (stereo f32)
-                            let sample_rate = 44100.0_f32;
-                            let total_samples = ((duration_ms / 1000.0) * sample_rate) as usize;
-                            let channels = 2usize;
-                            let start_index = ((start_time * sample_rate) as usize) * channels;
-                            let required_len = start_index + total_samples * channels;
-                            if audio_engine.buffer.len() < required_len {
-                                audio_engine.buffer.resize(required_len, 0);
-                            }
-                            let mut fbuf = vec![0.0f32; total_samples * channels];
-                            let runner = WasmPluginRunner::new();
-                            let mut params_num: std::collections::HashMap<String, f32> =
-                                std::collections::HashMap::new();
-                            let mut params_str: std::collections::HashMap<String, String> =
-                                std::collections::HashMap::new();
-                            for (k, v) in synth_params.iter() {
-                                match v {
-                                    Value::Number(n) => {
-                                        params_num.insert(k.clone(), *n);
-                                    }
-                                    Value::String(s) => {
-                                        params_str.insert(k.clone(), s.clone());
-                                    }
-                                    Value::Identifier(s) => {
-                                        params_str.insert(k.clone(), s.clone());
-                                    }
-                                    _ => {}
-                                }
-                            }
-                            let _ = runner.render_note_with_params_in_place(
-                                wasm_bytes,
-                                &mut fbuf,
-                                None,
-                                final_freq,
-                                amp_note,
-                                duration_ms as i32,
-                                44100,
-                                2,
-                                &params_num,
-                                Some(&params_str),
-                            );
-                            for (i, sample) in
-                                fbuf.iter().enumerate().take(total_samples * channels)
-                            {
-                                let s = (sample.clamp(-1.0, 1.0) * (i16::MAX as f32)) as i16;
-                                let idx = start_index + i;
-                                audio_engine.buffer[idx] =
-                                    audio_engine.buffer[idx].saturating_add(s);
-                            }
-                        } else {
-                            let logger = Logger::new();
-                            logger.log_message(
-                                LogLevel::Warning,
-                                &format!(
-                                    "Plugin bytes not found for key '{}' (alias '{}').",
-                                    key, alias
-                                ),
-                            );
-                        }
-                    } else {
-                        let logger = Logger::new();
-                        logger.log_message(
-                            LogLevel::Warning,
-                            &format!("Invalid plugin URI in alias '{}': {}", alias, uri),
-                        );
-                    }
-                } else {
-                    let logger = Logger::new();
-                    logger.log_message(
-                        LogLevel::Warning,
-                        &format!("Plugin alias '{}' not found in variable table.", alias),
-                    );
-                }
-            } else {
-                audio_engine.insert_note(
-                    waveform_str.clone(),
-                    final_freq,
-                    amp_note,
-                    start_time * 1000.0,
-                    duration_ms,
-                    synth_params,
-                    note_params,
-                    automation,
-                );
-            }
-
-            *max_end_time = (*max_end_time).max(end_time);
-
-            if update_cursor {
-                if let Some(c) = cursor_time.as_mut() {
-                    **c = end_time;
-                }
-            }
-
-            return (*max_end_time, end_time);
-        } else {
-            let logger = Logger::new();
-            logger.log_message(
-                LogLevel::Error,
-                &format!("Unknown method '{}' on synth '{}'.", method, target),
-            );
-        }
-    }
-
-    (*max_end_time, cursor_copy)
-}
-
-fn extract_f32(map: &HashMap<String, Value>, key: &str, base_bpm: f32) -> Option<f32> {
-    map.get(key).and_then(|v| match v {
-        Value::Number(n) => Some(*n),
-        Value::Beat(beat_str) => {
-            let parts: Vec<&str> = beat_str.split('/').collect();
-            if parts.len() == 2 {
-                let numerator = parts[0].parse::<f32>().ok()?;
-                let denominator = parts[1].parse::<f32>().ok()?;
-
-                Some((numerator / denominator) * ((60.0 / base_bpm) * 1000.0))
-            } else {
-                None
-            }
-        }
-        _ => None,
-    })
-}
-
-fn note_to_freq(note: &str) -> f32 {
-    let notes = [
-        "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B",
-    ];
-
-    if note.len() < 2 || note.len() > 3 {
-        return 440.0;
-    }
-
-    let (name, octave_str) = note.split_at(note.len() - 1);
-    let semitone = notes.iter().position(|&n| n == name).unwrap_or(9) as i32;
-    let octave = octave_str.parse::<i32>().unwrap_or(4);
-    let midi_note = (octave + 1) * 12 + semitone;
-
-    440.0 * (2.0_f32).powf(((midi_note as f32) - 69.0) / 12.0)
-}

package/rust/core/audio/renderer.rs

@@ -1,54 +0,0 @@
-use crate::core::{
-    audio::{engine::AudioEngine, interpreter::driver::run_audio_program},
-    parser::statement::Statement,
-    store::global::GlobalStore,
-};
-use devalang_utils::logger::{LogLevel, Logger};
-use std::collections::HashMap;
-
-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::new();
-
-    for (module_name, statements) in modules {
-        let mut global_max_end_time: f32 = 0.0;
-        let mut audio_engine = AudioEngine::new(module_name.clone());
-
-        // Apply global variables to the initial engine
-        if let Some(module) = global_store.get_module(&module_name) {
-            // interprete statements to fill the audio buffer
-            let (module_max_end_time, _cursor_time) = run_audio_program(
-                &statements,
-                &mut audio_engine,
-                module_name.clone(),
-                output_dir.to_string(),
-                module.variable_table.clone(),
-                module.function_table.clone(),
-                global_store,
-            );
-
-            // Verify if the buffer is silent (all samples are zero)
-            if audio_engine.buffer.iter().all(|&s| s == 0) {
-                let logger = Logger::new();
-                logger.log_message(
-                    LogLevel::Warning,
-                    &format!(
-                        "Module '{}' ignored: silent buffer (no non-zero samples)",
-                        module_name
-                    ),
-                );
-            }
-
-            // Determines the maximum end time for the module
-            global_max_end_time = global_max_end_time.max(module_max_end_time);
-            audio_engine.set_duration(global_max_end_time);
-
-            result.insert(module_name, audio_engine);
-        }
-    }
-
-    result
-}