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
124
125
126
127
128

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

use crate::open_wav::OpenWav;
use crate::wave_header::Channels;
use crate::SampleFormat;
use crate::SampleFormatSize;
use crate::WavHeader;
use crate::WriteEx;

pub trait WriteSeek: Write + Seek {}

impl<TWriteSeek: Write + Seek> WriteSeek for TWriteSeek {}

/// An open wav writer
pub struct OpenWavWriter {
    writer: Box<dyn WriteSeek>,
    header: WavHeader,
    data_start: usize,
    chunk_size_written: bool,
    samples_written: usize,
    max_samples: usize,
}

/// An open random access wav writer
pub struct RandomAccessWavWriter<T> {
    open_wav: OpenWavWriter,
    write_sample_to_stream: Box<dyn Fn(&mut dyn Write, T) -> Result<()>>,
}

impl OpenWavWriter {
    /// Constructs a new wav writer
    ///
    /// * 'writer' - The (Write + Seek) struct to write the wav into. It is strongly recommended that this struct implement some form of buffering, such as via a BufWriter
    /// * 'header' - The header that represents the desired sampling rate and bit depth
    pub fn new<TWriter: 'static + WriteSeek>(
        writer: TWriter,
        header: WavHeader,
    ) -> Result<OpenWavWriter> {
        return OpenWavWriter::new_max_samples(writer, header, header.max_samples());
    }

    /// Intended to support testing max_samples
    pub(crate) fn new_max_samples<TWriter: 'static + WriteSeek>(
        mut writer: TWriter,
        header: WavHeader,
        max_samples: usize,
    ) -> Result<OpenWavWriter> {
        writer.write_str("data")?;
        writer.write_u32(0)?;

        let data_start = writer.stream_position()? as usize;

        Ok(OpenWavWriter {
            writer: Box::new(writer),
            header,
            data_start,
            chunk_size_written: false,
            samples_written: 0,
            max_samples,
        })
    }

    /// Flushes all buffered data to the stream
    pub fn flush(&mut self) -> Result<()> {
        // data chunk
        let chunk_size =
            self.samples_written * (self.num_channels() * self.bytes_per_sample()) as usize;
        self.writer
            .seek(SeekFrom::Start(self.data_start as u64 - 4u64))?;
        self.writer.write_u32(chunk_size as u32)?;

        // RIFF header
        self.writer.seek(SeekFrom::Start(4))?;
        self.writer.write_u32((chunk_size + 32 - 8) as u32)?;

        self.chunk_size_written = true;

        self.writer.flush()?;

        Ok(())
    }

    /// The maximum number of samples that can be written without exceeding the 4GB limit
    pub fn max_samples(&self) -> usize {
        self.max_samples
    }
}

impl OpenWav for OpenWavWriter {
    fn sample_format(&self) -> SampleFormat {
        self.header.sample_format
    }

    fn num_channels(&self) -> u16 {
        self.header.channels.count()
    }

    fn channels(&self) -> &Channels {
        &self.header.channels
    }

    fn sample_rate(&self) -> u32 {
        self.header.sample_rate
    }

    fn bits_per_sample(&self) -> u16 {
        self.header.sample_format.bits_per_sample()
    }

    fn bytes_per_sample(&self) -> u16 {
        self.header.sample_format.bytes_per_sample()
    }

    fn len_samples(&self) -> usize {
        self.samples_written
    }
}

impl Drop for OpenWavWriter {
    fn drop(&mut self) {
        if !self.chunk_size_written {
            self.flush().unwrap();
        }
    }
}

mod random;
mod stream;