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

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

@@ -1,169 +1,169 @@
-use crate::core::audio::engine::driver::MidiNoteEvent;
-use std::fs::File;
-
-pub fn generate_midi_file_impl(
-    midi_events: &Vec<MidiNoteEvent>,
-    output_path: &String,
-    bpm: Option<f32>,
-    tpqn: Option<u16>,
-) -> Result<(), String> {
-    use midly::num::{u7, u15, u24};
-    use midly::{
-        Format, Header, MetaMessage, MidiMessage, Smf, Timing, TrackEvent, TrackEventKind,
-    };
-
-    if midi_events.is_empty() {
-        return Ok(());
-    }
-
-    let bpm = bpm.unwrap_or(120.0_f32);
-    let tpqn: u16 = tpqn.unwrap_or(480u16);
-    let header = Header {
-        format: Format::SingleTrack,
-        timing: Timing::Metrical(u15::from(tpqn)),
-    };
-
-    #[derive(Clone)]
-    struct AbsEvent {
-        tick: u64,
-        kind: TrackEventKind<'static>,
-    }
-
-    let mut abs_events: Vec<AbsEvent> = Vec::new();
-    let microsecs_per_quarter = (60_000_000.0 / bpm) as u32;
-    abs_events.push(AbsEvent {
-        tick: 0,
-        kind: TrackEventKind::Meta(MetaMessage::Tempo(u24::from(microsecs_per_quarter))),
-    });
-
-    for ev in midi_events {
-        let start_secs = (ev.start_ms as f32) / 1000.0;
-        let dur_secs = (ev.duration_ms as f32) / 1000.0;
-        let start_ticks_f = start_secs * (bpm / 60.0) * (tpqn as f32);
-        let dur_ticks_f = dur_secs * (bpm / 60.0) * (tpqn as f32);
-        let start_tick = start_ticks_f.max(0.0).round() as u64;
-        let off_tick = (start_ticks_f + dur_ticks_f).max(start_tick as f32).round() as u64;
-
-        let key = u7::from(ev.key.min(127));
-        let vel = u7::from(ev.vel.min(127));
-
-        abs_events.push(AbsEvent {
-            tick: start_tick,
-            kind: TrackEventKind::Midi {
-                channel: (ev.channel as u8).into(),
-                message: MidiMessage::NoteOn { key, vel },
-            },
-        });
-
-        abs_events.push(AbsEvent {
-            tick: off_tick,
-            kind: TrackEventKind::Midi {
-                channel: (ev.channel as u8).into(),
-                message: MidiMessage::NoteOff {
-                    key,
-                    vel: u7::from(0),
-                },
-            },
-        });
-    }
-
-    let max_tick = abs_events.iter().map(|e| e.tick).max().unwrap_or(0);
-    abs_events.push(AbsEvent {
-        tick: max_tick + 0,
-        kind: TrackEventKind::Meta(MetaMessage::EndOfTrack),
-    });
-    abs_events.sort_by_key(|e| e.tick);
-
-    let mut track: Vec<TrackEvent> = Vec::new();
-    let mut last_tick: u64 = 0;
-    for e in abs_events {
-        let delta = (e.tick - last_tick) as u32;
-        track.push(TrackEvent {
-            delta: delta.into(),
-            kind: e.kind,
-        });
-        last_tick = e.tick;
-    }
-
-    let smf = Smf {
-        header,
-        tracks: vec![track],
-    };
-
-    if let Ok(mut file) = File::create(output_path) {
-        if let Err(e) = smf.write_std(&mut file) {
-            return Err(format!("Error writing MIDI file: {}", e));
-        }
-    } else {
-        return Err(format!("Cannot create MIDI file at {}", output_path));
-    }
-
-    Ok(())
-}
-
-pub fn generate_wav_file_impl(
-    buffer: &mut Vec<i16>,
-    output_dir: &String,
-    audio_format: Option<String>,
-    sample_rate: Option<u32>,
-) -> Result<(), String> {
-    if buffer.len() % (crate::core::audio::engine::CHANNELS as usize) != 0 {
-        buffer.push(0);
-    }
-
-    let sr = sample_rate.unwrap_or(crate::core::audio::engine::SAMPLE_RATE);
-    let format_str = audio_format.unwrap_or_else(|| "Wav16".to_string());
-    let fmt_low = format_str.to_lowercase();
-
-    match fmt_low.as_str() {
-        "wav16" => {
-            let spec = hound::WavSpec {
-                channels: crate::core::audio::engine::CHANNELS,
-                sample_rate: sr,
-                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 buffer.iter() {
-                writer
-                    .write_sample(*sample)
-                    .map_err(|e| format!("Error writing sample: {:?}", e))?;
-            }
-
-            writer
-                .finalize()
-                .map_err(|e| format!("Error finalizing WAV: {:?}", e))?;
-        }
-        "wav24" | "wav32" => {
-            let bits = if fmt_low.contains("24") { 24 } else { 32 };
-            let spec = hound::WavSpec {
-                channels: crate::core::audio::engine::CHANNELS,
-                sample_rate: sr,
-                bits_per_sample: bits,
-                sample_format: hound::SampleFormat::Int,
-            };
-
-            let mut writer = hound::WavWriter::create(output_dir, spec)
-                .map_err(|e| format!("Error creating WAV file: {}", e))?;
-
-            for &s in buffer.iter() {
-                let v32 = (s as i32) << (bits - 16);
-                writer
-                    .write_sample(v32)
-                    .map_err(|e| format!("Error writing sample: {:?}", e))?;
-            }
-
-            writer
-                .finalize()
-                .map_err(|e| format!("Error finalizing WAV: {:?}", e))?;
-        }
-        _ => {
-            return Err(format!("Unsupported audio format: {}", format_str));
-        }
-    }
-
-    Ok(())
-}
+use crate::core::audio::engine::driver::MidiNoteEvent;
+use std::fs::File;
+
+pub fn generate_midi_file_impl(
+    midi_events: &Vec<MidiNoteEvent>,
+    output_path: &String,
+    bpm: Option<f32>,
+    tpqn: Option<u16>,
+) -> Result<(), String> {
+    use midly::num::{u7, u15, u24};
+    use midly::{
+        Format, Header, MetaMessage, MidiMessage, Smf, Timing, TrackEvent, TrackEventKind,
+    };
+
+    if midi_events.is_empty() {
+        return Ok(());
+    }
+
+    let bpm = bpm.unwrap_or(120.0_f32);
+    let tpqn: u16 = tpqn.unwrap_or(480u16);
+    let header = Header {
+        format: Format::SingleTrack,
+        timing: Timing::Metrical(u15::from(tpqn)),
+    };
+
+    #[derive(Clone)]
+    struct AbsEvent {
+        tick: u64,
+        kind: TrackEventKind<'static>,
+    }
+
+    let mut abs_events: Vec<AbsEvent> = Vec::new();
+    let microsecs_per_quarter = (60_000_000.0 / bpm) as u32;
+    abs_events.push(AbsEvent {
+        tick: 0,
+        kind: TrackEventKind::Meta(MetaMessage::Tempo(u24::from(microsecs_per_quarter))),
+    });
+
+    for ev in midi_events {
+        let start_secs = (ev.start_ms as f32) / 1000.0;
+        let dur_secs = (ev.duration_ms as f32) / 1000.0;
+        let start_ticks_f = start_secs * (bpm / 60.0) * (tpqn as f32);
+        let dur_ticks_f = dur_secs * (bpm / 60.0) * (tpqn as f32);
+        let start_tick = start_ticks_f.max(0.0).round() as u64;
+        let off_tick = (start_ticks_f + dur_ticks_f).max(start_tick as f32).round() as u64;
+
+        let key = u7::from(ev.key.min(127));
+        let vel = u7::from(ev.vel.min(127));
+
+        abs_events.push(AbsEvent {
+            tick: start_tick,
+            kind: TrackEventKind::Midi {
+                channel: (ev.channel as u8).into(),
+                message: MidiMessage::NoteOn { key, vel },
+            },
+        });
+
+        abs_events.push(AbsEvent {
+            tick: off_tick,
+            kind: TrackEventKind::Midi {
+                channel: (ev.channel as u8).into(),
+                message: MidiMessage::NoteOff {
+                    key,
+                    vel: u7::from(0),
+                },
+            },
+        });
+    }
+
+    let max_tick = abs_events.iter().map(|e| e.tick).max().unwrap_or(0);
+    abs_events.push(AbsEvent {
+        tick: max_tick + 0,
+        kind: TrackEventKind::Meta(MetaMessage::EndOfTrack),
+    });
+    abs_events.sort_by_key(|e| e.tick);
+
+    let mut track: Vec<TrackEvent> = Vec::new();
+    let mut last_tick: u64 = 0;
+    for e in abs_events {
+        let delta = (e.tick - last_tick) as u32;
+        track.push(TrackEvent {
+            delta: delta.into(),
+            kind: e.kind,
+        });
+        last_tick = e.tick;
+    }
+
+    let smf = Smf {
+        header,
+        tracks: vec![track],
+    };
+
+    if let Ok(mut file) = File::create(output_path) {
+        if let Err(e) = smf.write_std(&mut file) {
+            return Err(format!("Error writing MIDI file: {}", e));
+        }
+    } else {
+        return Err(format!("Cannot create MIDI file at {}", output_path));
+    }
+
+    Ok(())
+}
+
+pub fn generate_wav_file_impl(
+    buffer: &mut Vec<i16>,
+    output_dir: &String,
+    audio_format: Option<String>,
+    sample_rate: Option<u32>,
+) -> Result<(), String> {
+    if buffer.len() % (crate::core::audio::engine::CHANNELS as usize) != 0 {
+        buffer.push(0);
+    }
+
+    let sr = sample_rate.unwrap_or(crate::core::audio::engine::SAMPLE_RATE);
+    let format_str = audio_format.unwrap_or_else(|| "Wav16".to_string());
+    let fmt_low = format_str.to_lowercase();
+
+    match fmt_low.as_str() {
+        "wav16" => {
+            let spec = hound::WavSpec {
+                channels: crate::core::audio::engine::CHANNELS,
+                sample_rate: sr,
+                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 buffer.iter() {
+                writer
+                    .write_sample(*sample)
+                    .map_err(|e| format!("Error writing sample: {:?}", e))?;
+            }
+
+            writer
+                .finalize()
+                .map_err(|e| format!("Error finalizing WAV: {:?}", e))?;
+        }
+        "wav24" | "wav32" => {
+            let bits = if fmt_low.contains("24") { 24 } else { 32 };
+            let spec = hound::WavSpec {
+                channels: crate::core::audio::engine::CHANNELS,
+                sample_rate: sr,
+                bits_per_sample: bits,
+                sample_format: hound::SampleFormat::Int,
+            };
+
+            let mut writer = hound::WavWriter::create(output_dir, spec)
+                .map_err(|e| format!("Error creating WAV file: {}", e))?;
+
+            for &s in buffer.iter() {
+                let v32 = (s as i32) << (bits - 16);
+                writer
+                    .write_sample(v32)
+                    .map_err(|e| format!("Error writing sample: {:?}", e))?;
+            }
+
+            writer
+                .finalize()
+                .map_err(|e| format!("Error finalizing WAV: {:?}", e))?;
+        }
+        _ => {
+            return Err(format!("Unsupported audio format: {}", format_str));
+        }
+    }
+
+    Ok(())
+}

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

@@ -1,56 +1,56 @@
-pub mod driver;
-pub mod export;
-pub mod helpers;
-pub mod notes;
-pub mod sample;
-
-pub use driver::AudioEngine;
-
-pub use driver::CHANNELS;
-pub use driver::MidiNoteEvent;
-pub use driver::SAMPLE_RATE;
-pub use helpers::*;
-
-use crate::core::audio::interpreter::driver::run_audio_program;
-use crate::core::parser::statement::Statement;
-use crate::core::store::global::GlobalStore;
-use devalang_types::{FunctionTable, VariableTable};
-use std::collections::HashMap;
-
-/// Render audio for a set of parsed modules.
-///
-/// For each entry in `modules` (module path -> statements), create an
-/// AudioEngine, setup empty module-local VariableTable and FunctionTable,
-/// invoke the interpreter driver to schedule audio into the engine, and
-/// return a map of module name -> AudioEngine.
-pub fn render_audio_with_modules(
-    modules: HashMap<String, Vec<Statement>>,
-    _output_dir: &str,
-    global_store: &mut GlobalStore,
-) -> HashMap<String, AudioEngine> {
-    let mut result: HashMap<String, AudioEngine> = HashMap::new();
-
-    for (module_name, statements) in modules.into_iter() {
-        // Create engine named after module (used for diagnostics)
-        let mut engine = AudioEngine::new(module_name.clone());
-
-        // Create empty module-local tables; interpreter expects these as starting context
-        let module_vars = VariableTable::new();
-        let module_funcs = FunctionTable::new();
-
-        // Run interpreter which will populate the engine.buffer and midi events
-        let (_max_end_time, _cursor_time) = run_audio_program(
-            &statements,
-            &mut engine,
-            module_name.clone(),
-            module_name.clone(),
-            module_vars,
-            module_funcs,
-            global_store,
-        );
-
-        result.insert(module_name, engine);
-    }
-
-    result
-}
+pub mod driver;
+pub mod export;
+pub mod helpers;
+pub mod notes;
+pub mod sample;
+
+pub use driver::AudioEngine;
+
+pub use driver::CHANNELS;
+pub use driver::MidiNoteEvent;
+pub use driver::SAMPLE_RATE;
+pub use helpers::*;
+
+use crate::core::audio::interpreter::driver::run_audio_program;
+use crate::core::parser::statement::Statement;
+use crate::core::store::global::GlobalStore;
+use devalang_types::{FunctionTable, VariableTable};
+use std::collections::HashMap;
+
+/// Render audio for a set of parsed modules.
+///
+/// For each entry in `modules` (module path -> statements), create an
+/// AudioEngine, setup empty module-local VariableTable and FunctionTable,
+/// invoke the interpreter driver to schedule audio into the engine, and
+/// return a map of module name -> AudioEngine.
+pub fn render_audio_with_modules(
+    modules: HashMap<String, Vec<Statement>>,
+    _output_dir: &str,
+    global_store: &mut GlobalStore,
+) -> HashMap<String, AudioEngine> {
+    let mut result: HashMap<String, AudioEngine> = HashMap::new();
+
+    for (module_name, statements) in modules.into_iter() {
+        // Create engine named after module (used for diagnostics)
+        let mut engine = AudioEngine::new(module_name.clone());
+
+        // Create empty module-local tables; interpreter expects these as starting context
+        let module_vars = VariableTable::new();
+        let module_funcs = FunctionTable::new();
+
+        // Run interpreter which will populate the engine.buffer and midi events
+        let (_max_end_time, _cursor_time) = run_audio_program(
+            &statements,
+            &mut engine,
+            module_name.clone(),
+            module_name.clone(),
+            module_vars,
+            module_funcs,
+            global_store,
+        );
+
+        result.insert(module_name, engine);
+    }
+
+    result
+}

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

@@ -1,85 +1,88 @@
-use crate::core::audio::engine::notes::params::NoteSetup;
-use devalang_types::Value;
-use std::collections::HashMap;
-
-pub fn render_notes_into_buffer(
-    engine: &mut crate::core::audio::engine::AudioEngine,
-    _waveform: &str,
-    _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>>,
-    setup: NoteSetup,
-) {
-    use crate::core::audio::engine::helpers;
-
-    let sample_rate = setup.sample_rate;
-    let channels = setup.channels;
-    let total_samples = setup.total_samples;
-    let start_sample = setup.start_sample;
-
-    let mut stereo_samples: Vec<i16> = Vec::with_capacity(total_samples * channels);
-    let fade_len = (sample_rate * 0.01) as usize; // 10ms fade
-
-    for i in 0..total_samples {
-        let t = ((start_sample + i) as f32) / sample_rate;
-
-        // simplified voice/unison and oscillator sampling
-        let mut value = helpers::oscillator_sample(_waveform, _freq, t);
-
-        // apply ADSR envelope
-        let envelope = helpers::adsr_envelope_value(
-            i,
-            setup.attack_samples,
-            setup.decay_samples,
-            if total_samples > setup.attack_samples + setup.decay_samples + setup.release_samples {
-                total_samples - setup.attack_samples - setup.decay_samples - setup.release_samples
-            } else {
-                0
-            },
-            setup.release_samples,
-            setup.sustain_level,
-        );
-
-        value *= envelope * (i16::MAX as f32) * _amp;
-
-        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 {
-                value *= ((total_samples - 1 - i) as f32) / ((fade_len - 1) as f32);
-            }
-        }
-
-        let (left_gain, right_gain) = helpers::pan_gains(0.0);
-        let left = (value * left_gain)
-            .round()
-            .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
-        let right = (value * right_gain)
-            .round()
-            .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
-
-        // push samples interleaved for channels=2, fallback zeros for other channel counts
-        if channels >= 2 {
-            stereo_samples.push(left);
-            stereo_samples.push(right);
-        } else if channels == 1 {
-            stereo_samples.push(((left as i32 + right as i32) / 2) as i16);
-        } else {
-            stereo_samples.push(left);
-            stereo_samples.push(right);
-        }
-    }
-
-    engine.note_count = engine.note_count.saturating_add(1);
-    helpers::mix_stereo_samples_into_buffer(engine, start_sample, channels, &stereo_samples);
-}
+use crate::core::audio::engine::notes::params::NoteSetup;
+use devalang_types::Value;
+use std::collections::HashMap;
+
+pub fn render_notes_into_buffer(
+    engine: &mut crate::core::audio::engine::AudioEngine,
+    _waveform: &str,
+    _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>>,
+    setup: NoteSetup,
+) -> Vec<(usize, usize)> {
+    use crate::core::audio::engine::helpers;
+
+    let sample_rate = setup.sample_rate;
+    let channels = setup.channels;
+    let total_samples = setup.total_samples;
+    let start_sample = setup.start_sample;
+
+    let mut stereo_samples: Vec<i16> = Vec::with_capacity(total_samples * channels);
+    let fade_len = (sample_rate * 0.01) as usize; // 10ms fade
+
+    for i in 0..total_samples {
+        let t = ((start_sample + i) as f32) / sample_rate;
+
+        // simplified voice/unison and oscillator sampling
+        let mut value = helpers::oscillator_sample(_waveform, _freq, t);
+
+        // apply ADSR envelope
+        let envelope = helpers::adsr_envelope_value(
+            i,
+            setup.attack_samples,
+            setup.decay_samples,
+            if total_samples > setup.attack_samples + setup.decay_samples + setup.release_samples {
+                total_samples - setup.attack_samples - setup.decay_samples - setup.release_samples
+            } else {
+                0
+            },
+            setup.release_samples,
+            setup.sustain_level,
+        );
+
+        value *= envelope * (i16::MAX as f32) * _amp;
+
+        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 {
+                value *= ((total_samples - 1 - i) as f32) / ((fade_len - 1) as f32);
+            }
+        }
+
+        let (left_gain, right_gain) = helpers::pan_gains(0.0);
+        let left = (value * left_gain)
+            .round()
+            .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+        let right = (value * right_gain)
+            .round()
+            .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+
+        // push samples interleaved for channels=2, fallback zeros for other channel counts
+        if channels >= 2 {
+            stereo_samples.push(left);
+            stereo_samples.push(right);
+        } else if channels == 1 {
+            stereo_samples.push(((left as i32 + right as i32) / 2) as i16);
+        } else {
+            stereo_samples.push(left);
+            stereo_samples.push(right);
+        }
+    }
+
+    engine.note_count = engine.note_count.saturating_add(1);
+    helpers::mix_stereo_samples_into_buffer(engine, start_sample, channels, &stereo_samples);
+
+    // Return the inserted sample range for this note (start_sample, total_samples)
+    vec![(start_sample, stereo_samples.len())]
+}