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

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

@@ -0,0 +1,294 @@
+use devalang_types::Value;
+use std::collections::HashMap;
+
+pub struct FilterSpec {
+    pub kind: String,
+    pub cutoff: f32,
+}
+
+pub struct FilterState {
+    pub prev_l: f32,
+    pub prev_r: f32,
+    pub prev_in_l: f32,
+    pub prev_in_r: f32,
+    pub prev_out_l: f32,
+    pub prev_out_r: f32,
+}
+
+pub struct NoteSetup {
+    pub sample_rate: f32,
+    pub channels: usize,
+    pub total_samples: usize,
+    pub start_sample: usize,
+    pub attack_samples: usize,
+    pub decay_samples: usize,
+    pub release_samples: usize,
+    pub sustain_level: f32,
+    pub pluck_click: f32,
+    pub pluck_click_samples: usize,
+    pub drive: f32,
+    pub filters: Vec<FilterSpec>,
+    pub filter_states: Vec<FilterState>,
+    pub lfo_rate: f32,
+    pub lfo_depth: f32,
+    pub lfo_target: Option<String>,
+    pub voices: usize,
+    pub unison_detune: f32,
+    pub volume_env: HashMap<String, Value>,
+    pub pan_env: HashMap<String, Value>,
+    pub pitch_env: HashMap<String, Value>,
+}
+
+pub fn build_note_setup(
+    engine: &mut crate::core::audio::engine::AudioEngine,
+    _waveform: &str,
+    freq: f32,
+    amp: f32,
+    start_time_ms: f32,
+    mut duration_ms: f32,
+    synth_params: &HashMap<String, Value>,
+    note_params: &HashMap<String, Value>,
+    automation: &Option<HashMap<String, Value>>,
+) -> NoteSetup {
+    use crate::core::audio::engine::helpers;
+
+    // Extract ADSR and normalize units
+    let attack = engine.extract_f32(synth_params, "attack").unwrap_or(0.0);
+    let decay = engine.extract_f32(synth_params, "decay").unwrap_or(0.0);
+    let sustain = engine.extract_f32(synth_params, "sustain").unwrap_or(1.0);
+    let release = engine.extract_f32(synth_params, "release").unwrap_or(0.0);
+    let _sustain_level = if sustain > 1.0 {
+        (sustain / 100.0).clamp(0.0, 1.0)
+    } else {
+        sustain.clamp(0.0, 1.0)
+    };
+
+    if let Some(g) = engine.extract_f32(note_params, "gate") {
+        if g > 0.0 && g <= 1.0 {
+            duration_ms = duration_ms * g;
+        } else if g > 1.0 {
+            duration_ms = duration_ms * (g / 100.0);
+        }
+    } else if let Some(g) = engine.extract_f32(synth_params, "gate") {
+        if g > 0.0 && g <= 1.0 {
+            duration_ms = duration_ms * g;
+        } else if g > 1.0 {
+            duration_ms = duration_ms * (g / 100.0);
+        }
+    }
+
+    let velocity = engine.extract_f32(note_params, "velocity").unwrap_or(1.0);
+
+    let detune_cents = engine
+        .extract_f32(note_params, "detune")
+        .or(engine.extract_f32(synth_params, "detune"))
+        .unwrap_or(0.0);
+
+    let _lowpass_cut = engine
+        .extract_f32(note_params, "lowpass")
+        .or(engine.extract_f32(synth_params, "lowpass"))
+        .unwrap_or(0.0);
+
+    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;
+
+    let glide = engine
+        .extract_boolean(note_params, "glide")
+        .unwrap_or(false);
+    let slide = engine
+        .extract_boolean(note_params, "slide")
+        .unwrap_or(false);
+    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 = engine.sample_rate as f32;
+    let channels = engine.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;
+
+    // MIDI event
+    let midi_note_f = 69.0 + 12.0 * (_freq_start / 440.0).log2();
+    let midi_note = midi_note_f.round().clamp(0.0, 127.0) as u8;
+    let midi_vel = (velocity.clamp(0.0, 1.0) * 127.0).round().clamp(0.0, 127.0) as u8;
+    engine
+        .midi_events
+        .push(crate::core::audio::engine::driver::MidiNoteEvent {
+            key: midi_note,
+            vel: midi_vel,
+            start_ms: start_time_ms as u32,
+            duration_ms: duration_ms as u32,
+            channel: 0,
+        });
+
+    let _detune_factor = (2.0_f32).powf(detune_cents / 1200.0);
+
+    let (_volume_env, _pan_env, _pitch_env) = helpers::env_maps_from_automation(automation);
+
+    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 = _sustain_level;
+
+    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;
+
+    // optional pluck click
+    let pluck_click = engine
+        .extract_f32(note_params, "pluck_click")
+        .or(engine.extract_f32(synth_params, "pluck_click"))
+        .unwrap_or(0.0);
+    let pluck_click_ms = engine
+        .extract_f32(note_params, "pluck_click_ms")
+        .or(engine.extract_f32(synth_params, "pluck_click_ms"))
+        .unwrap_or(10.0);
+    let pluck_click_samples = ((pluck_click_ms / 1000.0) * sample_rate) as usize;
+
+    let drive = engine
+        .extract_f32(note_params, "drive")
+        .or(engine.extract_f32(synth_params, "drive"))
+        .unwrap_or(0.0);
+
+    // parse filter specs
+    let mut raw_filters: Vec<HashMap<String, Value>> = Vec::new();
+    if let Some(Value::Array(arr)) = synth_params.get("filters") {
+        for v in arr {
+            if let Value::Map(m) = v {
+                raw_filters.push(m.clone());
+            }
+        }
+    }
+    if let Some(Value::Array(arr)) = note_params.get("filters") {
+        for v in arr {
+            if let Value::Map(m) = v {
+                raw_filters.push(m.clone());
+            }
+        }
+    }
+
+    let mut filters: Vec<FilterSpec> = Vec::new();
+    let mut filter_states: Vec<FilterState> = Vec::new();
+    for rf in raw_filters.into_iter() {
+        let kind = rf
+            .get("type")
+            .and_then(|v| match v {
+                Value::String(s) => Some(s.clone()),
+                Value::Identifier(s) => Some(s.clone()),
+                _ => None,
+            })
+            .unwrap_or_else(|| "lowpass".to_string());
+        let cutoff = rf
+            .get("cutoff")
+            .and_then(|v| match v {
+                Value::Number(n) => Some(*n),
+                Value::String(s) => s.parse::<f32>().ok(),
+                _ => None,
+            })
+            .unwrap_or(1000.0);
+        filters.push(FilterSpec {
+            kind: kind.to_lowercase(),
+            cutoff,
+        });
+        filter_states.push(FilterState {
+            prev_l: 0.0,
+            prev_r: 0.0,
+            prev_in_l: 0.0,
+            prev_in_r: 0.0,
+            prev_out_l: 0.0,
+            prev_out_r: 0.0,
+        });
+    }
+
+    // LFO parsing (from synth or note) - simplified: prefer note params over synth params
+    let mut lfo_rate = 0.0f32;
+    let mut lfo_depth = 0.0f32;
+    let mut lfo_target: Option<String> = None;
+    if let Some(Value::Map(m)) = synth_params.get("lfo") {
+        if let Some(Value::Number(r)) = m.get("rate") {
+            lfo_rate = *r;
+        }
+        if let Some(Value::Number(d)) = m.get("depth") {
+            lfo_depth = *d;
+        }
+        if let Some(Value::String(t)) = m.get("target") {
+            lfo_target = Some(t.clone());
+        }
+    }
+    if let Some(Value::Map(m)) = note_params.get("lfo") {
+        if let Some(Value::Number(r)) = m.get("rate") {
+            lfo_rate = *r;
+        }
+        if let Some(Value::Number(d)) = m.get("depth") {
+            lfo_depth = *d;
+        }
+        if let Some(Value::String(t)) = m.get("target") {
+            lfo_target = Some(t.clone());
+        }
+    }
+
+    let voices = engine
+        .extract_f32(note_params, "voices")
+        .or(engine.extract_f32(synth_params, "voices"))
+        .unwrap_or(1.0)
+        .max(1.0)
+        .round() as usize;
+    let unison_detune = engine
+        .extract_f32(note_params, "unison_detune")
+        .or(engine.extract_f32(synth_params, "unison_detune"))
+        .unwrap_or(0.0);
+
+    let (volume_env, pan_env, pitch_env) = (
+        helpers::env_map_to_hash(&_volume_env),
+        helpers::env_map_to_hash(&_pan_env),
+        helpers::env_map_to_hash(&_pitch_env),
+    );
+
+    NoteSetup {
+        sample_rate,
+        channels,
+        total_samples,
+        start_sample,
+        attack_samples,
+        decay_samples,
+        release_samples,
+        sustain_level,
+        pluck_click,
+        pluck_click_samples,
+        drive,
+        filters,
+        filter_states,
+        lfo_rate,
+        lfo_depth,
+        lfo_target,
+        voices,
+        unison_detune,
+        volume_env,
+        pan_env,
+        pitch_env,
+    }
+}

package/rust/core/audio/engine/sample/insert.rs

@@ -0,0 +1,300 @@
+use crate::config::ops::load_config;
+use devalang_types::Value;
+use devalang_types::VariableTable;
+use devalang_utils::path::normalize_path;
+use rodio::{Decoder, Source};
+use std::path::PathBuf;
+use std::{collections::HashMap, fs::File, io::BufReader, path::Path};
+
+pub fn insert_sample_impl(
+    engine: &mut crate::core::audio::engine::driver::AudioEngine,
+    filepath: &str,
+    time_secs: f32,
+    dur_sec: f32,
+    effects: Option<HashMap<String, Value>>,
+    variable_table: &VariableTable,
+) {
+    if filepath.is_empty() {
+        eprintln!("❌ Empty file path provided for audio sample.");
+        return;
+    }
+
+    let module_root = Path::new(&engine.module_name);
+    let root = match devalang_utils::path::get_project_root() {
+        Ok(p) => p,
+        Err(_) => std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from(".")),
+    };
+    let resolved_path: String;
+
+    let mut var_path = filepath.to_string();
+    if let Some(Value::String(variable_path)) = variable_table.variables.get(filepath) {
+        var_path = variable_path.clone();
+    } else if let Some(Value::Sample(sample_path)) = variable_table.variables.get(filepath) {
+        var_path = sample_path.clone();
+    }
+
+    if var_path.starts_with("devalang://") {
+        let path_after_protocol = var_path.replace("devalang://", "");
+        let parts: Vec<&str> = path_after_protocol.split('/').collect();
+
+        if parts.len() < 3 {
+            eprintln!(
+                "❌ Invalid devalang:// path format. Expected devalang://<type>/<author>.<bank>/<entity>"
+            );
+            return;
+        }
+
+        let obj_type = parts[0];
+        let bank_name = parts[1];
+        // Rejoin the remainder as the entity path so bank entries can contain
+        // nested paths like "subdir/sample.wav" or plain names.
+        let entity_name = parts[2..].join("/");
+
+        let deva_dir = match devalang_utils::path::get_deva_dir() {
+            Ok(dir) => dir,
+            Err(e) => {
+                eprintln!("❌ {}", e);
+                return;
+            }
+        };
+        let subdir = match obj_type {
+            "bank" => "banks",
+            "plugin" => "plugins",
+            "preset" => "presets",
+            "template" => "templates",
+            other => other,
+        };
+
+        // Try both plural and singular folder names (some installs use 'bank' instead of 'banks')
+        let singular = if subdir.ends_with('s') {
+            &subdir[..subdir.len() - 1]
+        } else {
+            subdir
+        };
+
+        // Build a list of candidate addon roots to support different layouts:
+        // - legacy flat: .deva/<subdir>/<publisher>.<name>
+        // - nested: .deva/<subdir>/<publisher>/<name>
+        // Test both plural and singular folder names.
+        let mut candidate_roots: Vec<PathBuf> = Vec::new();
+        for sd in &[subdir, singular] {
+            let base = deva_dir.join(sd).join(bank_name);
+            candidate_roots.push(base.clone());
+
+            if bank_name.contains('.') {
+                let mut it = bank_name.splitn(2, '.');
+                let pubr = it.next().unwrap_or("");
+                let nm = it.next().unwrap_or("");
+                candidate_roots.push(deva_dir.join(sd).join(pubr).join(nm));
+            }
+        }
+
+        // If none of the candidate roots yields the asset, we will also
+        // try to lookup referenced addons from the project config.
+
+        // Helper to resolve audio path for a given addon root
+        let resolve_from_root = |root: &PathBuf| -> Option<String> {
+            // Determine audio dir: prefer audioPath in bank.toml, else audio/
+            let mut audio_dir = root.join("audio");
+            let bank_toml = root.join("bank.toml");
+            if bank_toml.exists() {
+                if let Ok(content) = std::fs::read_to_string(&bank_toml) {
+                    if let Ok(parsed) = toml::from_str::<toml::Value>(&content) {
+                        if let Some(ap) = parsed
+                            .get("audioPath")
+                            .or_else(|| parsed.get("audio_path"))
+                            .and_then(|v| v.as_str())
+                        {
+                            let ap_norm = ap.replace("\\", "/");
+                            audio_dir = root.join(ap_norm);
+                        }
+                    }
+                }
+            }
+
+            let candidate = audio_dir.join(&entity_name);
+            if candidate.exists() {
+                return Some(candidate.to_string_lossy().to_string());
+            }
+
+            let has_extension = std::path::Path::new(&entity_name).extension().is_some();
+            if !has_extension {
+                let wav_candidate = audio_dir.join(format!("{}.wav", entity_name));
+                if wav_candidate.exists() {
+                    return Some(wav_candidate.to_string_lossy().to_string());
+                }
+
+                let legacy_candidate = root.join(format!("{}.wav", entity_name));
+                if legacy_candidate.exists() {
+                    return Some(legacy_candidate.to_string_lossy().to_string());
+                }
+            } else {
+                let legacy_candidate = root.join(&entity_name);
+                if legacy_candidate.exists() {
+                    return Some(legacy_candidate.to_string_lossy().to_string());
+                }
+            }
+
+            None
+        };
+
+        let mut found: Option<String> = None;
+        for root in &candidate_roots {
+            if let Some(p) = resolve_from_root(root) {
+                found = Some(p);
+                break;
+            }
+        }
+
+        // If not found in typical layouts, try to find the addon referenced in the project config
+        if found.is_none() {
+            if let Ok(config_path) = devalang_utils::path::get_devalang_config_path() {
+                if let Some(cfg) = load_config(Some(&config_path)) {
+                    // Scan banks or plugins depending on obj_type
+                    if obj_type == "bank" {
+                        if let Some(banks) = cfg.banks {
+                            for b in banks {
+                                if let Some(name_in_path) = b.path.strip_prefix("devalang://bank/")
+                                {
+                                    // match by exact, suffix, or dot notation
+                                    if name_in_path == bank_name
+                                        || name_in_path.ends_with(bank_name)
+                                    {
+                                        let root = deva_dir.join(subdir).join(name_in_path);
+                                        if let Some(p) = resolve_from_root(&root) {
+                                            found = Some(p);
+                                            break;
+                                        }
+                                        // try nested layout
+                                        if name_in_path.contains('.') {
+                                            let mut it = name_in_path.splitn(2, '.');
+                                            let pubr = it.next().unwrap_or("");
+                                            let nm = it.next().unwrap_or("");
+                                            let root2 = deva_dir.join(subdir).join(pubr).join(nm);
+                                            if let Some(p) = resolve_from_root(&root2) {
+                                                found = Some(p);
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    } else if obj_type == "plugin" {
+                        if let Some(plugins) = cfg.plugins {
+                            for p in plugins {
+                                if let Some(name_in_path) =
+                                    p.path.strip_prefix("devalang://plugin/")
+                                {
+                                    if name_in_path == bank_name
+                                        || name_in_path.ends_with(bank_name)
+                                    {
+                                        let root = deva_dir.join(subdir).join(name_in_path);
+                                        if let Some(path_found) = resolve_from_root(&root) {
+                                            found = Some(path_found);
+                                            break;
+                                        }
+                                        if name_in_path.contains('.') {
+                                            let mut it = name_in_path.splitn(2, '.');
+                                            let pubr = it.next().unwrap_or("");
+                                            let nm = it.next().unwrap_or("");
+                                            let root2 = deva_dir.join(subdir).join(pubr).join(nm);
+                                            if let Some(path_found) = resolve_from_root(&root2) {
+                                                found = Some(path_found);
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if let Some(p) = found {
+            resolved_path = p;
+        } else {
+            // Not found; fallback to legacy candidate for error message
+            let legacy = deva_dir
+                .join(subdir)
+                .join(bank_name)
+                .join(format!("{}.wav", entity_name));
+            resolved_path = legacy.to_string_lossy().to_string();
+        }
+    } else {
+        let entry_dir = module_root.parent().unwrap_or(&root);
+        let absolute_path = root.join(entry_dir).join(&var_path);
+
+        resolved_path = normalize_path(absolute_path.to_string_lossy().to_string());
+    }
+
+    if !Path::new(&resolved_path).exists() {
+        eprintln!("❌ Unknown trigger or missing audio file: {}", filepath);
+        return;
+    }
+
+    let file = match File::open(&resolved_path) {
+        Ok(f) => BufReader::new(f),
+        Err(e) => {
+            eprintln!("❌ Failed to open audio file {}: {}", resolved_path, e);
+            return;
+        }
+    };
+
+    let decoder = match Decoder::new(file) {
+        Ok(d) => d,
+        Err(e) => {
+            eprintln!("❌ Failed to decode audio file {}: {}", resolved_path, e);
+            return;
+        }
+    };
+
+    // Read frames from decoder and convert to mono if needed.
+    let sample_rate = engine.sample_rate as f32;
+    let channels = engine.channels as usize;
+
+    let max_frames = (dur_sec * sample_rate) as usize;
+    let dec_channels = decoder.channels() as usize;
+    let max_raw_samples = max_frames.saturating_mul(dec_channels.max(1));
+    let raw_samples: Vec<i16> = decoder.convert_samples().take(max_raw_samples).collect();
+
+    // Convert interleaved channels to mono by averaging channels per frame.
+    // Apply a small RMS-preserving scale so mono level is similar to mixed stereo.
+    let actual_frames = if dec_channels > 0 {
+        raw_samples.len() / dec_channels
+    } else {
+        0
+    };
+    let mut samples: Vec<i16> = Vec::with_capacity(actual_frames);
+    let rms_scale = (dec_channels as f32).sqrt();
+    for frame in 0..actual_frames {
+        let mut sum: i32 = 0;
+        for ch in 0..dec_channels {
+            sum += raw_samples[frame * dec_channels + ch] as i32;
+        }
+        if dec_channels > 0 {
+            let avg = (sum / (dec_channels as i32)) as f32;
+            let scaled = (avg * rms_scale).clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+            samples.push(scaled);
+        } else {
+            samples.push(0);
+        }
+    }
+
+    if samples.is_empty() {
+        eprintln!("❌ No samples read from {}", resolved_path);
+        return;
+    }
+
+    let offset = (time_secs * sample_rate * (channels as f32)) as usize;
+    let required_len = offset + samples.len() * (channels as usize);
+    if engine.buffer.len() < required_len {
+        engine.buffer.resize(required_len, 0);
+    }
+
+    crate::core::audio::engine::sample::padding::pad_samples_impl(
+        engine, &samples, time_secs, effects,
+    );
+}

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

@@ -0,0 +1,40 @@
+pub mod insert;
+pub mod padding;
+
+use devalang_types::Value;
+use devalang_types::VariableTable;
+use std::collections::HashMap;
+
+impl super::driver::AudioEngine {
+    pub fn insert_sample(
+        &mut self,
+        filepath: &str,
+        time_secs: f32,
+        dur_sec: f32,
+        effects: Option<HashMap<String, Value>>,
+        variable_table: &VariableTable,
+    ) {
+        crate::core::audio::engine::sample::insert::insert_sample_impl(
+            self,
+            filepath,
+            time_secs,
+            dur_sec,
+            effects,
+            variable_table,
+        );
+    }
+
+    pub fn pad_samples(
+        &mut self,
+        samples: &[i16],
+        time_secs: f32,
+        effects_map: Option<HashMap<String, Value>>,
+    ) {
+        crate::core::audio::engine::sample::padding::pad_samples_impl(
+            self,
+            samples,
+            time_secs,
+            effects_map,
+        );
+    }
+}