rack 0.4.8

A modern Rust library for hosting audio plugins
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Process audio through an AudioUnit effect plugin
//!
//! This example demonstrates:
//! - Loading an effect plugin
//! - Initializing it for audio processing
//! - Processing audio buffers through the plugin
//! - Analyzing the output

use rack::prelude::*;

fn main() -> Result<()> {
    println!("AudioUnit Audio Processing Example");
    println!("===================================\n");

    // Create scanner
    println!("Creating scanner...");
    let scanner = Scanner::new()?;

    // Scan for plugins
    println!("Scanning for AudioUnit plugins...");
    let plugins = scanner.scan()?;

    if plugins.is_empty() {
        println!("No plugins found!");
        return Ok(());
    }

    println!("Found {} plugin(s)\n", plugins.len());

    // Find first effect plugin
    let effect = plugins
        .iter()
        .find(|p| p.plugin_type == PluginType::Effect);

    if let Some(info) = effect {
        println!("Loading effect plugin:");
        println!("  Name: {}", info.name);
        println!("  Manufacturer: {}", info.manufacturer);
        println!("  Type: {:?}", info.plugin_type);
        println!("  ID: {}", info.unique_id);
        println!();

        // Create instance
        println!("Creating plugin instance...");
        let mut plugin = scanner.load(info)?;
        println!("✓ Plugin instance created");

        // Initialize for 48kHz, 512 sample buffers
        println!("Initializing plugin (48kHz, 512 samples)...");
        plugin.initialize(48000.0, 512)?;
        println!("✓ Plugin initialized successfully!");
        println!();

        // Create test buffers (planar format - separate buffer per channel)
        let frames = 512;
        let mut left_in = vec![0.0f32; frames];
        let mut right_in = vec![0.0f32; frames];
        let mut left_out = vec![0.0f32; frames];
        let mut right_out = vec![0.0f32; frames];

        println!("Generating test signal (440 Hz sine wave)...");
        let frequency = 440.0f32; // A4
        let sample_rate = 48000.0f32;

        for i in 0..frames {
            let t = i as f32 / sample_rate;
            let sample = (2.0 * std::f32::consts::PI * frequency * t).sin() * 0.5;
            left_in[i] = sample;  // Left channel
            right_in[i] = sample; // Right channel
        }

        println!("✓ Test signal generated ({} frames, stereo planar)", frames);
        println!();

        // Process audio (planar format)
        println!("Processing audio through plugin...");
        plugin.process(
            &[&left_in, &right_in],
            &mut [&mut left_out, &mut right_out],
            frames
        )?;
        println!("✓ Audio processing complete!");
        println!();

        // Analyze output
        println!("Analyzing output:");

        // Calculate RMS (Root Mean Square) level
        let output_samples = left_out.len() + right_out.len();
        let rms: f32 = (left_out.iter().chain(right_out.iter())
            .map(|&sample| sample * sample)
            .sum::<f32>()
            / output_samples as f32)
            .sqrt();

        println!("  RMS level: {:.6}", rms);

        // Find peak level
        let peak = left_out.iter().chain(right_out.iter())
            .fold(0.0f32, |max, &sample| max.max(sample.abs()));
        println!("  Peak level: {:.6}", peak);

        // Check if output has signal
        let has_signal = left_out.iter().chain(right_out.iter())
            .any(|&sample| sample != 0.0);
        if has_signal {
            println!("  Signal: ✓ Output contains audio");
        } else {
            println!("  Signal: ✗ Output is silent");
        }

        // Compare input and output
        let input_samples = left_in.len() + right_in.len();
        let input_rms: f32 = (left_in.iter().chain(right_in.iter())
            .map(|&sample| sample * sample)
            .sum::<f32>()
            / input_samples as f32)
            .sqrt();

        println!();
        println!("Comparison:");
        println!("  Input RMS:  {:.6}", input_rms);
        println!("  Output RMS: {:.6}", rms);
        println!("  Gain change: {:.2} dB", 20.0 * (rms / input_rms).log10());

        println!();
        println!("✓ Audio processing demonstration complete!");

        return Ok(());
    }

    println!("No effect plugin found to demonstrate processing");
    Ok(())
}