sdl3 0.18.0

Bindings to SDL3, a cross-platform library to abstract the platform-specific details for building applications.
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148

fn init_audio_subsystem() -> Option<(sdl3::Sdl, sdl3::AudioSubsystem)> {
    std::env::set_var("SDL_AUDIODRIVER", "dummy");
    let sdl = match sdl3::init() {
        Ok(sdl) => sdl,
        Err(err) => {
            eprintln!("Skipping audio test: failed to init SDL: {err}");
            return None;
        }
    };
    let audio = match sdl.audio() {
        Ok(audio) => audio,
        Err(err) => {
            eprintln!("Skipping audio test: failed to init audio subsystem: {err}");
            return None;
        }
    };
    Some((sdl, audio))
}

#[test]
fn audio_spec_wav() {
    let wav = sdl3::audio::AudioSpecWAV::load_wav("./assets/sine.wav").unwrap();

    assert_eq!(wav.freq, 22_050);
    assert_eq!(wav.format, sdl3::audio::AudioFormat::S16LE);
    assert_eq!(wav.channels, 1);

    let buffer = wav.buffer();
    assert_eq!(buffer.len(), 4_410);
}

#[test]
fn audio_stream_device_paused_state_transitions() {
    let Some((_sdl, audio)) = init_audio_subsystem() else {
        return;
    };

    let device = match audio.open_playback_device(&sdl3::audio::AudioSpec::default()) {
        Ok(device) => device,
        Err(err) => {
            eprintln!("Skipping stream test: failed to open dummy playback device: {err}");
            return;
        }
    };

    let stream = match device.open_device_stream(None) {
        Ok(stream) => stream,
        Err(err) => {
            eprintln!("Skipping stream test: failed to open device stream: {err}");
            return;
        }
    };

    // Newly created device streams start paused.
    assert!(stream.device_paused().expect("device_paused failed"));

    stream.resume().expect("resume failed");
    assert!(
        !stream
            .device_paused()
            .expect("device_paused failed after resume"),
        "Device should report unpaused after resuming"
    );

    stream.pause().expect("pause failed");
    assert!(
        stream
            .device_paused()
            .expect("device_paused failed after pause"),
        "Device should report paused after pausing"
    );
}

#[test]
fn audio_stream_reports_format_and_queue() {
    let Some((_sdl, audio)) = init_audio_subsystem() else {
        return;
    };

    let device = match audio.open_playback_device(&sdl3::audio::AudioSpec::default()) {
        Ok(device) => device,
        Err(err) => {
            eprintln!("Skipping format test: failed to open dummy playback device: {err}");
            return;
        }
    };

    let stream = match device.open_device_stream(None) {
        Ok(stream) => stream,
        Err(err) => {
            eprintln!("Skipping format test: failed to open device stream: {err}");
            return;
        }
    };

    let (src, dst) = stream.get_format().expect("get_format failed");
    assert!(
        src.is_some() || dst.is_some(),
        "Expected dummy driver to report at least one side of the stream format"
    );

    let avail = stream.available_bytes().expect("available_bytes failed");
    assert!(avail >= 0, "available bytes should be non-negative");
    let queued = stream.queued_bytes().expect("queued_bytes failed");
    assert!(queued >= 0, "queued bytes should be non-negative");

    stream.clear().expect("clear failed");
    stream.pause().expect("pause failed");
    stream.resume().expect("resume failed");
}

#[test]
fn audio_stream_put_and_clear() {
    let Some((_sdl, audio)) = init_audio_subsystem() else {
        return;
    };

    let spec = sdl3::audio::AudioSpec {
        freq: Some(48_000),
        channels: Some(1),
        format: Some(sdl3::audio::AudioFormat::F32LE),
    };
    let stream = match audio.new_stream(Some(&spec), Some(&spec)) {
        Ok(stream) => stream,
        Err(err) => {
            eprintln!("Skipping stream buffer test: {err}");
            return;
        }
    };

    let samples = vec![0.0f32; 128];
    stream.put_data_f32(&samples).expect("put_data_f32 failed");
    let available = stream.available_bytes().expect("available_bytes failed");
    assert!(
        available >= (samples.len() * std::mem::size_of::<f32>()) as i32,
        "available bytes should reflect queued samples"
    );

    stream.clear().expect("clear failed");
    assert_eq!(
        stream
            .queued_bytes()
            .expect("queued_bytes failed after clear"),
        0,
        "clear should drop queued data"
    );
    stream.flush().expect("flush failed");
}