wave_stream 0.5.0

Wave file reader and writer. Random access and streaming is supported for reading, random access is supported for writing
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

use std::io::{Result, Write};

use crate::assertions::assert_int_24;
use crate::upconvert::{i16_to_f32, i16_to_i24, i24_to_f32, i8_to_f32, i8_to_i16, i8_to_i24};

/// Convenience methods for writing to a stream
pub trait WriteEx: Write {
    fn write_str(&mut self, s: &str) -> Result<()>;
    fn write_i32(&mut self, v: i32) -> Result<()>;
    fn write_u32(&mut self, v: u32) -> Result<()>;
    fn write_i16(&mut self, v: i16) -> Result<()>;
    fn write_i16_as_i24(&mut self, v: i16) -> Result<()>;
    fn write_u16(&mut self, v: u16) -> Result<()>;
    fn write_f32(&mut self, v: f32) -> Result<()>;
    fn write_i8(&mut self, v: i8) -> Result<()>;
    fn write_i8_as_i24(&mut self, v: i8) -> Result<()>;
    fn write_i8_as_i16(&mut self, v: i8) -> Result<()>;
    fn write_i24(&mut self, v: i32) -> Result<()>;
    fn write_i24_as_f32(&mut self, v: i32) -> Result<()>;
    fn write_i16_as_f32(&mut self, v: i16) -> Result<()>;
    fn write_i8_as_f32(&mut self, v: i8) -> Result<()>;
}

impl<T> WriteEx for T
where
    T: Write,
{
    fn write_str(&mut self, s: &str) -> Result<()> {
        let bytes = s.as_bytes();
        self.write(&bytes)?;

        Ok(())
    }

    fn write_i32(&mut self, v: i32) -> Result<()> {
        let bytes = v.to_le_bytes();
        self.write(&bytes)?;

        Ok(())
    }

    fn write_u32(&mut self, v: u32) -> Result<()> {
        let bytes = v.to_le_bytes();
        self.write(&bytes)?;

        Ok(())
    }

    fn write_i16(&mut self, v: i16) -> Result<()> {
        let bytes = v.to_le_bytes();
        self.write(&bytes)?;

        Ok(())
    }

    fn write_i16_as_i24(&mut self, v: i16) -> Result<()> {
        let sample_as_i24 = i16_to_i24(v)?;
        self.write_i24(sample_as_i24)?;

        Ok(())
    }

    fn write_i8_as_i24(&mut self, v: i8) -> Result<()> {
        let sample_as_i24 = i8_to_i24(v)?;
        self.write_i24(sample_as_i24)?;

        Ok(())
    }

    fn write_i8_as_i16(&mut self, v: i8) -> Result<()> {
        let sample_as_i16 = i8_to_i16(v)?;
        self.write_i16(sample_as_i16)?;

        Ok(())
    }

    fn write_u16(&mut self, v: u16) -> Result<()> {
        let bytes = v.to_le_bytes();
        self.write(&bytes)?;

        Ok(())
    }

    fn write_f32(&mut self, v: f32) -> Result<()> {
        let bytes = v.to_le_bytes();
        self.write(&bytes)?;

        Ok(())
    }

    fn write_i8(&mut self, v: i8) -> Result<()> {
        let bytes = v.to_le_bytes();
        self.write(&bytes)?;

        Ok(())
    }

    fn write_i24(&mut self, v: i32) -> Result<()> {
        assert_int_24(v)?;

        let bytes = (v << 8).to_le_bytes();

        let bytes = [bytes[1], bytes[2], bytes[3]];
        self.write(&bytes)?;

        Ok(())
    }

    fn write_i24_as_f32(&mut self, v: i32) -> Result<()> {
        let sample_float = i24_to_f32(v)?;
        return self.write_f32(sample_float);
    }

    fn write_i16_as_f32(&mut self, v: i16) -> Result<()> {
        let sample_float = i16_to_f32(v)?;
        return self.write_f32(sample_float);
    }

    fn write_i8_as_f32(&mut self, v: i8) -> Result<()> {
        let sample_float = i8_to_f32(v)?;
        return self.write_f32(sample_float);
    }
}