@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

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

@@ -0,0 +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(())
+}

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

@@ -0,0 +1,178 @@
+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)
+    }
+}
+
+/// Convert an Option<HashMap<..>> into a HashMap (empty if None).
+pub fn env_map_to_hash(opt: &Option<HashMap<String, Value>>) -> HashMap<String, Value> {
+    match opt {
+        Some(m) => m.clone(),
+        None => HashMap::new(),
+    }
+}
+
+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::driver::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,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
+}

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

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

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

@@ -0,0 +1,44 @@
+use devalang_types::Value;
+use std::collections::HashMap;
+
+pub mod dsp;
+pub mod params;
+
+// Minimal safe facade: parse the setup then call DSP renderer.
+
+pub fn insert_note_impl(
+    engine: &mut crate::core::audio::engine::AudioEngine,
+    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>>,
+) {
+    let setup = params::build_note_setup(
+        engine,
+        &waveform,
+        freq,
+        amp,
+        start_time_ms,
+        duration_ms,
+        &synth_params,
+        &note_params,
+        &automation,
+    );
+
+    dsp::render_notes_into_buffer(
+        engine,
+        &waveform,
+        freq,
+        amp,
+        start_time_ms,
+        duration_ms,
+        synth_params,
+        note_params,
+        automation,
+        setup,
+    );
+}