@devaloop/devalang 0.0.1-beta.3 → 0.1.1

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

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

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

@@ -1,56 +0,0 @@
-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,88 +0,0 @@
-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())]
-}

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

@@ -1,53 +0,0 @@
-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,
-    owner: Option<String>,
-    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>>,
-) -> Vec<(usize, usize)> {
-    let setup = params::build_note_setup(
-        engine,
-        &waveform,
-        freq,
-        amp,
-        start_time_ms,
-        duration_ms,
-        &synth_params,
-        &note_params,
-        &automation,
-    );
-
-    let ranges = dsp::render_notes_into_buffer(
-        engine,
-        &waveform,
-        freq,
-        amp,
-        start_time_ms,
-        duration_ms,
-        synth_params,
-        note_params,
-        automation,
-        setup,
-    );
-
-    if let Some(owner_name) = owner {
-        for (start, len) in ranges.iter() {
-            engine.record_last_note_range(&owner_name, *start, *len);
-        }
-    }
-
-    ranges
-}