aetherdsp-nodes 0.2.4

//! ADSR envelope demonstration
//!
//! This example demonstrates:
//! - ADSR envelope (Attack, Decay, Sustain, Release)
//! - Gate triggering (note on/off)
//! - Envelope modulation of audio signal
//! - Multiple note triggers
//!
//! # Usage
//!
//! ```bash
//! cargo run --example envelope_test -p aetherdsp-nodes
//! ```
//!
//! Output: `envelope_test.wav` (6 seconds, 48kHz, mono)
//!
//! # What You'll Hear
//!
//! Three notes played with an ADSR envelope:
//! 1. Short note (0.5s gate)
//! 2. Medium note (1.0s gate)
//! 3. Long note (1.5s gate)
//!
//! Each note demonstrates the full ADSR cycle:
//! - Attack: 0.1s (fade in)
//! - Decay: 0.2s (drop to sustain level)
//! - Sustain: 0.7 level (held while gate is on)
//! - Release: 0.3s (fade out after gate off)

use aether_core::{
    command::Command, graph::DspGraph, param::Param, scheduler::Scheduler, BUFFER_SIZE,
};
use aether_nodes::{envelope::AdsrEnvelope, oscillator::Oscillator};
use hound::{WavSpec, WavWriter};
use ringbuf::{
    traits::{Producer, Split},
    HeapRb,
};

const SAMPLE_RATE: f32 = 48_000.0;
const DURATION_SECS: f32 = 6.0;
const TOTAL_SAMPLES: usize = (SAMPLE_RATE * DURATION_SECS) as usize;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🎵 ADSR Envelope Test");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!();
    println!("Rendering: Oscillator → ADSR Envelope → Output");
    println!("Duration: {} seconds", DURATION_SECS);
    println!("Sample Rate: {} Hz", SAMPLE_RATE);
    println!();

    // Create command ring buffer
    let (mut producer, mut consumer) = HeapRb::<Command>::new(1024).split();

    // Create scheduler and graph
    let mut scheduler = Scheduler::new(SAMPLE_RATE);
    let mut graph = DspGraph::new();

    // Build audio graph: oscillator → envelope → output
    println!("🔧 Building audio graph...");

    // Create oscillator (sine wave at 440 Hz)
    let osc = Box::new(Oscillator::new());
    let osc_id = graph.add_node(osc).expect("Failed to add oscillator");

    // Create ADSR envelope
    let envelope = Box::new(AdsrEnvelope::new());
    let env_id = graph.add_node(envelope).expect("Failed to add envelope");

    // Connect: oscillator → envelope input 0
    graph.connect(osc_id, env_id, 0);

    // Set envelope as output
    graph.set_output_node(env_id);

    // Send commands to scheduler
    producer.try_push(Command::AddNode { id: osc_id }).ok();
    producer.try_push(Command::AddNode { id: env_id }).ok();
    producer
        .try_push(Command::Connect {
            src: osc_id,
            dst: env_id,
            slot: 0,
        })
        .ok();
    producer
        .try_push(Command::SetOutputNode { id: env_id })
        .ok();

    // Set oscillator parameters: frequency=440Hz, amplitude=1.0, waveform=0 (sine)
    producer
        .try_push(Command::UpdateParam {
            node: osc_id,
            param_index: 0,
            new_param: Param::new(440.0), // frequency
        })
        .ok();
    producer
        .try_push(Command::UpdateParam {
            node: osc_id,
            param_index: 1,
            new_param: Param::new(1.0), // amplitude
        })
        .ok();
    producer
        .try_push(Command::UpdateParam {
            node: osc_id,
            param_index: 2,
            new_param: Param::new(0.0), // waveform (0=sine)
        })
        .ok();

    // Set envelope parameters: A=0.1s, D=0.2s, S=0.7, R=0.3s, gate=0
    producer
        .try_push(Command::UpdateParam {
            node: env_id,
            param_index: 0,
            new_param: Param::new(0.1), // attack
        })
        .ok();
    producer
        .try_push(Command::UpdateParam {
            node: env_id,
            param_index: 1,
            new_param: Param::new(0.2), // decay
        })
        .ok();
    producer
        .try_push(Command::UpdateParam {
            node: env_id,
            param_index: 2,
            new_param: Param::new(0.7), // sustain
        })
        .ok();
    producer
        .try_push(Command::UpdateParam {
            node: env_id,
            param_index: 3,
            new_param: Param::new(0.3), // release
        })
        .ok();
    producer
        .try_push(Command::UpdateParam {
            node: env_id,
            param_index: 4,
            new_param: Param::new(0.0), // gate (off)
        })
        .ok();

    println!("  ✅ Oscillator (440 Hz) → ADSR Envelope → Output");
    println!("  📊 Envelope: A=0.1s, D=0.2s, S=0.7, R=0.3s");
    println!();

    // Create WAV file
    let spec = WavSpec {
        channels: 1,
        sample_rate: SAMPLE_RATE as u32,
        bits_per_sample: 16,
        sample_format: hound::SampleFormat::Int,
    };
    let mut writer = WavWriter::create("envelope_test.wav", spec)?;

    println!("🎬 Rendering audio...");

    // Define note triggers (time in seconds, gate duration in seconds)
    let notes = vec![
        (0.5, 0.5), // Note 1: starts at 0.5s, held for 0.5s
        (2.0, 1.0), // Note 2: starts at 2.0s, held for 1.0s
        (4.0, 1.5), // Note 3: starts at 4.0s, held for 1.5s
    ];

    let mut current_note = 0;
    let mut gate_on_time: Option<f32> = None;

    // Process audio in blocks
    let mut samples_rendered = 0;
    let mut output_buffer = vec![0.0f32; BUFFER_SIZE];

    while samples_rendered < TOTAL_SAMPLES {
        let current_time = samples_rendered as f32 / SAMPLE_RATE;

        // Check if we need to trigger a note
        if current_note < notes.len() {
            let (trigger_time, duration) = notes[current_note];

            // Gate ON
            if gate_on_time.is_none() && current_time >= trigger_time {
                producer
                    .try_push(Command::UpdateParam {
                        node: env_id,
                        param_index: 4,
                        new_param: Param::new(1.0), // gate ON
                    })
                    .ok();
                gate_on_time = Some(current_time);
                println!("  🎹 Note {} ON  @ {:.2}s", current_note + 1, current_time);
            }

            // Gate OFF
            if let Some(on_time) = gate_on_time {
                if current_time >= on_time + duration {
                    producer
                        .try_push(Command::UpdateParam {
                            node: env_id,
                            param_index: 4,
                            new_param: Param::new(0.0), // gate OFF
                        })
                        .ok();
                    println!("  🎹 Note {} OFF @ {:.2}s", current_note + 1, current_time);
                    gate_on_time = None;
                    current_note += 1;
                }
            }
        }

        // Process one block
        scheduler.process_block(&mut consumer, &mut output_buffer);

        // Write to WAV file
        for &sample in output_buffer.iter() {
            let sample_i16 = (sample.clamp(-1.0, 1.0) * 32767.0) as i16;
            writer.write_sample(sample_i16)?;
        }

        samples_rendered += BUFFER_SIZE;
    }

    writer.finalize()?;

    println!();
    println!("✅ Rendering complete!");
    println!("📁 Output: envelope_test.wav");
    println!();
    println!("🎧 What to listen for:");
    println!("   - Note 1: Quick attack, short sustain, smooth release");
    println!("   - Note 2: Same envelope, longer sustain phase");
    println!("   - Note 3: Same envelope, longest sustain phase");
    println!(
        "   - Each note fades in (attack), drops (decay), holds (sustain), fades out (release)"
    );
    println!();
    println!("💡 Try modifying:");
    println!("   - Attack time (line 107)");
    println!("   - Decay time (line 112)");
    println!("   - Sustain level (line 117)");
    println!("   - Release time (line 122)");
    println!("   - Note timings (line 153)");

    Ok(())
}