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

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

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

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

@@ -0,0 +1,7 @@
+pub mod helpers;
+pub mod sample;
+pub mod synth;
+
+pub use synth::AudioEngine;
+
+pub use helpers::*;

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

@@ -0,0 +1,366 @@
+use crate::core::{store::variable::VariableTable, utils::path::normalize_path};
+use devalang_types::Value;
+use rodio::{Decoder, Source};
+use std::{collections::HashMap, fs::File, io::BufReader, path::Path};
+
+const SAMPLE_RATE: u32 = 44100;
+const CHANNELS: u16 = 2;
+
+impl super::synth::AudioEngine {
+    pub fn insert_sample(
+        &mut self,
+        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(&self.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,
+            };
+
+            // Determine the bank audio base directory. Prefer an optional
+            // `audioPath` declared in the bank's bank.toml (supports keys
+            // `audioPath` or `audio_path`). If absent, fall back to `audio/`.
+            let mut audio_dir = deva_dir.join(subdir).join(bank_name).join("audio");
+            // Try to read bank.toml to get audioPath
+            let bank_toml = deva_dir.join(subdir).join(bank_name).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())
+                        {
+                            // normalize separators
+                            let ap_norm = ap.replace("\\", "/");
+                            audio_dir = deva_dir.join(subdir).join(bank_name).join(ap_norm);
+                        }
+                    }
+                }
+            }
+            // Force looking into the computed audio_dir. If the entity_name
+            // already contains an extension (e.g. .wav/.mp3) or a nested path,
+            // preserve it as-is. Otherwise, try with a .wav extension.
+            let bank_base = audio_dir;
+            let candidate = bank_base.join(&entity_name);
+
+            if candidate.exists() {
+                resolved_path = candidate.to_string_lossy().to_string();
+            } else {
+                // Detect whether the provided entity already includes an extension.
+                let has_extension = std::path::Path::new(&entity_name).extension().is_some();
+
+                if !has_extension {
+                    // Try appending .wav as a fallback for shorthand names without extension
+                    let wav_candidate = bank_base.join(format!("{}.wav", entity_name));
+                    if wav_candidate.exists() {
+                        resolved_path = wav_candidate.to_string_lossy().to_string();
+                    } else {
+                        // Last resort: use the legacy location (no audio/), also with .wav
+                        resolved_path = deva_dir
+                            .join(subdir)
+                            .join(bank_name)
+                            .join(format!("{}.wav", entity_name))
+                            .to_string_lossy()
+                            .to_string();
+                    }
+                } else {
+                    // If an extension was specified, don't append .wav; try legacy location
+                    let legacy_candidate = deva_dir.join(subdir).join(bank_name).join(&entity_name);
+
+                    if legacy_candidate.exists() {
+                        resolved_path = legacy_candidate.to_string_lossy().to_string();
+                    } else {
+                        // No file found; fall back to the audio candidate path (even if missing)
+                        resolved_path = candidate.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 max_frames = (dur_sec * (SAMPLE_RATE as f32)) 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 as f32) * (CHANNELS as f32)) as usize;
+        let required_len = offset + samples.len() * (CHANNELS as usize);
+        if self.buffer.len() < required_len {
+            self.buffer.resize(required_len, 0);
+        }
+
+        if let Some(effects_map) = effects {
+            self.pad_samples(&samples, time_secs, Some(effects_map));
+        } else {
+            self.pad_samples(&samples, time_secs, None);
+        }
+    }
+
+    fn pad_samples(
+        &mut self,
+        samples: &[i16],
+        time_secs: f32,
+        effects_map: Option<HashMap<String, Value>>,
+    ) {
+        let offset = (time_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
+        let total_samples = samples.len();
+
+        let mut gain = 1.0;
+        let mut pan = 0.0;
+        let mut fade_in = 0.0;
+        let mut fade_out = 0.0;
+        let mut pitch = 1.0;
+        let mut drive = 0.0;
+        let mut reverb = 0.0;
+        let mut delay = 0.0; // delay time in seconds
+        let delay_feedback = 0.35; // default feedback
+
+        if let Some(map) = &effects_map {
+            for (key, val) in map {
+                match (key.as_str(), val) {
+                    ("gain", Value::Number(v)) => {
+                        gain = *v;
+                    }
+                    ("pan", Value::Number(v)) => {
+                        pan = *v;
+                    }
+                    ("fadeIn", Value::Number(v)) => {
+                        fade_in = *v;
+                    }
+                    ("fadeOut", Value::Number(v)) => {
+                        fade_out = *v;
+                    }
+                    ("pitch", Value::Number(v)) => {
+                        pitch = *v;
+                    }
+                    ("drive", Value::Number(v)) => {
+                        drive = *v;
+                    }
+                    ("reverb", Value::Number(v)) => {
+                        reverb = *v;
+                    }
+                    ("delay", Value::Number(v)) => {
+                        delay = *v;
+                    }
+                    _ => eprintln!("⚠️ Unknown or invalid effect '{}'", key),
+                }
+            }
+        }
+
+        let fade_in_samples = (fade_in * (SAMPLE_RATE as f32)) as usize;
+        let fade_out_samples = (fade_out * (SAMPLE_RATE as f32)) as usize;
+
+        // If no fade specified, apply a tiny default fade (2 ms) when sample boundaries are non-zero
+        let default_boundary_fade_ms = 1.0_f32; // 1 ms
+        let default_fade_samples = (default_boundary_fade_ms * (SAMPLE_RATE as f32)) as usize;
+        let mut effective_fade_in = fade_in_samples;
+        let mut effective_fade_out = fade_out_samples;
+        if effective_fade_in == 0 {
+            if let Some(&first) = samples.first() {
+                if first.abs() > 64 {
+                    // increased threshold to detect only strong abrupt starts
+                    effective_fade_in = default_fade_samples.max(1);
+                }
+            }
+        }
+        if effective_fade_out == 0 {
+            if let Some(&last) = samples.last() {
+                if last.abs() > 64 {
+                    // increased threshold to detect only strong abrupt ends
+                    effective_fade_out = default_fade_samples.max(1);
+                }
+            }
+        }
+
+        // Ensure fades do not exceed half the sample length to avoid silencing short samples
+        if total_samples > 0 {
+            let cap = total_samples / 2;
+            if effective_fade_in > cap {
+                effective_fade_in = cap.max(1);
+            }
+            if effective_fade_out > cap {
+                effective_fade_out = cap.max(1);
+            }
+        }
+
+        let delay_samples = if delay > 0.0 {
+            (delay * (SAMPLE_RATE as f32)) as usize
+        } else {
+            0
+        };
+        let mut delay_buffer: Vec<f32> = vec![0.0; total_samples + delay_samples];
+
+        for i in 0..total_samples {
+            let pitch_index = if pitch != 1.0 {
+                ((i as f32) / pitch) as usize
+            } else {
+                i
+            };
+
+            let mut adjusted = if pitch_index < total_samples {
+                samples[pitch_index] as f32
+            } else {
+                0.0
+            };
+
+            adjusted *= gain;
+
+            if effective_fade_in > 0 && i < effective_fade_in {
+                if effective_fade_in == 1 {
+                    adjusted *= 0.0;
+                } else {
+                    adjusted *= (i as f32) / (effective_fade_in as f32);
+                }
+            }
+            if effective_fade_out > 0 && i >= total_samples.saturating_sub(effective_fade_out) {
+                if effective_fade_out == 1 {
+                    adjusted *= 0.0;
+                } else {
+                    adjusted *=
+                        ((total_samples - 1 - i) as f32) / ((effective_fade_out - 1) as f32);
+                }
+            }
+
+            if drive > 0.0 {
+                let normalized = adjusted / (i16::MAX as f32);
+                let pre_gain = (10f32).powf(drive / 20.0);
+                let driven = (normalized * pre_gain).tanh();
+                adjusted = driven * (i16::MAX as f32);
+            }
+
+            if delay_samples > 0 && i >= delay_samples {
+                let echo = delay_buffer[i - delay_samples] * delay_feedback;
+                adjusted += echo;
+            }
+            if delay_samples > 0 {
+                delay_buffer[i] = adjusted;
+            }
+
+            if reverb > 0.0 {
+                let reverb_delay = (0.03 * (SAMPLE_RATE as f32)) as usize;
+                if i >= reverb_delay {
+                    adjusted += (self.buffer[offset + i - reverb_delay] as f32) * reverb;
+                }
+            }
+
+            let adjusted_sample = adjusted.round().clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+
+            let (left_gain, right_gain) = crate::core::audio::engine::helpers::pan_gains(pan);
+
+            let left = ((adjusted_sample as f32) * left_gain) as i16;
+            let right = ((adjusted_sample as f32) * right_gain) as i16;
+
+            let left_pos = offset + i * 2;
+            let right_pos = left_pos + 1;
+
+            if right_pos < self.buffer.len() {
+                self.buffer[left_pos] = self.buffer[left_pos].saturating_add(left);
+                self.buffer[right_pos] = self.buffer[right_pos].saturating_add(right);
+            }
+        }
+    }
+}