@devaloop/devalang 0.0.1-alpha.12 → 0.0.1-alpha.13

package/rust/core/audio/engine.rs

@@ -1,11 +1,10 @@
 use std::{ collections::HashMap, fs::File, io::BufReader, path::Path };
 use hound::{ SampleFormat, WavSpec, WavWriter };
 use rodio::{ Decoder, Source };
-
 use crate::core::{
     shared::value::Value,
     store::variable::VariableTable,
-    utils::path::{ normalize_path, resolve_relative_path },
+    utils::path::normalize_path,
 };
 
 const SAMPLE_RATE: u32 = 44100;
@@ -14,7 +13,6 @@ const CHANNELS: u16 = 2;
 #[derive(Debug, Clone, PartialEq)]
 pub struct AudioEngine {
     pub volume: f32,
-    pub variables: VariableTable,
     pub buffer: Vec<i16>,
     pub module_name: String,
 }
@@ -24,7 +22,6 @@ impl AudioEngine {
         AudioEngine {
             volume: 1.0,
             buffer: vec![],
-            variables: VariableTable::new(),
             module_name,
         }
     }
@@ -57,12 +54,10 @@ impl AudioEngine {
 
         if self.buffer.iter().all(|&s| s == 0) {
             self.buffer = other.buffer;
-            self.variables.variables.extend(other.variables.variables);
             return;
         }
 
         self.mix(&other);
-        self.variables.variables.extend(other.variables.variables);
     }
 
     pub fn set_duration(&mut self, duration_secs: f32) {
@@ -73,10 +68,6 @@ impl AudioEngine {
         }
     }
 
-    pub fn set_variables(&mut self, variables: VariableTable) {
-        self.variables = variables;
-    }
-
     pub fn generate_wav_file(&mut self, output_dir: &String) -> Result<(), String> {
         if self.buffer.len() % (CHANNELS as usize) != 0 {
             self.buffer.push(0);
@@ -168,79 +159,122 @@ impl AudioEngine {
         filepath: &str,
         time_secs: f32,
         dur_sec: f32,
-        effects: Option<HashMap<String, Value>>
+        effects: Option<HashMap<String, Value>>,
+        variable_table: &VariableTable
     ) {
         if filepath.is_empty() {
             eprintln!("❌ Empty file path provided for audio sample.");
             return;
         }
 
+        let root = Path::new(env!("CARGO_MANIFEST_DIR"));
+        let module_root = Path::new(&self.module_name);
         let mut resolved_path = String::new();
 
-        if filepath.starts_with("devalang://") {
-            let root = Path::new(env!("CARGO_MANIFEST_DIR"));
-            let parts = filepath.split("devalang://").collect::<Vec<&str>>();
-            let object_parts = parts.get(1).unwrap_or(&"").split("/").collect::<Vec<&str>>();
-            let object_type = object_parts.get(0).unwrap_or(&"").to_lowercase();
-            let object_dir = object_parts.get(1).unwrap_or(&"").to_string();
-            let object_name = object_parts.get(2).unwrap_or(&"").to_string();
+        // Get the variable path from the variable table
+        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 it's a namespace
+        if var_path.contains(".") {
+            let parts: Vec<&str> = var_path.trim_start_matches('.').split('.').collect();
+            if parts.len() == 2 {
+                let bank_name = parts[0];
+                let entity_name = parts[1];
+
+                // Verifies if the bank is declared
+                if !variable_table.variables.contains_key(bank_name) {
+                    eprintln!(
+                        "❌ Bank '{}' not declared. Please declare it first using : 'bank {}'",
+                        bank_name,
+                        bank_name
+                    );
+                    return;
+                }
 
-            if object_type.contains("bank") {
                 resolved_path = root
                     .join(".deva")
                     .join("bank")
-                    .join(object_dir)
-                    .join(format!("{}.wav", object_name))
-                    .to_str()
-                    .unwrap_or("")
+                    .join(bank_name)
+                    .join(format!("{}.wav", entity_name))
+                    .to_string_lossy()
                     .to_string();
             } else {
-                eprintln!("❌ Unsupported devalang:// object type: {}", object_type);
+                eprintln!("❌ Invalid namespace format: {}", var_path);
                 return;
             }
-        } else {
-            let module_path = &self.module_name;
-            let root = Path::new(module_path).parent();
-
-            if let Some(root_path) = root {
-                resolved_path = root_path.join(filepath).to_str().unwrap_or("").to_string();
-            } else {
-                eprintln!("❌ Could not resolve root path for module: {}", module_path);
+        } else 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>/<bank>/<entity>"
+                );
                 return;
             }
+
+            let obj_type = parts[0];
+            let bank_name = parts[1];
+            let entity_name = parts[2];
+
+            resolved_path = root
+                .join(".deva")
+                .join(obj_type)
+                .join(bank_name)
+                .join(format!("{}.wav", entity_name))
+                .to_string_lossy()
+                .to_string();
+        } else {
+            // Else, resolve as a relative path
+            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());
         }
 
+        // Verify if the file exists
         if !Path::new(&resolved_path).exists() {
             eprintln!("❌ Audio file not found at: {}", resolved_path);
             return;
         }
 
-        let file = BufReader::new(
-            File::open(&resolved_path).expect(&format!("Failed to open audio file {}", filepath))
-        );
-        let decoder = Decoder::new(file).expect("Failed to decode audio file");
+        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;
+            }
+        };
 
-        // Mono or stereo reading possible here, we will duplicate in L/R
         let max_mono_samples = (dur_sec * (SAMPLE_RATE as f32)) as usize;
         let samples: Vec<i16> = decoder.convert_samples().take(max_mono_samples).collect();
 
         if samples.is_empty() {
-            eprintln!("No samples found in the audio file: {}", filepath);
+            eprintln!("❌ No samples read from {}", resolved_path);
             return;
         }
 
-        // Pad the buffer to ensure it can accommodate the new samples
+        // Calculate buffer offset and size
         let offset = (time_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
         let required_len = offset + samples.len() * (CHANNELS as usize);
-        let padded_required_len = if required_len % 2 == 1 {
-            required_len + 1
-        } else {
-            required_len
-        };
-
-        self.buffer.resize(padded_required_len, 0);
+        if self.buffer.len() < required_len {
+            self.buffer.resize(required_len, 0);
+        }
 
-        // Apply effects
+        // Apply effects and mix
         if let Some(effects_map) = effects {
             self.pad_samples(&samples, time_secs, Some(effects_map));
         } else {
@@ -263,8 +297,10 @@ impl AudioEngine {
         let mut fade_in = 0.0;
         let mut fade_out = 0.0;
         let mut pitch = 1.0;
-        let mut drive = 0.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 {
@@ -285,12 +321,14 @@ impl AudioEngine {
                         pitch = *v;
                     }
                     ("drive", Value::Number(v)) => {
-                        // Drive effect can be implemented here if needed
                         drive = *v;
                     }
                     ("reverb", Value::Number(v)) => {
                         reverb = *v;
                     }
+                    ("delay", Value::Number(v)) => {
+                        delay = *v;
+                    }
                     _ => eprintln!("⚠️ Unknown or invalid effect '{}'", key),
                 }
             }
@@ -299,49 +337,64 @@ impl AudioEngine {
         let fade_in_samples = (fade_in * (SAMPLE_RATE as f32)) as usize;
         let fade_out_samples = (fade_out * (SAMPLE_RATE as f32)) as usize;
 
-        for (i, &sample) in samples.iter().enumerate() {
-            // Gain
-            let mut adjusted = (sample as f32) * gain;
+        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];
 
-            // Fade in
+        for i in 0..total_samples {
+            // PITCH FIRST
+            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
+            };
+
+            // GAIN
+            adjusted *= gain;
+
+            // FADE IN/OUT
             if fade_in_samples > 0 && i < fade_in_samples {
                 adjusted *= (i as f32) / (fade_in_samples as f32);
             }
-
-            // Fade out
             if fade_out_samples > 0 && i >= total_samples.saturating_sub(fade_out_samples) {
                 adjusted *= ((total_samples - i) as f32) / (fade_out_samples as f32);
             }
 
-            // Pitch adjustment
-            if pitch != 1.0 {
-                let pitch_adjusted_index = ((i as f32) / pitch) as usize;
-                if pitch_adjusted_index < total_samples {
-                    adjusted = (samples[pitch_adjusted_index] as f32) * gain;
-                } else {
-                    adjusted = 0.0; // Out of bounds, set to zero
-                }
+            // DRIVE (soft)
+            if drive > 0.0 {
+                let normalized = adjusted / (i16::MAX as f32);
+                let pre_gain = (10f32).powf(drive / 20.0); // dB mapping
+                let driven = (normalized * pre_gain).tanh();
+                adjusted = driven * (i16::MAX as f32);
             }
 
-            // Drive effect
-            if drive > 0.0 {
-                adjusted = adjusted.tanh() * (1.0 + drive);
+            // DELAY
+            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;
             }
 
-            // Reverb effect
+            // REVERB
             if reverb > 0.0 {
-                let reverb_delay = (reverb * (SAMPLE_RATE as f32)) as usize;
+                let reverb_delay = (0.03 * (SAMPLE_RATE as f32)) as usize;
                 if i >= reverb_delay {
-                    adjusted += self.buffer[offset + i - reverb_delay] as f32 * 0.5; // Simple feedback
+                    adjusted += (self.buffer[offset + i - reverb_delay] as f32) * reverb;
                 }
             }
 
-            // Clamp
+            // CLAMP
             let adjusted_sample = adjusted.round().clamp(i16::MIN as f32, i16::MAX as f32) as i16;
 
-            // Pan (L/R split)
-            let left = ((adjusted_sample as f32) * (1.0 - pan.clamp(0.0, 1.0))) as i16;
-            let right = ((adjusted_sample as f32) * (1.0 + pan.clamp(-1.0, 0.0)).abs()) as i16;
+            // PAN
+            let left_gain = 1.0 - pan.max(0.0); // Pan > 0 => reduce left
+            let right_gain = 1.0 + pan.min(0.0); // Pan < 0 => reduce right
+
+            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;

package/rust/core/audio/interpreter/call.rs

@@ -1,70 +1,95 @@
 use crate::core::{
-    audio::{ engine::AudioEngine, interpreter::{ driver::execute_audio_block } },
-    parser::statement::{ Statement, StatementKind },
-    shared::{ duration::Duration, value::Value },
-    store::variable::VariableTable,
+    audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
+    parser::statement::{Statement, StatementKind},
+    shared::value::Value,
+    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
 };
 
 pub fn interprete_call_statement(
     stmt: &Statement,
-    audio_engine: AudioEngine,
-    variable_table: VariableTable,
+    audio_engine: &mut AudioEngine,
+    variable_table: &VariableTable,
+    functions: &FunctionTable,
+    global_store: &GlobalStore,
     base_bpm: f32,
     base_duration: f32,
     max_end_time: f32,
     cursor_time: f32,
-    all_statements: &Vec<Statement>
-) -> (AudioEngine, f32, f32, f32) {
-    match &stmt.value {
-        Value::String(identifier) | Value::Identifier(identifier) => {
-            if
-                let Some(group_stmt) = all_statements
-                    .iter()
-                    .find(|s| {
-                        matches!(s.kind, StatementKind::Group) &&
-                            s.value.get("identifier") == Some(&Value::String(identifier.clone()))
-                    })
-            {
-                if let Some(Value::Block(block)) = group_stmt.value.get("body") {
-                    let (eng, _, end_time) = execute_audio_block(
-                        audio_engine,
-                        variable_table,
-                        block.clone(),
-                        base_bpm,
-                        base_duration,
-                        max_end_time,
-                        cursor_time
+) -> (f32, f32) {
+    match &stmt.kind {
+        StatementKind::Call { name, args } => {
+            // ✅ 1. Cas : fonction classique
+            if let Some(func) = functions.functions.get(name) {
+                if func.parameters.len() != args.len() {
+                    eprintln!(
+                        "❌ Function '{}' expects {} args, got {}",
+                        name,
+                        func.parameters.len(),
+                        args.len()
                     );
-                    return (eng, max_end_time.max(end_time), end_time, cursor_time);
-                } else {
-                    eprintln!("❌ Group '{}' found but no valid body block", identifier);
+                    return (max_end_time, cursor_time);
+                }
+
+                let mut local_vars = VariableTable::with_parent(variable_table.clone());
+                for (param, arg) in func.parameters.iter().zip(args) {
+                    local_vars.set(param.clone(), arg.clone());
                 }
-            } else {
-                eprintln!("❌ Group '{}' not found in statements", identifier);
-            }
-        }
 
-        Value::Map(map) => {
-            if let Some(Value::Block(block)) = map.get("body") {
-                let (eng, _, end_time) = execute_audio_block(
+                return execute_audio_block(
                     audio_engine,
-                    variable_table,
-                    block.clone(),
+                    global_store,
+                    local_vars,
+                    functions.clone(),
+                    func.body.clone(),
                     base_bpm,
                     base_duration,
                     max_end_time,
-                    cursor_time
+                    cursor_time,
                 );
-                return (eng, max_end_time.max(end_time), end_time, cursor_time);
-            } else {
-                eprintln!("❌ Call map has no 'body' block");
             }
-        }
 
-        other => {
-            eprintln!("❌ Invalid call statement: expected identifier or map, found {:?}", other);
+            // ✅ 2. Cas : group dans le scope local OU global
+            if let Some(group_stmt) = find_group(name, variable_table, global_store) {
+                if let Value::Map(map) = &group_stmt.value {
+                    if let Some(Value::Block(body)) = map.get("body") {
+                        return execute_audio_block(
+                            audio_engine,
+                            global_store,
+                            variable_table.clone(),
+                            functions.clone(),
+                            body.clone(),
+                            base_bpm,
+                            base_duration,
+                            max_end_time,
+                            cursor_time,
+                        );
+                    }
+                }
+            }
+
+            eprintln!("❌ Function or group '{}' not found", name);
         }
+
+        _ => eprintln!("❌ interprete_call_statement expected Call, got {:?}", stmt.kind),
     }
 
-    (audio_engine, base_bpm, max_end_time, cursor_time)
+    (max_end_time, cursor_time)
+}
+
+fn find_group<'a>(
+    name: &str,
+    variable_table: &'a VariableTable,
+    global_store: &'a GlobalStore,
+) -> Option<&'a Statement> {
+    if let Some(Value::Statement(stmt_box)) = variable_table.get(name) {
+        if let StatementKind::Group = stmt_box.kind {
+            return Some(stmt_box);
+        }
+    }
+    if let Some(Value::Statement(stmt_box)) = global_store.variables.variables.get(name) {
+        if let StatementKind::Group = stmt_box.kind {
+            return Some(stmt_box);
+        }
+    }
+    None
 }

package/rust/core/audio/interpreter/condition.rs

@@ -6,20 +6,20 @@ use crate::core::{
     },
     parser::statement::Statement,
     shared::value::Value,
-    store::variable::VariableTable,
+    store::{ function::FunctionTable, global::GlobalStore, variable::VariableTable },
 };
 
 pub fn interprete_condition_statement(
     stmt: &Statement,
-    audio_engine: AudioEngine,
-    variable_table: VariableTable,
+    audio_engine: &mut AudioEngine,
+    global_store: &GlobalStore,
+    variable_table: &VariableTable,
+    functions_table: &FunctionTable,
     base_bpm: f32,
     base_duration: f32,
     max_end_time: f32,
     cursor_time: f32
-) -> (AudioEngine, f32, f32) {
-    let mut engine = audio_engine.clone();
-    let mut vars = variable_table.clone();
+) -> (f32, f32) {
     let mut cur_time = cursor_time;
     let mut max_time = max_end_time;
 
@@ -32,23 +32,25 @@ pub fn interprete_condition_statement(
 
         let should_execute = match map.get("condition") {
             Some(Value::Boolean(b)) => *b,
-            Some(Value::String(expr)) => evaluate_condition_string(expr, &vars),
+            Some(Value::String(expr)) => evaluate_condition_string(expr, &variable_table.clone()),
             Some(_) => false,
             None => true,
         };
 
         if should_execute {
             if let Some(Value::Block(block)) = map.get("body") {
-                let (new_engine, _, new_max) = execute_audio_block(
-                    engine,
-                    vars,
+                let (new_max, cursor_time) = execute_audio_block(
+                    audio_engine,
+                    global_store,
+                    variable_table.clone(),
+                    functions_table.clone(),
                     block.clone(),
                     base_bpm,
                     base_duration,
                     max_time,
                     cur_time
                 );
-                return (new_engine, new_max, new_max);
+                return (new_max, cursor_time);
             } else {
                 break;
             }
@@ -65,5 +67,5 @@ pub fn interprete_condition_statement(
         }
     }
 
-    (audio_engine, max_end_time, cursor_time)
+    (max_end_time, cursor_time)
 }