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

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

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

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,
-        }
-    }
-}