stream_wave_parser/
lib.rs

1#![warn(missing_docs)]
2
3//!  The `stream-wave-parser` is a crate that treats a stream from WAVE file.
4//!
5//! ```
6//! # use stream_wave_parser::WaveStream;
7//! # use futures_util::StreamExt as _;
8//! #
9//! use futures_util::stream::iter; // To create stream from `Vec<_>`.
10//!
11//! #[tokio::main]
12//! async fn main() {
13//!     // create wave stream.
14//!     let chunks = create_sine_wave()
15//!         .chunks(256)
16//!         .map(|x| Ok(x.iter().cloned().collect::<Vec<_>>()))
17//!         .collect::<Vec<_>>();
18//!     let stream = iter(chunks);
19//!
20//!     // read stream by `WaveStream`.
21//!     let mut stream = WaveStream::new(stream);
22//!     let spec = stream.spec().await.unwrap();
23//!     assert_eq!(spec.pcm_format, 1);
24//!     assert_eq!(spec.channels, 1);
25//!     assert_eq!(spec.sample_rate, 8000);
26//!     assert_eq!(spec.bits_per_sample, 16);
27//!
28//!     let data_size = 16000; // 8000 samples x 2 Bytes (16 bits per sample)
29//!     let mut data = stream.into_data().await;
30//!     let mut size = 0;
31//!     while let Some(chunk) = data.next().await {
32//!         let chunk = chunk.unwrap();
33//!         size += chunk.len();
34//!     }
35//!     assert_eq!(data_size, size as u32);
36//! }
37//!
38//! /// create sine wave (440 Hz 1 seconds)
39//! fn create_sine_wave() -> Vec<u8> {
40//!     use std::f32::consts::PI;
41//!
42//!     let data_chunk = (0..)
43//!         .enumerate()
44//!         .map(|(_, idx)| {
45//!             let t = idx as f32 / 8000.0;
46//!             let sample = (t * 440. * 2. * PI).sin();
47//!             ((sample * i16::MAX as f32) as i16).to_le_bytes()
48//!         })
49//!         .take(8000)
50//!         .flatten()
51//!         .collect::<Vec<u8>>();
52//!
53//!     let mut wave = vec![];
54//!     let riff_length = ((data_chunk.len() + 36) as u32).to_le_bytes();
55//!     wave.extend(b"RIFF");
56//!     wave.extend(riff_length);
57//!     wave.extend(b"WAVE");
58//!     wave.extend(b"fmt ");
59//!     wave.extend(16u32.to_le_bytes());    // `fmt ` chunk size
60//!     wave.extend(1u16.to_le_bytes());     // PCM format
61//!     wave.extend(1u16.to_le_bytes());     // channels
62//!     wave.extend(8000u32.to_le_bytes());  // sample rate
63//!     wave.extend(16000u32.to_le_bytes()); // bit rate
64//!     wave.extend(2u16.to_le_bytes());     // block size
65//!     wave.extend(16u16.to_le_bytes());    // bits per sample
66//!
67//!     wave.extend(b"data");
68//!     wave.extend((data_chunk.len() as u32).to_le_bytes());
69//!     wave.extend(data_chunk);
70//!
71//!     wave
72//! }
73//! ```
74
75mod error;
76mod mixer;
77mod wave;
78
79pub use error::{Error, Result};
80pub use mixer::{WaveChannelMixer, WaveChannelMixerOptions};
81pub use wave::{WaveSpec, WaveStream};