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

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

@@ -0,0 +1,220 @@
+use devalang_types::Value;
+use std::collections::HashMap;
+
+// Minimal representation of a MIDI note event for export purposes.
+#[derive(Debug, Clone, PartialEq)]
+pub struct MidiNoteEvent {
+    /// MIDI key number 0-127
+    pub key: u8,
+    /// velocity 0-127
+    pub vel: u8,
+    /// start time in milliseconds (absolute)
+    pub start_ms: u32,
+    /// duration in milliseconds
+    pub duration_ms: u32,
+    /// MIDI channel (0-15)
+    pub channel: u8,
+}
+
+// Sample rate and channel constants used throughout the engine.
+pub const SAMPLE_RATE: u32 = 44100;
+pub 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>,
+    /// Collected MIDI note events for export (non-audio representation).
+    pub midi_events: Vec<MidiNoteEvent>,
+    /// Logical module name used for error traces/diagnostics.
+    pub module_name: String,
+    /// Simple diagnostic counter for inserted notes.
+    pub note_count: usize,
+    /// Sample rate (can be overridden per-engine)
+    pub sample_rate: u32,
+    /// Number of channels (interleaved). Defaults to 2.
+    pub channels: u16,
+}
+
+impl AudioEngine {
+    pub fn new(module_name: String) -> Self {
+        AudioEngine {
+            volume: 1.0,
+            buffer: vec![],
+            midi_events: Vec::new(),
+            module_name,
+            note_count: 0,
+            sample_rate: SAMPLE_RATE,
+            channels: CHANNELS,
+        }
+    }
+
+    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 * (self.sample_rate as f32) * (self.channels as f32)) as usize;
+
+        if self.buffer.len() < total_samples {
+            self.buffer.resize(total_samples, 0);
+        }
+    }
+
+    pub fn generate_midi_file(
+        &mut self,
+        output_path: &String,
+        bpm: Option<f32>,
+        tpqn: Option<u16>,
+    ) -> Result<(), String> {
+        crate::core::audio::engine::export::generate_midi_file_impl(
+            &self.midi_events,
+            output_path,
+            bpm,
+            tpqn,
+        )
+    }
+
+    pub fn generate_wav_file(
+        &mut self,
+        output_dir: &String,
+        audio_format: Option<String>,
+        sample_rate: Option<u32>,
+    ) -> Result<(), String> {
+        crate::core::audio::engine::export::generate_wav_file_impl(
+            &mut self.buffer,
+            output_dir,
+            audio_format,
+            sample_rate,
+        )
+    }
+
+    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>>,
+    ) {
+        // Delegated implementation lives in notes.rs
+        crate::core::audio::engine::notes::insert_note_impl(
+            self,
+            waveform,
+            freq,
+            amp,
+            start_time_ms,
+            duration_ms,
+            synth_params,
+            note_params,
+            automation,
+        );
+    }
+
+    // helper extraction functions left in this struct for now
+    pub(crate) 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,
+        }
+    }
+
+    pub(crate) 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,
+        }
+    }
+}
+
+// Parse simple musical fraction strings like "1/16" into seconds using bpm
+pub fn parse_fraction_to_seconds(s: &str, bpm: f32) -> Option<f32> {
+    let trimmed = s.trim();
+    if let Some((num, den)) = trimmed.split_once('/') {
+        if let (Ok(n), Ok(d)) = (num.parse::<f32>(), den.parse::<f32>()) {
+            if d != 0.0 {
+                let beats = n / d; // e.g. 1/16 -> 0.0625 beats
+                let secs_per_beat = 60.0 / bpm.max(1.0);
+                return Some(beats * secs_per_beat);
+            }
+        }
+    }
+    None
+}
+
+// Convert a devalang_types::Duration to seconds using bpm when relevant.
+pub fn duration_to_seconds(d: &devalang_types::Duration, bpm: f32) -> Option<f32> {
+    use devalang_types::Duration as D;
+    match d {
+        D::Number(s) => Some(*s),
+        D::Beat(frac) | D::Identifier(frac) => parse_fraction_to_seconds(frac, bpm),
+        _ => None,
+    }
+}

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