audio 0.2.1

A crate for working with audio in Rust
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

#[test]
fn test_read_write() {
    use crate::io::{Read, ReadWrite, Write};
    use audio_core::{Buf, ReadBuf, WriteBuf};

    let from = crate::interleaved![[1.0f32, 2.0f32, 3.0f32, 4.0f32]; 2];
    let to = crate::interleaved![[0.0f32; 4]; 2];

    // Make `to` into a ReadWrite adapter.
    let mut to = ReadWrite::empty(to);

    crate::io::copy_remaining(Read::new((&from).skip(2).limit(1)), &mut to);
    assert_eq!(to.remaining(), 1);

    crate::io::copy_remaining(Read::new((&from).limit(1)), &mut to);
    assert_eq!(to.remaining(), 2);

    assert_eq! {
        to.as_ref().as_slice(),
        &[3.0, 3.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0],
    };

    // Note: 4 channels, 2 frames each.
    let mut read_out = Write::new(crate::buf::Interleaved::with_topology(4, 2));

    assert_eq!(read_out.remaining_mut(), 2);
    assert!(read_out.has_remaining_mut());

    assert_eq!(to.remaining(), 2);
    assert!(to.has_remaining());

    crate::io::copy_remaining(&mut to, &mut read_out);

    assert_eq!(read_out.remaining_mut(), 0);
    assert!(!read_out.has_remaining_mut());

    assert_eq!(to.remaining(), 0);
    assert!(!to.has_remaining());

    assert_eq! {
        read_out.as_ref().as_slice(),
        &[3.0, 3.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0],
    }
}

#[test]
fn test_simple_io() {
    use crate::io::ReadWrite;

    let buf: crate::buf::Interleaved<i16> = crate::interleaved![[1, 2, 3, 4]; 4];
    let mut buf = ReadWrite::new(buf);

    let from = crate::wrap::interleaved(&[1i16, 2i16, 3i16, 4i16][..], 2);

    crate::io::translate_remaining(from, &mut buf);

    let buf = buf.into_inner();

    assert_eq!(buf.channels(), 4);
}