@devaloop/devalang 0.0.1-beta.3 → 0.1.2

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

@@ -1,294 +0,0 @@
-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

@@ -1,300 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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,
-        );
-    }
-}