voxudio 0.6.3

A real-time audio processing library with ONNX runtime support
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

use {std::time::Duration, tokio::time::sleep, voxudio::*};

async fn test_audio_player_creation() -> anyhow::Result<()> {
    let player = AudioPlayer::new()?;
    println!("Successfully created AudioPlayer: {:?}", player);
    player.get_name()?;

    Ok(())
}

async fn test_audio_player_play() -> anyhow::Result<()> {
    let mut player = AudioPlayer::new()?;
    // Create short test audio
    let sample_rate = 48000;
    let duration_secs = 0.1;
    let frequency = 440.0;
    let num_samples = (sample_rate as f32 * duration_secs) as usize;

    let mut test_audio = Vec::with_capacity(num_samples);
    for i in 0..num_samples {
        let t = i as f32 / sample_rate as f32;
        let sample = (2.0 * std::f32::consts::PI * frequency * t).sin() * 0.5;
        test_audio.push(sample);
    }

    // Play audio
    println!("Attempting to play audio...");
    player.play()?;
    player.write::<48000, f32>(&test_audio, 1).await?;

    Ok(())
}

async fn test_audio_collector_creation() -> anyhow::Result<()> {
    let Ok(collector) = AudioCollector::new() else {
        println!("Testing audio collector creation - requires audio input device");
        return Ok(());
    };
    println!("Successfully created AudioCollector: {:?}", collector);
    assert!(
        collector.get_name().is_ok(),
        "Should be able to get device name"
    );

    Ok(())
}

async fn test_audio_collector_start_stop() -> anyhow::Result<()> {
    // Create audio collector
    let Ok(collector) = AudioCollector::new() else {
        println!("Testing audio collector start/stop - requires audio input device");
        return Ok(());
    };

    // Start collection
    println!("Attempting to start audio collection...");
    collector.collect()?;
    println!("Audio collection started, waiting 100ms...");
    sleep(Duration::from_millis(100)).await;

    // Stop collection
    println!("Attempting to stop audio collection...");
    collector.pause()?;

    Ok(())
}

async fn test_audio_collector_read() -> anyhow::Result<()> {
    // Create audio collector
    let Ok(mut collector) = AudioCollector::new() else {
        println!("Testing audio collector read - requires audio input device");
        return Ok(());
    };

    // Start collection
    println!("Attempting to start audio collection...");
    collector.collect()?;
    println!("Audio collection started, waiting 100ms...");
    sleep(Duration::from_millis(100)).await;

    // Read data - add more error handling and logging
    println!("Attempting to read audio data...");
    let data = collector.read::<48000, f32>(2).await?;

    // Ensure to stop collection immediately after reading, regardless of success
    println!("Attempting to stop audio collection...");
    collector.pause()?;

    // Process read results

    println!("Successfully read {} audio samples", data.len());
    assert!(!data.is_empty(), "Should be able to read audio data");

    // Stop collection
    println!("Attempting to stop audio collection...");
    collector.pause()?;

    Ok(())
}

#[tokio::test]
async fn test_all() -> anyhow::Result<()> {
    test_audio_player_creation().await?;
    test_audio_player_play().await?;
    test_audio_collector_creation().await?;
    test_audio_collector_start_stop().await?;
    test_audio_collector_read().await?;

    Ok(())
}