Import 'hound' crate
Request Document: go/android-rust-importing-crates
For CL Reviewers: go/android3p#cl-review
For Build Team: go/ab-third-party-imports
Bug: 355564847
Test: m libhound
Change-Id: Ifb313345cde3fdbd41a2ab3e21bece7510c3307d
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
new file mode 100644
index 0000000..44c7fcc
--- /dev/null
+++ b/.cargo_vcs_info.json
@@ -0,0 +1,5 @@
+{
+ "git": {
+ "sha1": "2cddb275183a6146c0dff2c758ff936d00147af1"
+ }
+}
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..133c829
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,10 @@
+# Cargo files
+/target
+
+# Editor files
+*.swp
+*.swo
+
+# Example and test output
+/append.wav
+/sine.wav
diff --git a/Android.bp b/Android.bp
new file mode 100644
index 0000000..5be1567
--- /dev/null
+++ b/Android.bp
@@ -0,0 +1,29 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+ default_applicable_licenses: ["external_rust_crates_hound_license"],
+}
+
+license {
+ name: "external_rust_crates_hound_license",
+ visibility: [":__subpackages__"],
+ license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+ license_text: ["LICENSE"],
+}
+
+rust_library {
+ name: "libhound",
+ host_supported: true,
+ crate_name: "hound",
+ cargo_env_compat: true,
+ cargo_pkg_version: "3.5.1",
+ crate_root: "src/lib.rs",
+ edition: "2015",
+ apex_available: [
+ "//apex_available:platform",
+ "//apex_available:anyapex",
+ ],
+ product_available: true,
+ vendor_available: true,
+}
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000..be15e7f
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,100 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "alsa-sys"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.23 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pkg-config 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "bitflags"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "coreaudio-rs"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "coreaudio-sys 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.23 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "coreaudio-sys"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.23 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "cpal"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "alsa-sys 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "coreaudio-rs 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.23 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ole32-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "hound"
+version = "3.5.1"
+dependencies = [
+ "cpal 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "lazy_static"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "libc"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "ole32-sys"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi-build"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[metadata]
+"checksum alsa-sys 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9013f855a808ab924a4c08b5c1ec9bd6b04fdb2295b4d570fb723e0ed2802a4f"
+"checksum bitflags 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "32866f4d103c4e438b1db1158aa1b1a80ee078e5d77a59a2f906fd62a577389c"
+"checksum coreaudio-rs 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7f97dd1cb4381fc1d3a80f2c63ce965c4c936befe7051fd33289a2dc45914bda"
+"checksum coreaudio-sys 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "31231897622a4cd14cb211af6f26d6fcf0c78078fa60c586ce9db8f0b581cd44"
+"checksum cpal 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)" = "989df64d59c65f18776046436c3e50964699ec789e76b1af04f6fc32b6a2b713"
+"checksum lazy_static 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4f9e1e434b35b61b6422b19998d5c219f6b4a90aae841583444b44077adb953b"
+"checksum libc 0.2.23 (registry+https://github.com/rust-lang/crates.io-index)" = "e7eb6b826bfc1fdea7935d46556250d1799b7fe2d9f7951071f4291710665e3e"
+"checksum ole32-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5d2c49021782e5233cd243168edfa8037574afed4eba4bbaf538b3d8d1789d8c"
+"checksum pkg-config 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "3a8b4c6b8165cd1a1cd4b9b120978131389f64bdaf456435caa41e630edba903"
+"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+"checksum winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..630af06
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,26 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+name = "hound"
+version = "3.5.1"
+authors = ["Ruud van Asseldonk <[email protected]>"]
+description = "A wav encoding and decoding library"
+homepage = "https://github.com/ruuda/hound"
+documentation = "https://docs.rs/hound"
+readme = "readme.md"
+keywords = ["wav", "wave", "audio", "codec"]
+categories = ["multimedia::encoding", "multimedia::audio"]
+license = "Apache-2.0"
+repository = "https://github.com/ruuda/hound"
+[dev-dependencies.cpal]
+version = "0.2.12"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
new file mode 100644
index 0000000..a6fa89a
--- /dev/null
+++ b/Cargo.toml.orig
@@ -0,0 +1,19 @@
+[package]
+
+name = "hound"
+version = "3.5.1"
+authors = ["Ruud van Asseldonk <[email protected]>"]
+description = "A wav encoding and decoding library"
+keywords = ["wav", "wave", "audio", "codec"]
+categories = ["multimedia::encoding", "multimedia::audio"]
+license = "Apache-2.0"
+readme = "readme.md"
+homepage = "https://github.com/ruuda/hound"
+repository = "https://github.com/ruuda/hound"
+documentation = "https://docs.rs/hound"
+
+[dev-dependencies]
+# An older version of cpal, but newer versions depend on the futures library,
+# which is incompatible with the version of Rust that Hound guarantees to
+# support.
+cpal = "0.2.12"
diff --git a/LICENSE b/LICENSE
new file mode 120000
index 0000000..0484eba
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1 @@
+license
\ No newline at end of file
diff --git a/METADATA b/METADATA
new file mode 100644
index 0000000..5cbf973
--- /dev/null
+++ b/METADATA
@@ -0,0 +1,20 @@
+name: "hound"
+description: "A wav encoding and decoding library"
+third_party {
+ identifier {
+ type: "crates.io"
+ value: "hound"
+ }
+ identifier {
+ type: "Archive"
+ value: "https://static.crates.io/crates/hound/hound-3.5.1.crate"
+ primary_source: true
+ }
+ version: "3.5.1"
+ license_type: NOTICE
+ last_upgrade_date {
+ year: 2024
+ month: 8
+ day: 9
+ }
+}
diff --git a/MODULE_LICENSE_APACHE2 b/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/MODULE_LICENSE_APACHE2
diff --git a/OWNERS b/OWNERS
new file mode 100644
index 0000000..48bea6e
--- /dev/null
+++ b/OWNERS
@@ -0,0 +1,2 @@
+# Bug component: 688011
+include platform/prebuilts/rust:main:/OWNERS
diff --git a/cargo_embargo.json b/cargo_embargo.json
new file mode 100644
index 0000000..e6a2930
--- /dev/null
+++ b/cargo_embargo.json
@@ -0,0 +1,4 @@
+{
+ "run_cargo": false,
+ "tests": false
+}
diff --git a/changelog.md b/changelog.md
new file mode 100644
index 0000000..2c65b22
--- /dev/null
+++ b/changelog.md
@@ -0,0 +1,292 @@
+Changelog
+=========
+
+3.5.1
+-----
+
+Released 2023-09-25.
+
+**Compatibility**:
+
+ * Ensures compatibility with Rust 1.40.0 through 1.72.1. This bumps the minimum
+ supported Rust version from 1.16 to 1.40.
+
+Changes:
+
+ * Soundness: Wrap writes to uninitialized memory in `mem::MaybeUninit`. The
+ unsoundness was present in all versions since 0.2.0. There is no evidence
+ that rustc took advantage of the unsoundness to compile programs in a
+ problematic way.
+
+Thanks to Cam Lloyd for originally contributing these changes, and thanks to
+Maxwell McKinnon for rebasing them on top of 3.5.0.
+
+3.5.0
+-----
+
+Released 2022-09-09.
+
+This is a maintenance release that includes most of the bugfixes and features
+that have been contributed since 3.4.0, which could be cherry-picked on top of
+3.4.0. Some other contributions with more far-reaching changes remain unreleased
+as of yet.
+
+**Compatibility**:
+
+ * Ensures compatibility with Rust 1.16 through 1.63 stable. Previously the
+ minimum supported Rust version was 1.4. Cargo from 1.4 is no longer
+ compatible with the current crates.io registry, and Rustup fails signature
+ verification for these binaries, so it is infeasible to continue to support
+ it.
+
+New features:
+
+ * Add support for `S24_LE` files, which store 24 bits in 4 bytes ([#40][40],
+ [#41][41])
+ * Add `WavWriter::new_with_spec_ex` ([#42][42])
+ * Add `WavSpec::into_header_for_infinite_file` ([#33][33], [#36][36])
+
+Bugfixes and compatibility improvements:
+
+ * Handle files that have the `wValidBitsPerSample` field set to zero
+ ([#50][50], [#51][51])
+ * Avoid overflow in the channel mask when writing file with more than 32
+ channels ([#59][59], [#60][60])
+
+[33]: https://github.com/ruuda/hound/pull/33
+[36]: https://github.com/ruuda/hound/pull/36
+[40]: https://github.com/ruuda/hound/pull/40
+[41]: https://github.com/ruuda/hound/pull/41
+[42]: https://github.com/ruuda/hound/pull/42
+[50]: https://github.com/ruuda/hound/pull/50
+[51]: https://github.com/ruuda/hound/pull/51
+[59]: https://github.com/ruuda/hound/pull/59
+[60]: https://github.com/ruuda/hound/pull/60
+
+Many thanks to Diffuse, Fletcher Woodruff, Matt Wilkinson, Vitaly Vi Shukela,
+and Tuckerrrrrrrrrr for contributing to this release.
+
+3.4.0
+-----
+
+Released 2018-04-07.
+
+**Breaking changes**:
+
+- None.
+
+Release highlights:
+
+- Exposes `read_wave_header()`, to quickly determine whether a file could be
+ a wav file.
+- Adds support for appending to an existing file. See `WavWriter::append()` for
+ constructing a writer that appends to a file, and `WavWriter::new_append()`
+ for the generic case.
+- Adds `WavWriter::flush()` to flush the underlying writer and update the
+ header. This can be used to minimize data loss when writing a large file.
+- Adds `WavWriter::duration()`, `WavWriter::len()`, and `WavWriter::spec()` to
+ obtain the duration and number of samples written so far, and the spec of the
+ file being written. The latter is useful when appending.
+- Hound now fails earlier when requesting to write an unsupported spec:
+ `WavWriter::new()` will already return `Error::Unsupported`. Previously this
+ error was returned when writing a sample.
+- Hound now verifies that the data chunk has no trailing bytes.
+- `WavWriter::finalize()` now performs a flush as its last operation, to be able
+ to observe errors when using a buffered writer.
+- Ensures compatibility with Rust 1.4 through 1.25 stable.
+
+3.3.1
+-----
+
+Released 2018-02-18.
+
+**Breaking changes**:
+
+- None.
+
+Release highlights:
+
+- Hound now reads certain WAVEFORMATEX files that were previously
+ rejected incorrectly.
+- Ensures compatibility with Rust 1.4 through 1.24 stable.
+
+3.3.0
+-----
+
+Released 2017-12-02.
+
+**Breaking changes**:
+
+- None.
+
+Release highlights:
+
+- Hound now supports seeking to a particular time in the file.
+ See `WavReader::seek()`.
+- Ensures compatibility with Rust 1.4 through 1.22 stable.
+
+Many thanks to Mitchell Nordine for contributing to this release.
+
+3.2.0
+-----
+
+Released 2017-10-14.
+
+**Breaking changes**:
+
+- None.
+
+Release highlights:
+
+- Hound will now write the older PCMWAVEFORMAT format whenever possible, rather
+ than the newer WAVEFORMATEXTENSIBLE, to improve compatibility.
+- Certain nonstandard files (produced among others by “Pro Tools”) can now
+ be read.
+- Ensures compatibility with Rust 1.4 through 1.21 stable.
+
+Many thanks to Denis Kolodin for contributing to this release.
+
+3.1.0
+-----
+
+Released 2017-04-09.
+
+**Breaking changes**:
+
+- None.
+
+Release highlights:
+
+- Support for writing IEEE float was added.
+- The cpal example was updated, and it now compiles on OS X.
+- An OS X target was added to the CI configuration.
+- Ensures compatibility with Rust 1.4 through 1.16 stable.
+
+Many thanks to Alex Zywicki for contributing to this release.
+
+3.0.1
+-----
+
+Released 2017-04-01.
+
+This release fixes a few bugs discovered through fuzzing.
+
+**Breaking changes**:
+
+- None.
+
+Release highlights:
+
+- Fixes high memory usage issue that could occur when reading unknown blocks.
+- Resolve various division by zero and arithmetic overflow errors.
+- Ensures compatibility with Rust 1.4 through 1.16 stable.
+
+3.0.0
+-----
+
+Released 2016-11-27.
+
+This release focuses on improving write performance.
+
+**Breaking changes**:
+
+- When a `WavWriter` is constructed, the header is now written immediately,
+ therefore the constructor now returns a `Result`.
+
+Other changes:
+
+- `WavWriter` no longer maintains a buffer internally.
+ `WavWriter::create()` does still wrap the file it opens in a buffered writer.
+- Adds `SampleWriter16` for fast writing of 16-bit samples. Dedicated
+ writers for other bit depths might be added in future releases.
+
+Upgrading requires dealing with the `Result` in `WavWriter::new()`
+and `WavWriter::create()`. In many cases this should be as simple as
+wrapping the call in a `try!()`, or appending a `?` on recent versions
+of Rust.
+
+2.0.0
+-----
+
+Released 2016-07-31.
+
+**Breaking changes**:
+
+- Support for Rust 1.0 through 1.3 has been dropped.
+- The `WavSpec` struct gained a new `sample_format` member. To upgrade,
+ add `sample_format: hound::SampleFormat::Int` to places where a `WavSpec`
+ is constructed.
+
+Release highlights:
+
+- Ensures compatibility with Rust 1.4 through 1.10.
+- Adds support for reading files with 32-bit IEEE float samples.
+
+Many thanks to Mitchell Nordine for his contributions to this release.
+
+1.1.0
+-----
+
+Released 2015-09-14.
+
+Release highlights:
+
+- New `WavReader::into_inner` method for consistency with the standard library.
+- New `WavReader::into_samples` method for ergonomics and consistency.
+- Ensures compatibility with Rust 1.4.
+
+Many thanks to Pierre Krieger for his contributions to this release.
+
+1.0.0
+-----
+
+Released 2015-07-21.
+
+This is the first stable release of Hound. Only small changes have been made
+with respect to v0.4.0. Release highlights:
+
+- `WavWriter::create` now wraps the writer in a `BufWriter`.
+- `WavSamples` now implements `ExactSizeIterator`.
+- `WavReader::spec` now returns the spec by value.
+- Internal cleanups
+
+0.4.0
+-----
+
+Released 2015-05-16.
+
+Release highlights:
+
+- Works with Rust 1.0.0.
+- Hound can now read and write files with 8, 16, 24, or 32 bits per sample.
+- Better error reporting
+- Improved documentation
+- An improved test suite
+
+0.3.0
+-----
+
+Released 2015-05-05.
+
+Release highlights:
+
+- Hound can now read WAVEFORMATEXTENSIBLE, so it can read the files it writes.
+- Hound can now read files with PCMWAVEFORMAT and WAVEFORMATEX header.
+- Hound now uses a custom error type.
+- New convenient filename-based constructors for `WavReader` and `WavWriter`.
+- More examples
+- An improved test suite
+
+0.2.0
+-----
+
+Released 2015-04-09.
+
+This version adds support for decoding wav files in addition to writing them.
+
+0.1.0
+-----
+
+Released 2015-04-01.
+
+Initial release with only write support.
diff --git a/contributing.md b/contributing.md
new file mode 100644
index 0000000..ed01f9f
--- /dev/null
+++ b/contributing.md
@@ -0,0 +1,19 @@
+Contributing
+============
+
+Contributions in the form of bug reports, feature requests, or pull requests are
+welcome. For pull requests, please consider:
+
+ * Write [a proper commit message][proper-commit] and keep the history clean.
+ * Avoid unrelated formatting changes, they make it harder to identify
+ functional changes in the diff.
+ * You agree to license your contribution under the Apache 2.0 license.
+
+Code of conduct
+---------------
+
+ * Be nice.
+ * Please do not discuss politics in the issue tracker,
+ the issue tracker is for technical issues.
+
+[proper-commit]: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html
diff --git a/examples/append.rs b/examples/append.rs
new file mode 100644
index 0000000..b5fbdc4
--- /dev/null
+++ b/examples/append.rs
@@ -0,0 +1,52 @@
+// Hound -- A wav encoding and decoding library in Rust
+// Copyright 2018 Ruud van Asseldonk
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// A copy of the License has been included in the root of the repository.
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This example appends one second of a 440 Hz sine wave to the file "sine.wav".
+// If the file does not exist, it is created instead.
+
+use std::f32::consts::PI;
+use std::i16;
+use std::path::Path;
+
+extern crate hound;
+
+fn main() {
+ let spec = hound::WavSpec {
+ channels: 1,
+ sample_rate: 44100,
+ bits_per_sample: 16,
+ sample_format: hound::SampleFormat::Int,
+ };
+
+ let path: &Path = "sine.wav".as_ref();
+
+ let mut writer = match path.is_file() {
+ true => hound::WavWriter::append(path).unwrap(),
+ false => hound::WavWriter::create(path, spec).unwrap(),
+ };
+
+ // We should not append blindly, we should make sure that the existing file
+ // has the right spec, because that is what we assume when writing.
+ assert_eq!(spec, writer.spec());
+
+ println!("Old duration is {} seconds.", writer.duration() / spec.sample_rate);
+
+ for t in (0 .. 44100).map(|x| x as f32 / 44100.0) {
+ let sample = (t * 440.0 * 2.0 * PI).sin();
+ let amplitude = i16::MAX as f32;
+ writer.write_sample((sample * amplitude) as i16).unwrap();
+ }
+
+ println!("New duration is {} seconds.", writer.duration() / spec.sample_rate);
+
+ writer.finalize().unwrap();
+}
diff --git a/examples/cpal.rs b/examples/cpal.rs
new file mode 100644
index 0000000..c434a2a
--- /dev/null
+++ b/examples/cpal.rs
@@ -0,0 +1,106 @@
+// Hound -- A wav encoding and decoding library in Rust
+// Copyright (C) 2015 Ruud van Asseldonk
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// A copy of the License has been included in the root of the repository.
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This example shows how to play a wav file using the cpal crate.
+
+extern crate hound;
+extern crate cpal;
+
+use std::env;
+use std::thread;
+
+fn main() {
+ // Make a WavReader that reads the file provided as program argument.
+ let fname = env::args().nth(1).expect("no file given");
+ let mut reader = hound::WavReader::open(fname).unwrap();
+ let spec = reader.spec();
+
+ let endpoint = cpal::get_default_endpoint().unwrap();
+
+ // Pick a playback format supported by the endpoint, which matches the spec
+ // of the wav file.
+ let format = endpoint.get_supported_formats_list().unwrap()
+ .filter(|f| matches_format(f, &spec))
+ .next()
+ .expect("no supported playback format");
+
+ // A voice in cpal is used for playback.
+ let mut voice = cpal::Voice::new(&endpoint, &format).unwrap();
+
+ let mut samples_left = reader.len() as usize;
+
+ let mut append_data = |voice: &mut cpal::Voice| {
+ match voice.append_data(samples_left) {
+ cpal::UnknownTypeBuffer::I16(mut wrapped_buf) => {
+ // We cannot rely on Rust's autoderef here, because we want to
+ // call .len() on the buffer, which would cause a deref() of the
+ // buffer, not a deref_mut(), and cpal's deref() implementation
+ // is to panic.
+ let buf: &mut [i16] = &mut *wrapped_buf;
+ for (dst, src) in buf.iter_mut().zip(reader.samples::<i16>()) {
+ *dst = src.unwrap();
+ }
+ samples_left -= buf.len();
+ }
+ cpal::UnknownTypeBuffer::F32(mut wrapped_buf) => {
+ let buf: &mut [f32] = &mut *wrapped_buf;
+ for (dst, src) in buf.iter_mut().zip(reader.samples::<f32>()) {
+ *dst = src.unwrap();
+ }
+ samples_left -= buf.len();
+ }
+ _ => unreachable!()
+ }
+
+ // Loop again if there are samples left.
+ samples_left > 0
+ };
+
+ // The voice must have some data before playing for the first time.
+ let mut has_more = append_data(&mut voice);
+ voice.play();
+
+ // Then we keep providing new data until the end of the audio.
+ while has_more {
+ has_more = append_data(&mut voice);
+ }
+
+ // Wait for playback to complete.
+ while voice.underflowed() {
+ thread::yield_now();
+ }
+}
+
+fn matches_format(format: &cpal::Format, spec: &hound::WavSpec) -> bool {
+ let cpal::SamplesRate(sample_rate) = format.samples_rate;
+ if sample_rate != spec.sample_rate {
+ return false
+ }
+
+ if format.channels.len() != spec.channels as usize {
+ return false
+ }
+
+ let data_type = match (spec.bits_per_sample, spec.sample_format) {
+ (16, hound::SampleFormat::Int) => Some(cpal::SampleFormat::I16),
+ (32, hound::SampleFormat::Float) => Some(cpal::SampleFormat::F32),
+ _ => None
+ };
+
+ if Some(format.data_type) != data_type {
+ return false
+ }
+
+ // If the sample rate, channel count, and sample format match, then we can
+ // play back the file in this format.
+ true
+}
diff --git a/examples/mean.rs b/examples/mean.rs
new file mode 100644
index 0000000..5c32d4b
--- /dev/null
+++ b/examples/mean.rs
@@ -0,0 +1,53 @@
+// Hound -- A wav encoding and decoding library in Rust
+// Copyright (C) 2015 Ruud van Asseldonk
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// A copy of the License has been included in the root of the repository.
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This example computes the mean value and rms of a file, where samples are
+// first interpreted as 16-bit signed integer, and then as a 16-bit unsigned
+// integer. This should allow us to determine whether the samples stored are
+// signed or unsigned: for signed the average value is expected to be 0, and
+// for unsigned the value is expected to be 2^16 - 1.
+// Note that this example is not a particularly good example of proper coding
+// style; it does not handle failure properly, and it assumes that the provided
+// file has 16 bits per sample.
+
+// TODO: This example should probably be removed, it is just here for verifying
+// and assumption at this point.
+
+extern crate hound;
+
+use std::env;
+
+fn main() {
+ let fname = env::args().nth(1).expect("no file given");
+ let mut reader = hound::WavReader::open(&fname).unwrap();
+ let samples: Vec<i16> = reader.samples().map(|s| s.unwrap()).collect();
+
+ let (ts, tu, n) = samples.iter().fold((0.0, 0.0, 0.0), |(ts, tu, n), &s| {
+ let signed = s as f64;
+ let unsigned = (s as u16) as f64;
+ (ts + signed, tu + unsigned, n + 1.0)
+ });
+ let ms = ts / n;
+ let mu = tu / n;
+ println!("mean signed: {} (should be 0, deviation is {})", ms, ms.abs());
+ println!("mean unsigned: {} (should be 2^16 - 1, deviation is {})", mu, (mu - 32767.0).abs());
+
+ let (ts, tu) = samples.iter().fold((0.0, 0.0), |(ts, tu), &s| {
+ let ds = s as f64 - ms;
+ let du = (s as u16) as f64 - mu;
+ (ts + ds * ds, tu + du * du)
+ });
+ let rmss = (ts / n).sqrt();
+ let rmsu = (tu / n).sqrt();
+ println!("rms signed: {}", rmss);
+ println!("rms unsigned: {}", rmsu);
+}
diff --git a/examples/rms.rs b/examples/rms.rs
new file mode 100644
index 0000000..32e2b47
--- /dev/null
+++ b/examples/rms.rs
@@ -0,0 +1,47 @@
+// Hound -- A wav encoding and decoding library in Rust
+// Copyright (C) 2017 Ruud van Asseldonk
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// A copy of the License has been included in the root of the repository.
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This example computes the root mean square (rms) of an audio file with
+// integer or float samples, of at most 32 bits per sample. It is a slightly
+// more elaborate version of the example found in the readme, mostly useful for
+// checking whether Hound can read a specific file.
+
+extern crate hound;
+
+use std::env;
+use std::io;
+
+/// Compute the RMS of either integers or float samples.
+fn compute_rms<S, R>(reader: &mut hound::WavReader<R>) -> f64
+where
+ f64: From<S>,
+ S: hound::Sample,
+ R: io::Read,
+{
+ let sqr_sum = reader.samples::<S>().fold(0.0, |sqr_sum, s| {
+ let sample = f64::from(s.unwrap());
+ sqr_sum + sample * sample
+ });
+ (sqr_sum / reader.len() as f64).sqrt()
+}
+
+fn main() {
+ // Compute the RMS for all files given on the command line.
+ for fname in env::args().skip(1) {
+ let mut reader = hound::WavReader::open(&fname).unwrap();
+ let rms = match reader.spec().sample_format {
+ hound::SampleFormat::Float => compute_rms::<f32, _>(&mut reader),
+ hound::SampleFormat::Int => compute_rms::<i32, _>(&mut reader),
+ };
+ println!("{}: {:0.1} ({} samples)", fname, rms, reader.len());
+ }
+}
diff --git a/examples/wavstdout.rs b/examples/wavstdout.rs
new file mode 100644
index 0000000..475a44b
--- /dev/null
+++ b/examples/wavstdout.rs
@@ -0,0 +1,31 @@
+// Generate endless screeching noise to stdout
+
+// Usage: cargo run --example wavstdout | mpv -
+
+extern crate hound;
+use std::io::Write;
+
+fn main() {
+ let spec = hound::WavSpec {
+ bits_per_sample: 16,
+ channels: 1,
+ sample_format: hound::SampleFormat::Int,
+ sample_rate: 16000,
+ };
+
+ let v = spec.into_header_for_infinite_file();
+
+ let so = std::io::stdout();
+ let mut so = so.lock();
+ so.write_all(&v[..]).unwrap();
+
+ loop {
+ for i in 0..126 {
+ use hound::Sample;
+ let x : i16 = (i * 256) as i16;
+ if x.write(&mut so, 16).is_err() {
+ return;
+ }
+ }
+ }
+}
diff --git a/license b/license
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/license
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/readme.md b/readme.md
new file mode 100644
index 0000000..9b85909
--- /dev/null
+++ b/readme.md
@@ -0,0 +1,85 @@
+Hound
+=====
+A wav encoding and decoding library in Rust.
+
+[![Crates.io version][crate-img]][crate]
+[![Changelog][changelog-img]](changelog.md)
+[![Documentation][docs-img]][docs]
+
+Hound can read and write the WAVE audio format, an ubiquitous format for raw,
+uncompressed audio. The main motivation to write it was to test
+[Claxon][claxon], a FLAC decoding library written in Rust.
+
+Examples
+--------
+The following example renders a 440 Hz sine wave, and stores it as a mono wav
+file with a sample rate of 44.1 kHz and 16 bits per sample.
+
+```rust
+use std::f32::consts::PI;
+use std::i16;
+use hound;
+
+let spec = hound::WavSpec {
+ channels: 1,
+ sample_rate: 44100,
+ bits_per_sample: 16,
+ sample_format: hound::SampleFormat::Int,
+};
+let mut writer = hound::WavWriter::create("sine.wav", spec).unwrap();
+for t in (0 .. 44100).map(|x| x as f32 / 44100.0) {
+ let sample = (t * 440.0 * 2.0 * PI).sin();
+ let amplitude = i16::MAX as f32;
+ writer.write_sample((sample * amplitude) as i16).unwrap();
+}
+```
+
+The file is finalized implicitly when the writer is dropped, call
+`writer.finalize()` to observe errors.
+
+The following example computes the root mean square (RMS) of an audio file with
+at most 16 bits per sample.
+
+```rust
+use hound;
+
+let mut reader = hound::WavReader::open("testsamples/pop.wav").unwrap();
+let sqr_sum = reader.samples::<i16>()
+ .fold(0.0, |sqr_sum, s| {
+ let sample = s.unwrap() as f64;
+ sqr_sum + sample * sample
+});
+println!("RMS is {}", (sqr_sum / reader.len() as f64).sqrt());
+```
+
+Features
+--------
+
+| | Read | Write |
+|-----------------|---------------------------------------------------------|-----------------------------------------|
+| Format | `PCMWAVEFORMAT`, `WAVEFORMATEX`, `WAVEFORMATEXTENSIBLE` | `PCMWAVEFORMAT`, `WAVEFORMATEXTENSIBLE` |
+| Encoding | Integer PCM, IEEE Float | Integer PCM, IEEE Float |
+| Bits per sample | 8, 16, 24, 32 (integer), 32 (float) | 8, 16, 24, 32 (integer), 32 (float) |
+
+Contributing
+------------
+Contributions in the form of bug reports, feature requests, or pull requests are
+welcome. See [contributing.md](contributing.md).
+
+License
+-------
+Hound is licensed under the [Apache 2.0][apache2] license. It may be used in
+free software as well as closed-source applications, both for commercial and
+non-commercial use under the conditions given in the license. If you want to
+use Hound in your GPLv2-licensed software, you can add an [exception][exception]
+to your copyright notice. Please do not open an issue if you disagree with the
+choice of license.
+
+[crate-img]: https://img.shields.io/crates/v/hound.svg
+[crate]: https://crates.io/crates/hound
+[changelog-img]: https://img.shields.io/badge/changelog-online-blue.svg
+[docs-img]: https://img.shields.io/badge/docs-online-blue.svg
+[docs]: https://docs.rs/hound
+[claxon]: https://github.com/ruuda/claxon
+[apache2]: https://www.apache.org/licenses/LICENSE-2.0
+[exception]: https://www.gnu.org/licenses/gpl-faq.html#GPLIncompatibleLibs
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
new file mode 100644
index 0000000..072ab04
--- /dev/null
+++ b/rust-toolchain.toml
@@ -0,0 +1,5 @@
+[toolchain]
+# Note, this is the Minimum Supported Rust Version. We build with this by
+# default to ensure we don't accidentally break it, but of course you should be
+# able to build with more recent versions.
+channel = "1.40.0"
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..fe435cb
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,925 @@
+// Hound -- A wav encoding and decoding library in Rust
+// Copyright (C) 2015 Ruud van Asseldonk
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// A copy of the License has been included in the root of the repository.
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Hound, a wav encoding and decoding library.
+//!
+//! Examples
+//! ========
+//!
+//! The following example renders a 440 Hz sine wave, and stores it as as a
+//! mono wav file with a sample rate of 44.1 kHz and 16 bits per sample.
+//!
+//! ```
+//! use std::f32::consts::PI;
+//! use std::i16;
+//! use hound;
+//!
+//! let spec = hound::WavSpec {
+//! channels: 1,
+//! sample_rate: 44100,
+//! bits_per_sample: 16,
+//! sample_format: hound::SampleFormat::Int,
+//! };
+//! let mut writer = hound::WavWriter::create("sine.wav", spec).unwrap();
+//! for t in (0 .. 44100).map(|x| x as f32 / 44100.0) {
+//! let sample = (t * 440.0 * 2.0 * PI).sin();
+//! let amplitude = i16::MAX as f32;
+//! writer.write_sample((sample * amplitude) as i16).unwrap();
+//! }
+//! writer.finalize().unwrap();
+//! ```
+//!
+//! The following example computes the root mean square (RMS) of an audio file
+//! with at most 16 bits per sample.
+//!
+//! ```
+//! use hound;
+//!
+//! let mut reader = hound::WavReader::open("testsamples/pop.wav").unwrap();
+//! let sqr_sum = reader.samples::<i16>()
+//! .fold(0.0, |sqr_sum, s| {
+//! let sample = s.unwrap() as f64;
+//! sqr_sum + sample * sample
+//! });
+//! println!("RMS is {}", (sqr_sum / reader.len() as f64).sqrt());
+//! ```
+
+#![warn(missing_docs)]
+
+use std::error;
+use std::fmt;
+use std::io;
+use std::result;
+use read::ReadExt;
+use write::WriteExt;
+
+mod read;
+mod write;
+
+pub use read::{WavReader, WavIntoSamples, WavSamples, read_wave_header};
+pub use write::{SampleWriter16, WavWriter};
+
+/// A type that can be used to represent audio samples.
+///
+/// Via this trait, decoding can be generic over `i8`, `i16`, `i32` and `f32`.
+///
+/// All integer formats with bit depths up to 32 bits per sample can be decoded
+/// into `i32`, but it takes up more memory. If you know beforehand that you
+/// will be reading a file with 16 bits per sample, then decoding into an `i16`
+/// will be sufficient.
+pub trait Sample: Sized {
+ /// Writes the audio sample to the WAVE data chunk.
+ fn write<W: io::Write>(self, writer: &mut W, bits: u16) -> Result<()>;
+
+ /// Writes the audio sample to the WAVE data chunk, zero padding the size of
+ /// the written sample out to `byte_width`.
+ fn write_padded<W: io::Write>(self, writer: &mut W, bits: u16, byte_width: u16) -> Result<()>;
+
+ /// Reads the audio sample from the WAVE data chunk.
+ fn read<R: io::Read>(reader: &mut R, SampleFormat, bytes: u16, bits: u16) -> Result<Self>;
+
+ /// Cast the sample to a 16-bit sample.
+ ///
+ /// This does not change the value of the sample, it only casts it. The
+ /// value is assumed to fit within the range. This is not verified,
+ /// truncation may occur.
+ fn as_i16(self) -> i16;
+}
+
+/// Converts an unsigned integer in the range 0-255 to a signed one in the range -128-127.
+///
+/// Presumably, the designers of the WAVE format did not like consistency. For
+/// all bit depths except 8, samples are stored as little-endian _signed_
+/// integers. However, an 8-bit sample is instead stored as an _unsigned_
+/// integer. Hound abstracts away this idiosyncrasy by providing only signed
+/// sample types.
+fn signed_from_u8(x: u8) -> i8 {
+ (x as i16 - 128) as i8
+}
+
+/// Converts a signed integer in the range -128-127 to an unsigned one in the range 0-255.
+fn u8_from_signed(x: i8) -> u8 {
+ (x as i16 + 128) as u8
+}
+
+#[test]
+fn u8_sign_conversion_is_bijective() {
+ for x in 0..255 {
+ assert_eq!(x, u8_from_signed(signed_from_u8(x)));
+ }
+ for x in -128..127 {
+ assert_eq!(x, signed_from_u8(u8_from_signed(x)));
+ }
+}
+
+/// Tries to cast the sample to an 8-bit signed integer, returning an error on overflow.
+#[inline(always)]
+fn narrow_to_i8(x: i32) -> Result<i8> {
+ use std::i8;
+ if x < i8::MIN as i32 || x > i8::MAX as i32 {
+ Err(Error::TooWide)
+ } else {
+ Ok(x as i8)
+ }
+}
+
+#[test]
+fn verify_narrow_to_i8() {
+ assert!(narrow_to_i8(127).is_ok());
+ assert!(narrow_to_i8(128).is_err());
+ assert!(narrow_to_i8(-128).is_ok());
+ assert!(narrow_to_i8(-129).is_err());
+}
+
+/// Tries to cast the sample to a 16-bit signed integer, returning an error on overflow.
+#[inline(always)]
+fn narrow_to_i16(x: i32) -> Result<i16> {
+ use std::i16;
+ if x < i16::MIN as i32 || x > i16::MAX as i32 {
+ Err(Error::TooWide)
+ } else {
+ Ok(x as i16)
+ }
+}
+
+#[test]
+fn verify_narrow_to_i16() {
+ assert!(narrow_to_i16(32767).is_ok());
+ assert!(narrow_to_i16(32768).is_err());
+ assert!(narrow_to_i16(-32768).is_ok());
+ assert!(narrow_to_i16(-32769).is_err());
+}
+
+/// Tries to cast the sample to a 24-bit signed integer, returning an error on overflow.
+#[inline(always)]
+fn narrow_to_i24(x: i32) -> Result<i32> {
+ if x < -(1 << 23) || x > (1 << 23) - 1 {
+ Err(Error::TooWide)
+ } else {
+ Ok(x)
+ }
+}
+
+#[test]
+fn verify_narrow_to_i24() {
+ assert!(narrow_to_i24(8_388_607).is_ok());
+ assert!(narrow_to_i24(8_388_608).is_err());
+ assert!(narrow_to_i24(-8_388_608).is_ok());
+ assert!(narrow_to_i24(-8_388_609).is_err());
+}
+
+impl Sample for i8 {
+ fn write<W: io::Write>(self, writer: &mut W, bits: u16) -> Result<()> {
+ self.write_padded(writer, bits, bits / 8)
+ }
+
+ fn write_padded<W: io::Write>(self, writer: &mut W, bits: u16, byte_width: u16) -> Result<()> {
+ match (bits, byte_width) {
+ (8, 1) => Ok(try!(writer.write_u8(u8_from_signed(self)))),
+ (16, 2) => Ok(try!(writer.write_le_i16(self as i16))),
+ (24, 3) => Ok(try!(writer.write_le_i24(self as i32))),
+ (24, 4) => Ok(try!(writer.write_le_i24_4(self as i32))),
+ (32, 4) => Ok(try!(writer.write_le_i32(self as i32))),
+ _ => Err(Error::Unsupported),
+ }
+ }
+
+ #[inline(always)]
+ fn as_i16(self) -> i16 {
+ self as i16
+ }
+
+ fn read<R: io::Read>(reader: &mut R, fmt: SampleFormat, bytes: u16, bits: u16) -> Result<i8> {
+ if fmt != SampleFormat::Int {
+ return Err(Error::InvalidSampleFormat);
+ }
+ match (bytes, bits) {
+ (1, 8) => Ok(try!(reader.read_u8().map(signed_from_u8))),
+ (n, _) if n > 1 => Err(Error::TooWide),
+ // TODO: add a genric decoder for any bit depth.
+ _ => Err(Error::Unsupported),
+ }
+ }
+}
+
+impl Sample for i16 {
+ fn write<W: io::Write>(self, writer: &mut W, bits: u16) -> Result<()> {
+ self.write_padded(writer, bits, bits / 8)
+ }
+
+ fn write_padded<W: io::Write>(self, writer: &mut W, bits: u16, byte_width: u16) -> Result<()> {
+ match (bits, byte_width) {
+ (8, 1) => Ok(try!(
+ writer.write_u8(u8_from_signed(try!(narrow_to_i8(self as i32))))
+ )),
+ (16, 2) => Ok(try!(writer.write_le_i16(self))),
+ (24, 3) => Ok(try!(writer.write_le_i24(self as i32))),
+ (24, 4) => Ok(try!(writer.write_le_i24_4(self as i32))),
+ (32, 4) => Ok(try!(writer.write_le_i32(self as i32))),
+ _ => Err(Error::Unsupported),
+ }
+ }
+
+ #[inline(always)]
+ fn as_i16(self) -> i16 {
+ self
+ }
+
+ fn read<R: io::Read>(reader: &mut R, fmt: SampleFormat, bytes: u16, bits: u16) -> Result<i16> {
+ if fmt != SampleFormat::Int {
+ return Err(Error::InvalidSampleFormat);
+ }
+ match (bytes, bits) {
+ (1, 8) => Ok(try!(reader.read_u8().map(signed_from_u8).map(|x| x as i16))),
+ (2, 16) => Ok(try!(reader.read_le_i16())),
+ (n, _) if n > 2 => Err(Error::TooWide),
+ // TODO: add a generic decoder for any bit depth.
+ _ => Err(Error::Unsupported),
+ }
+ }
+}
+
+impl Sample for i32 {
+ fn write<W: io::Write>(self, writer: &mut W, bits: u16) -> Result<()> {
+ self.write_padded(writer, bits, bits / 8)
+ }
+
+ fn write_padded<W: io::Write>(self, writer: &mut W, bits: u16, byte_width: u16) -> Result<()> {
+ match (bits, byte_width) {
+ (8, 1) => Ok(try!(
+ writer.write_u8(u8_from_signed(try!(narrow_to_i8(self))))
+ )),
+ (16, 2) => Ok(try!(writer.write_le_i16(try!(narrow_to_i16(self))))),
+ (24, 3) => Ok(try!(writer.write_le_i24(try!(narrow_to_i24(self))))),
+ (24, 4) => Ok(try!(writer.write_le_i24_4(try!(narrow_to_i24(self))))),
+ (32, 4) => Ok(try!(writer.write_le_i32(self))),
+ _ => Err(Error::Unsupported),
+ }
+ }
+
+ #[inline(always)]
+ fn as_i16(self) -> i16 {
+ self as i16
+ }
+
+ fn read<R: io::Read>(reader: &mut R, fmt: SampleFormat, bytes: u16, bits: u16) -> Result<i32> {
+ if fmt != SampleFormat::Int {
+ return Err(Error::InvalidSampleFormat);
+ }
+ match (bytes, bits) {
+ (1, 8) => Ok(try!(reader.read_u8().map(signed_from_u8).map(|x| x as i32))),
+ (2, 16) => Ok(try!(reader.read_le_i16().map(|x| x as i32))),
+ (3, 24) => Ok(try!(reader.read_le_i24())),
+ (4, 24) => Ok(try!(reader.read_le_i24_4())),
+ (4, 32) => Ok(try!(reader.read_le_i32())),
+ (n, _) if n > 4 => Err(Error::TooWide),
+ // TODO: add a generic decoder for any bit depth.
+ _ => Err(Error::Unsupported),
+ }
+ }
+}
+
+impl Sample for f32 {
+ fn write<W: io::Write>(self, writer: &mut W, bits: u16) -> Result<()> {
+ self.write_padded(writer, bits, bits / 8)
+ }
+
+ fn write_padded<W: io::Write>(self, writer: &mut W, bits: u16, byte_width: u16) -> Result<()> {
+ match (bits, byte_width) {
+ (32, 4) => Ok(try!(writer.write_le_f32(self))),
+ _ => Err(Error::Unsupported),
+ }
+ }
+
+ fn as_i16(self) -> i16 {
+ panic!("Calling as_i16 with an f32 is invalid.");
+ }
+
+ fn read<R: io::Read>(reader: &mut R, fmt: SampleFormat, bytes: u16, bits: u16) -> Result<Self> {
+ if fmt != SampleFormat::Float {
+ return Err(Error::InvalidSampleFormat);
+ }
+ match (bytes, bits) {
+ (4, 32) => Ok(try!(reader.read_le_f32())),
+ (n, _) if n > 4 => Err(Error::TooWide),
+ _ => Err(Error::Unsupported),
+ }
+ }
+}
+
+/// Specifies whether a sample is stored as an "IEEE Float" or an integer.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SampleFormat {
+ /// Wave files with the `WAVE_FORMAT_IEEE_FLOAT` format tag store samples as floating point
+ /// values.
+ ///
+ /// Values are normally in the range [-1.0, 1.0].
+ Float,
+ /// Wave files with the `WAVE_FORMAT_PCM` format tag store samples as integer values.
+ Int,
+}
+
+/// Specifies properties of the audio data.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct WavSpec {
+ /// The number of channels.
+ pub channels: u16,
+
+ /// The number of samples per second.
+ ///
+ /// A common value is 44100, this is 44.1 kHz which is used for CD audio.
+ pub sample_rate: u32,
+
+ /// The number of bits per sample.
+ ///
+ /// A common value is 16 bits per sample, which is used for CD audio.
+ pub bits_per_sample: u16,
+
+ /// Whether the wav's samples are float or integer values.
+ pub sample_format: SampleFormat,
+}
+
+/// Specifies properties of the audio data, as well as the layout of the stream.
+#[derive(Clone, Copy)]
+pub struct WavSpecEx {
+ /// The normal information about the audio data.
+ ///
+ /// Bits per sample here is the number of _used_ bits per sample, not the
+ /// number of bits used to _store_ a sample.
+ pub spec: WavSpec,
+
+ /// The number of bytes used to store a sample.
+ pub bytes_per_sample: u16,
+}
+
+/// The error type for operations on `WavReader` and `WavWriter`.
+#[derive(Debug)]
+pub enum Error {
+ /// An IO error occured in the underlying reader or writer.
+ IoError(io::Error),
+ /// Ill-formed WAVE data was encountered.
+ FormatError(&'static str),
+ /// The sample has more bits than the destination type.
+ ///
+ /// When iterating using the `samples` iterator, this means that the
+ /// destination type (produced by the iterator) is not wide enough to hold
+ /// the sample. When writing, this means that the sample cannot be written,
+ /// because it requires more bits than the bits per sample specified.
+ TooWide,
+ /// The number of samples written is not a multiple of the number of channels.
+ UnfinishedSample,
+ /// The format is not supported.
+ Unsupported,
+ /// The sample format is different than the destination format.
+ ///
+ /// When iterating using the `samples` iterator, this means the destination
+ /// type (produced by the iterator) has a different sample format than the
+ /// samples in the wav file.
+ ///
+ /// For example, this will occur if the user attempts to produce `i32`
+ /// samples (which have a `SampleFormat::Int`) from a wav file that
+ /// contains floating point data (`SampleFormat::Float`).
+ InvalidSampleFormat,
+}
+
+impl fmt::Display for Error {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {
+ match *self {
+ Error::IoError(ref err) => err.fmt(formatter),
+ Error::FormatError(reason) => {
+ try!(formatter.write_str("Ill-formed WAVE file: "));
+ formatter.write_str(reason)
+ }
+ Error::TooWide => {
+ formatter.write_str("The sample has more bits than the destination type.")
+ }
+ Error::UnfinishedSample => {
+ formatter.write_str(
+ "The number of samples written is not a multiple of the number of channels.")
+ }
+ Error::Unsupported => {
+ formatter.write_str("The wave format of the file is not supported.")
+ }
+ Error::InvalidSampleFormat => {
+ formatter.write_str("The sample format differs from the destination format.")
+ }
+ }
+ }
+}
+
+impl error::Error for Error {
+ fn description(&self) -> &str {
+ match *self {
+ Error::IoError(ref err) => err.description(),
+ Error::FormatError(reason) => reason,
+ Error::TooWide => "the sample has more bits than the destination type",
+ Error::UnfinishedSample => "the number of samples written is not a multiple of the number of channels",
+ Error::Unsupported => "the wave format of the file is not supported",
+ Error::InvalidSampleFormat => "the sample format differs from the destination format",
+ }
+ }
+
+ fn cause(&self) -> Option<&error::Error> {
+ match *self {
+ Error::IoError(ref err) => Some(err),
+ Error::FormatError(_) => None,
+ Error::TooWide => None,
+ Error::UnfinishedSample => None,
+ Error::Unsupported => None,
+ Error::InvalidSampleFormat => None,
+ }
+ }
+}
+
+impl From<io::Error> for Error {
+ fn from(err: io::Error) -> Error {
+ Error::IoError(err)
+ }
+}
+
+/// A type for results generated by Hound where the error type is hard-wired.
+pub type Result<T> = result::Result<T, Error>;
+
+// The WAVEFORMATEXTENSIBLE struct can contain several subformats.
+// These are identified by a GUID. The various GUIDS can be found in the file
+// mmreg.h that is part of the Windows SDK. The following GUIDS are defined:
+// - PCM: 00000001-0000-0010-8000-00aa00389b71
+// - IEEE_FLOAT: 00000003-0000-0010-8000-00aa00389b71
+// When written to a wav file, the byte order of a GUID is native for the first
+// three sections, which is assumed to be little endian, and big endian for the
+// last 8-byte section (which does contain a hyphen, for reasons unknown to me).
+
+/// Subformat type for PCM audio with integer samples.
+const KSDATAFORMAT_SUBTYPE_PCM: [u8; 16] = [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80,
+ 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71];
+
+/// Subformat type for IEEE_FLOAT audio with float samples.
+const KSDATAFORMAT_SUBTYPE_IEEE_FLOAT: [u8; 16] = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
+ 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71];
+
+
+impl WavSpec {
+ /// Get "stand-alone" wav header representing infinite or unknown size wav file.
+ /// Use this if you need to write audio data to non-seekable sinks (like stdout).
+ ///
+ /// Actual samples are supposed to be written using low-level [`Sample::write`] call.
+ ///
+ /// Such wav files are produced e.g. by FFmpeg and have `0xFFFFFFFF` instead of chunk sizes.
+ ///
+ /// Note that such files may be non-standard. Consider using [`WavWriter`] for better API.
+ ///
+ /// Example:
+ ///
+ /// ```no_run
+ /// extern crate hound;
+ /// use std::io::Write;
+ ///
+ /// let spec = hound::WavSpec {
+ /// bits_per_sample: 16,
+ /// channels: 1,
+ /// sample_format: hound::SampleFormat::Int,
+ /// sample_rate: 16000,
+ /// };
+ ///
+ /// let v = spec.into_header_for_infinite_file();
+ ///
+ /// let so = std::io::stdout();
+ /// let mut so = so.lock();
+ /// so.write_all(&v[..]).unwrap();
+ ///
+ /// loop {
+ /// for i in 0..126 {
+ /// let x : i16 = (i * 256) as i16;
+ /// hound::Sample::write(x, &mut so, 16).unwrap();
+ /// }
+ /// }
+ /// ```
+ pub fn into_header_for_infinite_file(self) -> Vec<u8> {
+ let mut c = std::io::Cursor::new(Vec::with_capacity(0x44));
+ {
+ let w = WavWriter::new(&mut c, self);
+ drop(w);
+ }
+ let mut v = c.into_inner();
+
+ // Set WAVE chunk size to a special signal value
+ v[4] = 0xFF; v[5] = 0xFF; v[6] = 0xFF; v[7] = 0xFF;
+
+ // Detect fmt size, get offset of data chunk's size and set it to signal value
+ if v[16] == 0x10 {
+ // pcm wave
+ v[0x28] = 0xFF; v[0x29] = 0xFF; v[0x2A] = 0xFF; v[0x2B] = 0xFF;
+ } else if v[16] == 0x28 {
+ // extensible
+ v[0x40] = 0xFF; v[0x41] = 0xFF; v[0x42] = 0xFF; v[0x43] = 0xFF;
+ } else {
+ unreachable!()
+ }
+
+ v
+ }
+}
+
+#[test]
+fn write_read_i16_is_lossless() {
+ let mut buffer = io::Cursor::new(Vec::new());
+ let write_spec = WavSpec {
+ channels: 2,
+ sample_rate: 44100,
+ bits_per_sample: 16,
+ sample_format: SampleFormat::Int,
+ };
+
+ {
+ let mut writer = WavWriter::new(&mut buffer, write_spec).unwrap();
+ for s in -1024_i16..1024 {
+ writer.write_sample(s).unwrap();
+ }
+ writer.finalize().unwrap();
+ }
+
+ {
+ buffer.set_position(0);
+ let mut reader = WavReader::new(&mut buffer).unwrap();
+ assert_eq!(write_spec, reader.spec());
+ assert_eq!(reader.len(), 2048);
+ for (expected, read) in (-1024_i16..1024).zip(reader.samples()) {
+ assert_eq!(expected, read.unwrap());
+ }
+ }
+}
+
+#[test]
+fn write_read_i16_via_sample_writer_is_lossless() {
+ let mut buffer = io::Cursor::new(Vec::new());
+ let write_spec = WavSpec {
+ channels: 2,
+ sample_rate: 44100,
+ bits_per_sample: 16,
+ sample_format: SampleFormat::Int,
+ };
+
+ {
+ let mut writer = WavWriter::new(&mut buffer, write_spec).unwrap();
+ {
+ {
+ let mut sample_writer = writer.get_i16_writer(1024);
+ for s in -1024_i16..0 {
+ sample_writer.write_sample(s);
+ }
+ sample_writer.flush().unwrap();
+ }
+
+ {
+ let mut sample_writer = writer.get_i16_writer(1024);
+ for s in 0i16..1024 {
+ unsafe { sample_writer.write_sample_unchecked(s); }
+ }
+ sample_writer.flush().unwrap();
+ }
+ }
+ writer.finalize().unwrap();
+ }
+
+ {
+ buffer.set_position(0);
+ let mut reader = WavReader::new(&mut buffer).unwrap();
+ assert_eq!(write_spec, reader.spec());
+ assert_eq!(reader.len(), 2048);
+ for (expected, read) in (-1024_i16..1024).zip(reader.samples()) {
+ assert_eq!(expected, read.unwrap());
+ }
+ }
+}
+
+#[test]
+fn write_read_i8_is_lossless() {
+ let mut buffer = io::Cursor::new(Vec::new());
+ let write_spec = WavSpec {
+ channels: 16,
+ sample_rate: 48000,
+ bits_per_sample: 8,
+ sample_format: SampleFormat::Int,
+ };
+
+ // Write `i8` samples.
+ {
+ let mut writer = WavWriter::new(&mut buffer, write_spec).unwrap();
+ // Iterate over i16 because we cannot specify the upper bound otherwise.
+ for s in -128_i16..127 + 1 {
+ writer.write_sample(s as i8).unwrap();
+ }
+ writer.finalize().unwrap();
+ }
+
+ // Then read them into `i16`.
+ {
+ buffer.set_position(0);
+ let mut reader = WavReader::new(&mut buffer).unwrap();
+ assert_eq!(write_spec, reader.spec());
+ assert_eq!(reader.len(), 256);
+ for (expected, read) in (-128_i16..127 + 1).zip(reader.samples()) {
+ assert_eq!(expected, read.unwrap());
+ }
+ }
+}
+
+#[test]
+fn write_read_i24_is_lossless() {
+ let mut buffer = io::Cursor::new(Vec::new());
+ let write_spec = WavSpec {
+ channels: 16,
+ sample_rate: 96000,
+ bits_per_sample: 24,
+ sample_format: SampleFormat::Int,
+ };
+
+ // Write `i32` samples, but with at most 24 bits per sample.
+ {
+ let mut writer = WavWriter::new(&mut buffer, write_spec).unwrap();
+ for s in -128_i32..127 + 1 {
+ writer.write_sample(s * 256 * 256).unwrap();
+ }
+ writer.finalize().unwrap();
+ }
+
+ // Then read them into `i32`. This should extend the sign in the correct
+ // manner.
+ {
+ buffer.set_position(0);
+ let mut reader = WavReader::new(&mut buffer).unwrap();
+ assert_eq!(write_spec, reader.spec());
+ assert_eq!(reader.len(), 256);
+ for (expected, read) in (-128_i32..127 + 1)
+ .map(|x| x * 256 * 256)
+ .zip(reader.samples()) {
+ assert_eq!(expected, read.unwrap());
+ }
+ }
+}
+#[test]
+fn write_read_f32_is_lossless() {
+ let mut buffer = io::Cursor::new(Vec::new());
+ let write_spec = WavSpec {
+ channels: 2,
+ sample_rate: 44100,
+ bits_per_sample: 32,
+ sample_format: SampleFormat::Float,
+ };
+
+ {
+ let mut writer = WavWriter::new(&mut buffer, write_spec).unwrap();
+ for s in 1_u32..257 {
+ writer.write_sample(1.0f32 / s as f32).unwrap();
+ }
+ writer.finalize().unwrap();
+ }
+
+ {
+ buffer.set_position(0);
+ let mut reader = WavReader::new(&mut buffer).unwrap();
+ assert_eq!(write_spec, reader.spec());
+ assert_eq!(reader.len(), 256);
+ for (expected, read) in (1..257)
+ .map(|x| 1.0_f32 / x as f32)
+ .zip(reader.samples()) {
+ assert_eq!(expected, read.unwrap());
+ }
+ }
+}
+
+#[test]
+#[should_panic]
+fn no_32_bps_for_float_sample_format_panics() {
+ let mut buffer = io::Cursor::new(Vec::new());
+ let write_spec = WavSpec {
+ channels: 2,
+ sample_rate: 44100,
+ bits_per_sample: 16, // will panic, because value must be 32 for floating point
+ sample_format: SampleFormat::Float,
+ };
+
+ WavWriter::new(&mut buffer, write_spec).unwrap();
+}
+
+#[test]
+fn flush_should_produce_valid_file() {
+ use std::mem;
+ use std::io::Seek;
+
+ let mut buffer = io::Cursor::new(Vec::new());
+ let samples = &[2, 4, 5, 7, 11, 13];
+
+ {
+ let spec = WavSpec {
+ channels: 2,
+ sample_rate: 44100,
+ bits_per_sample: 16,
+ sample_format: SampleFormat::Int,
+ };
+ let mut writer = WavWriter::new(&mut buffer, spec).unwrap();
+
+ for &x in samples {
+ writer.write_sample(x).unwrap();
+ }
+
+ // We should be able to see everything up to the flush later.
+ writer.flush().unwrap();
+
+ // Write more samples. These should be in the buffer, but not read by the
+ // reader if we don't finalize the writer.
+ writer.write_sample(17).unwrap();
+ writer.write_sample(19).unwrap();
+
+ mem::forget(writer);
+ }
+
+ buffer.seek(io::SeekFrom::Start(0)).unwrap();
+
+ let mut reader = WavReader::new(&mut buffer).unwrap();
+ let read_samples: Vec<i16> = reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // We expect to see all samples up to the flush, but not the later ones.
+ assert_eq!(&read_samples[..], &samples[..]);
+}
+
+#[test]
+fn new_append_should_append() {
+ use std::io::Seek;
+
+ let mut buffer = io::Cursor::new(Vec::new());
+ let samples = &[2, 5, 7, 11];
+ let spec = WavSpec {
+ channels: 2,
+ sample_rate: 44100,
+ bits_per_sample: 16,
+ sample_format: SampleFormat::Int,
+ };
+
+ // Write initial file.
+ {
+ let mut writer = WavWriter::new(&mut buffer, spec).unwrap();
+ for s in samples { writer.write_sample(*s).unwrap(); }
+ }
+
+ buffer.seek(io::SeekFrom::Start(0)).unwrap();
+
+ // Append samples (the same ones a second time).
+ {
+ let mut writer = WavWriter::new_append(&mut buffer).unwrap();
+ assert_eq!(writer.spec(), spec);
+ for s in samples { writer.write_sample(*s).unwrap(); }
+ }
+
+ buffer.seek(io::SeekFrom::Start(0)).unwrap();
+
+ let mut reader = WavReader::new(&mut buffer).unwrap();
+ let read_samples: Vec<i16> = reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // We expect to see all samples up to the flush, but not the later ones.
+ assert_eq!(&read_samples[..], &[2, 5, 7, 11, 2, 5, 7, 11]);
+}
+
+#[test]
+fn new_append_does_not_corrupt_files() {
+ use std::io::Read;
+ use std::fs;
+
+ let sample_files = [
+ "testsamples/pcmwaveformat-16bit-44100Hz-mono-extra.wav",
+ "testsamples/pcmwaveformat-16bit-44100Hz-mono.wav",
+ "testsamples/pcmwaveformat-8bit-44100Hz-mono.wav",
+ "testsamples/pop.wav",
+ "testsamples/waveformatex-16bit-44100Hz-mono-extra.wav",
+ "testsamples/waveformatex-16bit-44100Hz-mono.wav",
+ "testsamples/waveformatex-16bit-44100Hz-stereo.wav",
+ "testsamples/waveformatextensible-24bit-192kHz-mono.wav",
+ "testsamples/waveformatextensible-32bit-48kHz-stereo.wav",
+ "testsamples/nonstandard-01.wav",
+ "testsamples/nonstandard-02.wav",
+ "testsamples/waveformatex-8bit-11025Hz-mono.wav",
+ ];
+
+ for fname in &sample_files {
+ print!("testing {} ... ", fname);
+
+ let mut buffer = Vec::new();
+ let mut f = fs::File::open(fname).unwrap();
+ f.read_to_end(&mut buffer).unwrap();
+
+ let samples_orig: Vec<i32>;
+ let samples_after: Vec<i32>;
+
+ // Read samples first.
+ let mut cursor = io::Cursor::new(buffer);
+ {
+ let mut reader = WavReader::new(&mut cursor).unwrap();
+ samples_orig = reader.samples().map(|r| r.unwrap()).collect();
+ }
+ buffer = cursor.into_inner();
+
+ // Open in append mode and append one sample.
+ let mut cursor = io::Cursor::new(buffer);
+ {
+ let mut writer = WavWriter::new_append(&mut cursor).unwrap();
+ writer.write_sample(41_i8).unwrap();
+ writer.write_sample(43_i8).unwrap();
+ }
+ buffer = cursor.into_inner();
+
+ {
+ let cursor = io::Cursor::new(buffer);
+ let mut reader = WavReader::new(cursor)
+ .expect("Reading wav failed after append.");
+ samples_after = reader.samples().map(|r| r.unwrap()).collect();
+ }
+
+ assert_eq!(&samples_orig[..], &samples_after[..samples_orig.len()]);
+ assert_eq!(samples_after[samples_after.len() - 2], 41_i32);
+ assert_eq!(samples_after[samples_after.len() - 1], 43_i32);
+
+ println!("ok");
+ }
+}
+
+#[cfg(test)]
+fn assert_contents(fname: &str, expected: &[i16]) {
+ let mut reader = WavReader::open(fname).unwrap();
+ let samples: Vec<i16> = reader.samples().map(|s| s.unwrap()).collect();
+ assert_eq!(&samples[..], expected);
+}
+
+#[test]
+fn append_works_on_files() {
+ use std::fs;
+
+ let spec = WavSpec {
+ channels: 1,
+ sample_rate: 44100,
+ bits_per_sample: 16,
+ sample_format: SampleFormat::Int,
+ };
+
+ let mut writer = WavWriter::create("append.wav", spec).unwrap();
+ writer.write_sample(11_i16).unwrap();
+ writer.write_sample(13_i16).unwrap();
+ writer.write_sample(17_i16).unwrap();
+ writer.finalize().unwrap();
+
+ assert_contents("append.wav", &[11, 13, 17]);
+
+ let len = fs::metadata("append.wav").unwrap().len();
+
+ let mut appender = WavWriter::append("append.wav").unwrap();
+
+ appender.write_sample(19_i16).unwrap();
+ appender.write_sample(23_i16).unwrap();
+ appender.finalize().unwrap();
+
+ // We appended four bytes of audio data (2 16-bit samples), so the file
+ // should have grown by 4 bytes.
+ assert_eq!(fs::metadata("append.wav").unwrap().len(), len + 4);
+
+ assert_contents("append.wav", &[11, 13, 17, 19, 23]);
+}
+
+#[cfg(test)]
+#[test]
+fn test_into_header_for_infinite_file() {
+ let spec = WavSpec {
+ bits_per_sample: 16,
+ channels: 1,
+ sample_format: SampleFormat::Int,
+ sample_rate: 16000,
+ };
+ let v = spec.into_header_for_infinite_file();
+ assert_eq!(&v[..], &b"RIFF\xFF\xFF\xFF\xFFWAVE\
+fmt \x10\x00\x00\x00\x01\x00\x01\x00\x80\x3e\x00\x00\x00\x7d\x00\x00\x02\x00\x10\x00\
+data\xFF\xFF\xFF\xFF"[..]);
+
+ let spec = WavSpec {
+ bits_per_sample: 16,
+ channels: 10,
+ sample_format: SampleFormat::Int,
+ sample_rate: 16000,
+ };
+ let v = spec.into_header_for_infinite_file();
+ assert_eq!(&v[..], &b"RIFF\xFF\xFF\xFF\xFFWAVE\
+fmt \x28\x00\x00\x00\xfe\xff\x0a\x00\x80\x3e\x00\x00\x00\xe2\x04\x00\
+\x14\x00\x10\x00\x16\x00\x10\x00\xff\x03\x00\x00\x01\x00\x00\x00\
+\x00\x00\x10\x00\x80\x00\x00\xaa\x00\x38\x9b\x71\
+data\xFF\xFF\xFF\xFF"[..]);
+}
diff --git a/src/read.rs b/src/read.rs
new file mode 100644
index 0000000..9c9a9a4
--- /dev/null
+++ b/src/read.rs
@@ -0,0 +1,1244 @@
+// Hound -- A wav encoding and decoding library in Rust
+// Copyright (C) 2015 Ruud van Asseldonk
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// A copy of the License has been included in the root of the repository.
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::cmp;
+use std::fs;
+use std::io;
+use std::marker;
+use std::path;
+use super::{Error, Result, Sample, SampleFormat, WavSpec, WavSpecEx};
+
+/// Extends the functionality of `io::Read` with additional methods.
+///
+/// The methods may be used on any type that implements `io::Read`.
+pub trait ReadExt: io::Read {
+ /// Reads as many bytes as `buf` is long.
+ ///
+ /// This may issue multiple `read` calls internally. An error is returned
+ /// if `read` read 0 bytes before the buffer is full.
+ // TODO: There is an RFC proposing a method like this for the standard library.
+ fn read_into(&mut self, buf: &mut [u8]) -> io::Result<()>;
+
+ /// Reads 4 bytes and returns them in an array.
+ fn read_4_bytes(&mut self) -> io::Result<[u8; 4]>;
+
+ /// Skip over `n` bytes.
+ fn skip_bytes(&mut self, n: usize) -> io::Result<()>;
+
+ /// Reads a single byte and interprets it as an 8-bit signed integer.
+ fn read_i8(&mut self) -> io::Result<i8>;
+
+ /// Reads a single byte and interprets it as an 8-bit unsigned integer.
+ fn read_u8(&mut self) -> io::Result<u8>;
+
+ /// Reads two bytes and interprets them as a little-endian 16-bit signed integer.
+ fn read_le_i16(&mut self) -> io::Result<i16>;
+
+ /// Reads two bytes and interprets them as a little-endian 16-bit unsigned integer.
+ fn read_le_u16(&mut self) -> io::Result<u16>;
+
+ /// Reads three bytes and interprets them as a little-endian 24-bit signed integer.
+ ///
+ /// The sign bit will be extended into the most significant byte.
+ fn read_le_i24(&mut self) -> io::Result<i32>;
+
+ /// Reads four bytes and interprets them as a little-endian 24-bit signed integer.
+ ///
+ /// The sign bit will be extended into the most significant byte.
+ fn read_le_i24_4(&mut self) -> io::Result<i32>;
+
+ /// Reads three bytes and interprets them as a little-endian 24-bit unsigned integer.
+ ///
+ /// The most significant byte will be 0.
+ fn read_le_u24(&mut self) -> io::Result<u32>;
+
+ /// Reads four bytes and interprets them as a little-endian 32-bit signed integer.
+ fn read_le_i32(&mut self) -> io::Result<i32>;
+
+ /// Reads four bytes and interprets them as a little-endian 32-bit unsigned integer.
+ fn read_le_u32(&mut self) -> io::Result<u32>;
+
+ /// Reads four bytes and interprets them as a little-endian 32-bit IEEE float.
+ fn read_le_f32(&mut self) -> io::Result<f32>;
+}
+
+impl<R> ReadExt for R
+ where R: io::Read
+{
+ #[inline(always)]
+ fn read_into(&mut self, buf: &mut [u8]) -> io::Result<()> {
+ let mut n = 0;
+ while n < buf.len() {
+ let progress = try!(self.read(&mut buf[n..]));
+ if progress > 0 {
+ n += progress;
+ } else {
+ return Err(io::Error::new(io::ErrorKind::Other, "Failed to read enough bytes."));
+ }
+ }
+ Ok(())
+ }
+
+ #[inline(always)]
+ fn skip_bytes(&mut self, n: usize) -> io::Result<()> {
+ // Read from the input in chunks of 1024 bytes at a time, and discard
+ // the result. 1024 is a tradeoff between doing a lot of calls, and
+ // using too much stack space. This method is not in a hot path, so it
+ // can afford to do this.
+ let mut n_read = 0;
+ let mut buf = [0u8; 1024];
+ while n_read < n {
+ let end = cmp::min(n - n_read, 1024);
+ let progress = try!(self.read(&mut buf[0..end]));
+ if progress > 0 {
+ n_read += progress;
+ } else {
+ return Err(io::Error::new(io::ErrorKind::Other, "Failed to read enough bytes."));
+ }
+ }
+ Ok(())
+ }
+
+ #[inline(always)]
+ fn read_4_bytes(&mut self) -> io::Result<[u8; 4]> {
+ let mut buf = [0_u8; 4];
+ try!(self.read_into(&mut buf[..]));
+ Ok(buf)
+ }
+
+ #[inline(always)]
+ fn read_i8(&mut self) -> io::Result<i8> {
+ self.read_u8().map(|x| x as i8)
+ }
+
+ #[inline(always)]
+ fn read_u8(&mut self) -> io::Result<u8> {
+ let mut buf = [0u8; 1];
+ try!(self.read_into(&mut buf));
+ Ok(buf[0])
+ }
+
+ #[inline(always)]
+ fn read_le_i16(&mut self) -> io::Result<i16> {
+ self.read_le_u16().map(|x| x as i16)
+ }
+
+ #[inline(always)]
+ fn read_le_u16(&mut self) -> io::Result<u16> {
+ let mut buf = [0u8; 2];
+ try!(self.read_into(&mut buf));
+ Ok((buf[1] as u16) << 8 | (buf[0] as u16))
+ }
+
+ #[inline(always)]
+ fn read_le_i24(&mut self) -> io::Result<i32> {
+ self.read_le_u24().map(|x|
+ // Test the sign bit, if it is set, extend the sign bit into the
+ // most significant byte.
+ if x & (1 << 23) == 0 {
+ x as i32
+ } else {
+ (x | 0xff_00_00_00) as i32
+ }
+ )
+ }
+
+ #[inline(always)]
+ fn read_le_i24_4(&mut self) -> io::Result<i32> {
+ self.read_le_u32().map(|x|
+ // Test the sign bit, if it is set, extend the sign bit into the
+ // most significant byte. Otherwise, mask out the top byte.
+ if x & (1 << 23) == 0 {
+ (x & 0x00_ff_ff_ff) as i32
+ } else {
+ (x | 0xff_00_00_00) as i32
+ }
+ )
+ }
+
+ #[inline(always)]
+ fn read_le_u24(&mut self) -> io::Result<u32> {
+ let mut buf = [0u8; 3];
+ try!(self.read_into(&mut buf));
+ Ok((buf[2] as u32) << 16 | (buf[1] as u32) << 8 | (buf[0] as u32))
+ }
+
+ #[inline(always)]
+ fn read_le_i32(&mut self) -> io::Result<i32> {
+ self.read_le_u32().map(|x| x as i32)
+ }
+
+ #[inline(always)]
+ fn read_le_u32(&mut self) -> io::Result<u32> {
+ let mut buf = [0u8; 4];
+ try!(self.read_into(&mut buf));
+ Ok((buf[3] as u32) << 24 | (buf[2] as u32) << 16 |
+ (buf[1] as u32) << 8 | (buf[0] as u32) << 0)
+ }
+
+ #[inline(always)]
+ fn read_le_f32(&mut self) -> io::Result<f32> {
+ let mut buf = [0u8; 4];
+ try!(self.read_into(&mut buf));
+ Ok(f32::from_le_bytes(buf))
+ }
+}
+
+/// The different chunks that a WAVE file can contain.
+enum ChunkKind {
+ Fmt,
+ Fact,
+ Data,
+ Unknown,
+}
+
+/// Describes the structure of a chunk in the WAVE file.
+struct ChunkHeader {
+ pub kind: ChunkKind,
+ pub len: u32,
+}
+
+/// A reader that reads the WAVE format from the underlying reader.
+///
+/// A `WavReader` is a streaming reader. It reads data from the underlying
+/// reader on demand, and it reads no more than strictly necessary. No internal
+/// buffering is performed on the underlying reader, but this can easily be
+/// added by wrapping the reader in an `io::BufReader`. The `open` constructor
+/// takes care of this for you.
+pub struct WavReader<R> {
+ /// Specification of the file as found in the fmt chunk.
+ spec: WavSpec,
+
+ /// The number of bytes used to store a sample in the stream.
+ bytes_per_sample: u16,
+
+ /// The number of samples in the data chunk.
+ ///
+ /// The data chunk is limited to a 4 GiB length because its header has a
+ /// 32-bit length field. A sample takes at least one byte to store, so the
+ /// number of samples is always less than 2^32.
+ num_samples: u32,
+
+ /// The number of samples read so far.
+ samples_read: u32,
+
+ /// The reader from which the WAVE format is read.
+ reader: R,
+}
+
+/// An iterator that yields samples of type `S` read from a `WavReader`.
+///
+/// The type `S` must have at least as many bits as the bits per sample of the
+/// file, otherwise every iteration will return an error.
+pub struct WavSamples<'wr, R, S>
+ where R: 'wr
+{
+ reader: &'wr mut WavReader<R>,
+ phantom_sample: marker::PhantomData<S>,
+}
+
+/// An iterator that yields samples of type `S` read from a `WavReader`.
+///
+/// The type `S` must have at least as many bits as the bits per sample of the
+/// file, otherwise every iteration will return an error.
+pub struct WavIntoSamples<R, S> {
+ reader: WavReader<R>,
+ phantom_sample: marker::PhantomData<S>,
+}
+
+/// Reads the RIFF WAVE header, returns the supposed file size.
+///
+/// This function can be used to quickly check if the file could be a wav file
+/// by reading 12 bytes of the header. If an `Ok` is returned, the file is
+/// likely a wav file. If an `Err` is returned, it is definitely not a wav
+/// file.
+///
+/// The returned file size cannot be larger than 2<sup>32</sup> + 7 bytes.
+pub fn read_wave_header<R: io::Read>(reader: &mut R) -> Result<u64> {
+ // Every WAVE file starts with the four bytes 'RIFF' and a file length.
+ // TODO: the old approach of having a slice on the stack and reading
+ // into it is more cumbersome, but also avoids a heap allocation. Is
+ // the compiler smart enough to avoid the heap allocation anyway? I
+ // would not expect it to be.
+ if b"RIFF" != &try!(reader.read_4_bytes())[..] {
+ return Err(Error::FormatError("no RIFF tag found"));
+ }
+
+ let file_len = try!(reader.read_le_u32());
+
+ // Next four bytes indicate the file type, which should be WAVE.
+ if b"WAVE" != &try!(reader.read_4_bytes())[..] {
+ return Err(Error::FormatError("no WAVE tag found"));
+ }
+
+ // The stored file length does not include the "RIFF" magic and 4-byte
+ // length field, so the total size is 8 bytes more than what is stored.
+ Ok(file_len as u64 + 8)
+}
+
+/// Reads chunks until a data chunk is encountered.
+///
+/// Returns the information from the fmt chunk and the length of the data
+/// chunk in bytes. Afterwards, the reader will be positioned at the first
+/// content byte of the data chunk.
+pub fn read_until_data<R: io::Read>(mut reader: R) -> Result<(WavSpecEx, u32)> {
+ let mut spec_opt = None;
+
+ loop {
+ let header = try!(WavReader::read_chunk_header(&mut reader));
+ match header.kind {
+ ChunkKind::Fmt => {
+ let spec = try!(WavReader::read_fmt_chunk(&mut reader, header.len));
+ spec_opt = Some(spec);
+ }
+ ChunkKind::Fact => {
+ // All (compressed) non-PCM formats must have a fact chunk
+ // (Rev. 3 documentation). The chunk contains at least one
+ // value, the number of samples in the file.
+ //
+ // The number of samples field is redundant for sampled
+ // data, since the Data chunk indicates the length of the
+ // data. The number of samples can be determined from the
+ // length of the data and the container size as determined
+ // from the Format chunk.
+ // http://www-mmsp.ece.mcgill.ca/documents/audioformats/wave/wave.html
+ let _samples_per_channel = reader.read_le_u32();
+ }
+ ChunkKind::Data => {
+ // The "fmt" chunk must precede the "data" chunk. Any
+ // chunks that come after the data chunk will be ignored.
+ if let Some(spec) = spec_opt {
+ return Ok((spec, header.len));
+ } else {
+ return Err(Error::FormatError("missing fmt chunk"));
+ }
+ }
+ ChunkKind::Unknown => {
+ // Ignore the chunk; skip all of its bytes.
+ try!(reader.skip_bytes(header.len as usize));
+ }
+ }
+ // If no data chunk is ever encountered, the function will return
+ // via one of the try! macros that return an Err on end of file.
+ }
+}
+
+impl<R> WavReader<R>
+ where R: io::Read
+{
+ /// Attempts to read an 8-byte chunk header.
+ fn read_chunk_header(reader: &mut R) -> Result<ChunkHeader> {
+ let mut kind_str = [0; 4];
+ try!(reader.read_into(&mut kind_str));
+ let len = try!(reader.read_le_u32());
+
+ let kind = match &kind_str[..] {
+ b"fmt " => ChunkKind::Fmt,
+ b"fact" => ChunkKind::Fact,
+ b"data" => ChunkKind::Data,
+ _ => ChunkKind::Unknown,
+ };
+
+ Ok(ChunkHeader { kind: kind, len: len })
+ }
+
+ /// Reads the fmt chunk of the file, returns the information it provides.
+ fn read_fmt_chunk(reader: &mut R, chunk_len: u32) -> Result<WavSpecEx> {
+ // A minimum chunk length of at least 16 is assumed. Note: actually,
+ // the first 14 bytes contain enough information to fully specify the
+ // file. I have not encountered a file with a 14-byte fmt section
+ // though. If you ever encounter such file, please contact me.
+ if chunk_len < 16 {
+ return Err(Error::FormatError("invalid fmt chunk size"));
+ }
+
+ // Read the WAVEFORMAT struct, as defined at
+ // https://msdn.microsoft.com/en-us/library/ms713498.aspx.
+ // ```
+ // typedef struct {
+ // WORD wFormatTag;
+ // WORD nChannels;
+ // DWORD nSamplesPerSec;
+ // DWORD nAvgBytesPerSec;
+ // WORD nBlockAlign;
+ // } WAVEFORMAT;
+ // ```
+ // The WAVEFORMATEX struct has two more members, as defined at
+ // https://msdn.microsoft.com/en-us/library/ms713497.aspx
+ // ```
+ // typedef struct {
+ // WORD wFormatTag;
+ // WORD nChannels;
+ // DWORD nSamplesPerSec;
+ // DWORD nAvgBytesPerSec;
+ // WORD nBlockAlign;
+ // WORD wBitsPerSample;
+ // WORD cbSize;
+ // } WAVEFORMATEX;
+ // ```
+ // There is also PCMWAVEFORMAT as defined at
+ // https://msdn.microsoft.com/en-us/library/dd743663.aspx.
+ // ```
+ // typedef struct {
+ // WAVEFORMAT wf;
+ // WORD wBitsPerSample;
+ // } PCMWAVEFORMAT;
+ // ```
+ // In either case, the minimal length of the fmt section is 16 bytes,
+ // meaning that it does include the `wBitsPerSample` field. (The name
+ // is misleading though, because it is the number of bits used to store
+ // a sample, not all of the bits need to be valid for all versions of
+ // the WAVE format.)
+ let format_tag = try!(reader.read_le_u16());
+ let n_channels = try!(reader.read_le_u16());
+ let n_samples_per_sec = try!(reader.read_le_u32());
+ let n_bytes_per_sec = try!(reader.read_le_u32());
+ let block_align = try!(reader.read_le_u16());
+ let bits_per_sample = try!(reader.read_le_u16());
+
+ if n_channels == 0 {
+ return Err(Error::FormatError("file contains zero channels"));
+ }
+
+ let bytes_per_sample = block_align / n_channels;
+ // We allow bits_per_sample to be less than bytes_per_sample so that
+ // we can support things such as 24 bit samples in 4 byte containers.
+ if Some(bits_per_sample) > bytes_per_sample.checked_mul(8) {
+ return Err(Error::FormatError("sample bits exceeds size of sample"));
+ }
+
+ // This field is redundant, and may be ignored. We do validate it to
+ // fail early for ill-formed files.
+ if Some(n_bytes_per_sec) != (block_align as u32).checked_mul(n_samples_per_sec) {
+ return Err(Error::FormatError("inconsistent fmt chunk"));
+ }
+
+ // The bits per sample for a WAVEFORMAT struct is the number of bits
+ // used to store a sample. Therefore, it must be a multiple of 8.
+ if bits_per_sample % 8 != 0 {
+ return Err(Error::FormatError("bits per sample is not a multiple of 8"));
+ }
+
+ if bits_per_sample == 0 {
+ return Err(Error::FormatError("bits per sample is 0"));
+ }
+
+ let mut spec = WavSpec {
+ channels: n_channels,
+ sample_rate: n_samples_per_sec,
+ bits_per_sample: bits_per_sample,
+ sample_format: SampleFormat::Int,
+ };
+
+ // The different format tag definitions can be found in mmreg.h that is
+ // part of the Windows SDK. The vast majority are esoteric vendor-
+ // specific formats. We handle only a few. The following values could
+ // be of interest:
+ const PCM: u16 = 0x0001;
+ const ADPCM: u16 = 0x0002;
+ const IEEE_FLOAT: u16 = 0x0003;
+ const EXTENSIBLE: u16 = 0xfffe;
+ // We may update our WavSpec based on more data we read from the header.
+ match format_tag {
+ PCM => try!(WavReader::read_wave_format_pcm(reader, chunk_len, &spec)),
+ ADPCM => return Err(Error::Unsupported),
+ IEEE_FLOAT => try!(WavReader::read_wave_format_ieee_float(reader, chunk_len, &mut spec)),
+ EXTENSIBLE => try!(WavReader::read_wave_format_extensible(reader, chunk_len, &mut spec)),
+ _ => return Err(Error::Unsupported),
+ };
+
+ Ok(WavSpecEx {
+ spec: spec,
+ bytes_per_sample: bytes_per_sample,
+ })
+ }
+
+ fn read_wave_format_pcm(mut reader: R, chunk_len: u32, spec: &WavSpec) -> Result<()> {
+ // When there is a PCMWAVEFORMAT struct, the chunk is 16 bytes long.
+ // The WAVEFORMATEX structs includes two extra bytes, `cbSize`.
+ let is_wave_format_ex = match chunk_len {
+ 16 => false,
+ 18 => true,
+ // Other sizes are unexpected, but such files do occur in the wild,
+ // and reading these files is still possible, so we allow this.
+ 40 => true,
+ _ => return Err(Error::FormatError("unexpected fmt chunk size")),
+ };
+
+ if is_wave_format_ex {
+ // `cbSize` can be used for non-PCM formats to specify the size of
+ // additional data. However, for WAVE_FORMAT_PCM, the member should
+ // be ignored, see https://msdn.microsoft.com/en-us/library/ms713497.aspx.
+ // Nonzero values do in fact occur in practice.
+ let _cb_size = try!(reader.read_le_u16());
+
+ // For WAVE_FORMAT_PCM in WAVEFORMATEX, only 8 or 16 bits per
+ // sample are valid according to
+ // https://msdn.microsoft.com/en-us/library/ms713497.aspx.
+ // 24 bits per sample is explicitly not valid inside a WAVEFORMATEX
+ // structure, but such files do occur in the wild nonetheless, and
+ // there is no good reason why we couldn't read them.
+ match spec.bits_per_sample {
+ 8 => {}
+ 16 => {}
+ 24 => {}
+ _ => return Err(Error::FormatError("bits per sample is not 8 or 16")),
+ }
+ }
+
+ // If the chunk len was longer than expected, ignore the additional bytes.
+ if chunk_len == 40 {
+ try!(reader.skip_bytes(22));
+ }
+ Ok(())
+ }
+
+ fn read_wave_format_ieee_float(mut reader: R, chunk_len: u32, spec: &mut WavSpec) -> Result<()> {
+ // When there is a PCMWAVEFORMAT struct, the chunk is 16 bytes long.
+ // The WAVEFORMATEX structs includes two extra bytes, `cbSize`.
+ let is_wave_format_ex = chunk_len == 18;
+
+ if !is_wave_format_ex && chunk_len != 16 {
+ return Err(Error::FormatError("unexpected fmt chunk size"));
+ }
+
+ if is_wave_format_ex {
+ // For WAVE_FORMAT_IEEE_FLOAT which we are reading, there should
+ // be no extra data, so `cbSize` should be 0.
+ let cb_size = try!(reader.read_le_u16());
+ if cb_size != 0 {
+ return Err(Error::FormatError("unexpected WAVEFORMATEX size"));
+ }
+ }
+
+ // For WAVE_FORMAT_IEEE_FLOAT, the bits_per_sample field should be
+ // set to `32` according to
+ // https://msdn.microsoft.com/en-us/library/windows/hardware/ff538799(v=vs.85).aspx.
+ //
+ // Note that some applications support 64 bits per sample. This is
+ // not yet supported by hound.
+ if spec.bits_per_sample != 32 {
+ return Err(Error::FormatError("bits per sample is not 32"));
+ }
+
+ spec.sample_format = SampleFormat::Float;
+ Ok(())
+ }
+
+ fn read_wave_format_extensible(mut reader: R, chunk_len: u32, spec: &mut WavSpec) -> Result<()> {
+ // 16 bytes were read already, there must be two more for the `cbSize`
+ // field, and `cbSize` itself must be at least 22, so the chunk length
+ // must be at least 40.
+ if chunk_len < 40 {
+ return Err(Error::FormatError("unexpected fmt chunk size"));
+ }
+
+ // `cbSize` is the last field of the WAVEFORMATEX struct.
+ let cb_size = try!(reader.read_le_u16());
+
+ // `cbSize` must be at least 22, but in this case we assume that it is
+ // 22, because we would not know how to handle extra data anyway.
+ if cb_size != 22 {
+ return Err(Error::FormatError("unexpected WAVEFORMATEXTENSIBLE size"));
+ }
+
+ // What follows is the rest of the `WAVEFORMATEXTENSIBLE` struct, as
+ // defined at https://msdn.microsoft.com/en-us/library/ms713496.aspx.
+ // ```
+ // typedef struct {
+ // WAVEFORMATEX Format;
+ // union {
+ // WORD wValidBitsPerSample;
+ // WORD wSamplesPerBlock;
+ // WORD wReserved;
+ // } Samples;
+ // DWORD dwChannelMask;
+ // GUID SubFormat;
+ // } WAVEFORMATEXTENSIBLE, *PWAVEFORMATEXTENSIBLE;
+ // ```
+ let valid_bits_per_sample = try!(reader.read_le_u16());
+ let _channel_mask = try!(reader.read_le_u32()); // Not used for now.
+ let mut subformat = [0u8; 16];
+ try!(reader.read_into(&mut subformat));
+
+ // Several GUIDS are defined. At the moment, only the following are supported:
+ //
+ // * KSDATAFORMAT_SUBTYPE_PCM (PCM audio with integer samples).
+ // * KSDATAFORMAT_SUBTYPE_IEEE_FLOAT (PCM audio with floating point samples).
+ let sample_format = match subformat {
+ super::KSDATAFORMAT_SUBTYPE_PCM => SampleFormat::Int,
+ super::KSDATAFORMAT_SUBTYPE_IEEE_FLOAT => SampleFormat::Float,
+ _ => return Err(Error::Unsupported),
+ };
+
+ // Fallback to bits_per_sample if the valid_bits_per_sample is obviously wrong to support non standard headers found in the wild.
+ if valid_bits_per_sample > 0 {
+ spec.bits_per_sample = valid_bits_per_sample;
+ }
+
+ spec.sample_format = sample_format;
+ Ok(())
+ }
+
+ /// Attempts to create a reader that reads the WAVE format.
+ ///
+ /// The header is read immediately. Reading the data will be done on
+ /// demand.
+ pub fn new(mut reader: R) -> Result<WavReader<R>> {
+ try!(read_wave_header(&mut reader));
+ let (spec_ex, data_len) = try!(read_until_data(&mut reader));
+
+ let num_samples = data_len / spec_ex.bytes_per_sample as u32;
+
+ // It could be that num_samples * bytes_per_sample < data_len.
+ // If data_len is not a multiple of bytes_per_sample, there is some
+ // trailing data. Either somebody is playing some steganography game,
+ // but more likely something is very wrong, and we should refuse to
+ // decode the file, as it is invalid.
+ if num_samples * spec_ex.bytes_per_sample as u32 != data_len {
+ let msg = "data chunk length is not a multiple of sample size";
+ return Err(Error::FormatError(msg));
+ }
+
+ // The number of samples must be a multiple of the number of channels,
+ // otherwise the last inter-channel sample would not have data for all
+ // channels.
+ if num_samples % spec_ex.spec.channels as u32 != 0 {
+ return Err(Error::FormatError("invalid data chunk length"));
+ }
+
+ let wav_reader = WavReader {
+ spec: spec_ex.spec,
+ bytes_per_sample: spec_ex.bytes_per_sample,
+ num_samples: num_samples,
+ samples_read: 0,
+ reader: reader,
+ };
+
+ Ok(wav_reader)
+ }
+
+ /// Returns information about the WAVE file.
+ pub fn spec(&self) -> WavSpec {
+ self.spec
+ }
+
+ /// Returns an iterator over all samples.
+ ///
+ /// The channel data is interleaved. The iterator is streaming. That is,
+ /// if you call this method once, read a few samples, and call this method
+ /// again, the second iterator will not start again from the beginning of
+ /// the file, it will continue where the first iterator stopped.
+ ///
+ /// The type `S` must have at least `spec().bits_per_sample` bits,
+ /// otherwise every iteration will return an error. All bit depths up to
+ /// 32 bits per sample can be decoded into an `i32`, but if you know
+ /// beforehand that you will be reading a file with 16 bits per sample, you
+ /// can save memory by decoding into an `i16`.
+ ///
+ /// The type of `S` (int or float) must match `spec().sample_format`,
+ /// otherwise every iteration will return an error.
+ pub fn samples<'wr, S: Sample>(&'wr mut self) -> WavSamples<'wr, R, S> {
+ WavSamples {
+ reader: self,
+ phantom_sample: marker::PhantomData,
+ }
+ }
+
+ /// Same as `samples`, but takes ownership of the `WavReader`.
+ ///
+ /// See `samples()` for more info.
+ pub fn into_samples<S: Sample>(self) -> WavIntoSamples<R, S> {
+ WavIntoSamples {
+ reader: self,
+ phantom_sample: marker::PhantomData,
+ }
+ }
+
+ /// Returns the duration of the file in samples.
+ ///
+ /// The duration is independent of the number of channels. It is expressed
+ /// in units of samples. The duration in seconds can be obtained by
+ /// dividing this number by the sample rate. The duration is independent of
+ /// how many samples have been read already.
+ pub fn duration(&self) -> u32 {
+ self.num_samples / self.spec.channels as u32
+ }
+
+ /// Returns the number of values that the sample iterator will yield.
+ ///
+ /// The length of the file is its duration (in samples) times the number of
+ /// channels. The length is independent of how many samples have been read
+ /// already. To get the number of samples left, use `len()` on the
+ /// `samples()` iterator.
+ pub fn len(&self) -> u32 {
+ self.num_samples
+ }
+
+ /// Destroys the `WavReader` and returns the underlying reader.
+ pub fn into_inner(self) -> R {
+ self.reader
+ }
+
+ /// Seek to the given time within the file.
+ ///
+ /// The given time is measured in number of samples (independent of the
+ /// number of channels) since the beginning of the audio data. To seek to
+ /// a particular time in seconds, multiply the number of seconds with
+ /// `WavSpec::sample_rate`. The given time should not exceed the duration of
+ /// the file (returned by `duration()`). The behavior when seeking beyond
+ /// `duration()` depends on the reader's `Seek` implementation.
+ ///
+ /// This method requires that the inner reader `R` implements `Seek`.
+ pub fn seek(&mut self, time: u32) -> io::Result<()>
+ where R: io::Seek,
+ {
+ let bytes_per_sample = self.spec.bits_per_sample / 8;
+ let sample_position = time * self.spec.channels as u32;
+ let offset_samples = sample_position as i64 - self.samples_read as i64;
+ let offset_bytes = offset_samples * bytes_per_sample as i64;
+ try!(self.reader.seek(io::SeekFrom::Current(offset_bytes)));
+ self.samples_read = sample_position;
+ Ok(())
+ }
+}
+
+impl WavReader<io::BufReader<fs::File>> {
+ /// Attempts to create a reader that reads from the specified file.
+ ///
+ /// This is a convenience constructor that opens a `File`, wraps it in a
+ /// `BufReader` and then constructs a `WavReader` from it.
+ pub fn open<P: AsRef<path::Path>>(filename: P) -> Result<WavReader<io::BufReader<fs::File>>> {
+ let file = try!(fs::File::open(filename));
+ let buf_reader = io::BufReader::new(file);
+ WavReader::new(buf_reader)
+ }
+}
+
+fn iter_next<R, S>(reader: &mut WavReader<R>) -> Option<Result<S>>
+ where R: io::Read,
+ S: Sample
+{
+ if reader.samples_read < reader.num_samples {
+ reader.samples_read += 1;
+ let sample = Sample::read(&mut reader.reader,
+ reader.spec.sample_format,
+ reader.bytes_per_sample,
+ reader.spec.bits_per_sample);
+ Some(sample.map_err(Error::from))
+ } else {
+ None
+ }
+}
+
+fn iter_size_hint<R>(reader: &WavReader<R>) -> (usize, Option<usize>) {
+ let samples_left = reader.num_samples - reader.samples_read;
+ (samples_left as usize, Some(samples_left as usize))
+}
+
+impl<'wr, R, S> Iterator for WavSamples<'wr, R, S>
+ where R: io::Read,
+ S: Sample
+{
+ type Item = Result<S>;
+
+ fn next(&mut self) -> Option<Result<S>> {
+ iter_next(&mut self.reader)
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ iter_size_hint(&self.reader)
+ }
+}
+
+impl<'wr, R, S> ExactSizeIterator for WavSamples<'wr, R, S>
+ where R: io::Read,
+ S: Sample
+{
+}
+
+impl<R, S> Iterator for WavIntoSamples<R, S>
+ where R: io::Read,
+ S: Sample
+{
+ type Item = Result<S>;
+
+ fn next(&mut self) -> Option<Result<S>> {
+ iter_next(&mut self.reader)
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ iter_size_hint(&self.reader)
+ }
+}
+
+impl<R, S> ExactSizeIterator for WavIntoSamples<R, S>
+ where R: io::Read,
+ S: Sample
+{
+}
+
+#[test]
+fn duration_and_len_agree() {
+ let files = &["testsamples/pcmwaveformat-16bit-44100Hz-mono.wav",
+ "testsamples/waveformatex-16bit-44100Hz-stereo.wav",
+ "testsamples/waveformatextensible-32bit-48kHz-stereo.wav"];
+
+ for fname in files {
+ let reader = WavReader::open(fname).unwrap();
+ assert_eq!(reader.spec().channels as u32 * reader.duration(),
+ reader.len());
+ }
+}
+
+/// Tests reading a wave file with the PCMWAVEFORMAT struct.
+#[test]
+fn read_wav_pcm_wave_format_pcm() {
+ let mut wav_reader = WavReader::open("testsamples/pcmwaveformat-16bit-44100Hz-mono.wav")
+ .unwrap();
+
+ assert_eq!(wav_reader.spec().channels, 1);
+ assert_eq!(wav_reader.spec().sample_rate, 44100);
+ assert_eq!(wav_reader.spec().bits_per_sample, 16);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Int);
+
+ let samples: Vec<i16> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // The test file has been prepared with these exact four samples.
+ assert_eq!(&samples[..], &[2, -3, 5, -7]);
+}
+
+#[test]
+fn read_wav_skips_unknown_chunks() {
+ // The test samples are the same as without the -extra suffix, but ffmpeg
+ // has kindly added some useless chunks in between the fmt and data chunk.
+ let files = ["testsamples/pcmwaveformat-16bit-44100Hz-mono-extra.wav",
+ "testsamples/waveformatex-16bit-44100Hz-mono-extra.wav"];
+
+ for file in &files {
+ let mut wav_reader = WavReader::open(file).unwrap();
+
+ assert_eq!(wav_reader.spec().channels, 1);
+ assert_eq!(wav_reader.spec().sample_rate, 44100);
+ assert_eq!(wav_reader.spec().bits_per_sample, 16);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Int);
+
+ let sample = wav_reader.samples::<i16>().next().unwrap().unwrap();
+ assert_eq!(sample, 2);
+ }
+}
+
+#[test]
+fn read_wav_0_valid_bits_fallback() {
+ let mut wav_reader = WavReader::open("testsamples/nonstandard-02.wav")
+ .unwrap();
+
+ assert_eq!(wav_reader.spec().channels, 2);
+ assert_eq!(wav_reader.spec().sample_rate, 48000);
+ assert_eq!(wav_reader.spec().bits_per_sample, 32);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Int);
+
+ let samples: Vec<i32> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // The test file has been prepared with these exact four samples.
+ assert_eq!(&samples[..], &[19, -229373, 33587161, -2147483497]);
+}
+
+#[test]
+fn len_and_size_hint_are_correct() {
+ let mut wav_reader = WavReader::open("testsamples/pcmwaveformat-16bit-44100Hz-mono.wav")
+ .unwrap();
+
+ assert_eq!(wav_reader.len(), 4);
+
+ {
+ let mut samples = wav_reader.samples::<i16>();
+
+ assert_eq!(samples.size_hint(), (4, Some(4)));
+ samples.next();
+ assert_eq!(samples.size_hint(), (3, Some(3)));
+ }
+
+ // Reading should not affect the initial length.
+ assert_eq!(wav_reader.len(), 4);
+
+ // Creating a new iterator resumes where the previous iterator stopped.
+ {
+ let mut samples = wav_reader.samples::<i16>();
+
+ assert_eq!(samples.size_hint(), (3, Some(3)));
+ samples.next();
+ assert_eq!(samples.size_hint(), (2, Some(2)));
+ }
+}
+
+#[test]
+fn size_hint_is_exact() {
+ let files = &["testsamples/pcmwaveformat-16bit-44100Hz-mono.wav",
+ "testsamples/waveformatex-16bit-44100Hz-stereo.wav",
+ "testsamples/waveformatextensible-32bit-48kHz-stereo.wav"];
+
+ for fname in files {
+ let mut reader = WavReader::open(fname).unwrap();
+ let len = reader.len();
+ let mut iter = reader.samples::<i32>();
+ for i in 0..len {
+ let remaining = (len - i) as usize;
+ assert_eq!(iter.size_hint(), (remaining, Some(remaining)));
+ assert!(iter.next().is_some());
+ }
+ assert!(iter.next().is_none());
+ }
+}
+
+#[test]
+fn samples_equals_into_samples() {
+ let wav_reader_val = WavReader::open("testsamples/pcmwaveformat-8bit-44100Hz-mono.wav").unwrap();
+ let mut wav_reader_ref = WavReader::open("testsamples/pcmwaveformat-8bit-44100Hz-mono.wav").unwrap();
+
+ let samples_val: Vec<i16> = wav_reader_val.into_samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ let samples_ref: Vec<i16> = wav_reader_ref.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ assert_eq!(samples_val, samples_ref);
+}
+
+/// Tests reading a wave file with the WAVEFORMATEX struct.
+#[test]
+fn read_wav_wave_format_ex_pcm() {
+ let mut wav_reader = WavReader::open("testsamples/waveformatex-16bit-44100Hz-mono.wav")
+ .unwrap();
+
+ assert_eq!(wav_reader.spec().channels, 1);
+ assert_eq!(wav_reader.spec().sample_rate, 44100);
+ assert_eq!(wav_reader.spec().bits_per_sample, 16);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Int);
+
+ let samples: Vec<i16> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // The test file has been prepared with these exact four samples.
+ assert_eq!(&samples[..], &[2, -3, 5, -7]);
+}
+
+#[test]
+fn read_wav_wave_format_ex_ieee_float() {
+ let mut wav_reader = WavReader::open("testsamples/waveformatex-ieeefloat-44100Hz-mono.wav")
+ .unwrap();
+
+ assert_eq!(wav_reader.spec().channels, 1);
+ assert_eq!(wav_reader.spec().sample_rate, 44100);
+ assert_eq!(wav_reader.spec().bits_per_sample, 32);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Float);
+
+ let samples: Vec<f32> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // The test file has been prepared with these exact four samples.
+ assert_eq!(&samples[..], &[2.0, 3.0, -16411.0, 1019.0]);
+}
+
+#[test]
+fn read_wav_stereo() {
+ let mut wav_reader = WavReader::open("testsamples/waveformatex-16bit-44100Hz-stereo.wav")
+ .unwrap();
+
+ assert_eq!(wav_reader.spec().channels, 2);
+ assert_eq!(wav_reader.spec().sample_rate, 44100);
+ assert_eq!(wav_reader.spec().bits_per_sample, 16);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Int);
+
+ let samples: Vec<i16> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // The test file has been prepared with these exact eight samples.
+ assert_eq!(&samples[..], &[2, -3, 5, -7, 11, -13, 17, -19]);
+
+}
+
+#[test]
+fn read_wav_pcm_wave_format_8bit() {
+ let mut wav_reader = WavReader::open("testsamples/pcmwaveformat-8bit-44100Hz-mono.wav")
+ .unwrap();
+
+ assert_eq!(wav_reader.spec().channels, 1);
+ assert_eq!(wav_reader.spec().bits_per_sample, 8);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Int);
+
+ let samples: Vec<i16> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // The test file has been prepared with these exact four samples.
+ assert_eq!(&samples[..], &[19, -53, 89, -127]);
+}
+
+/// Test reading 24 bit samples in a 4 byte container using the pcmwaveformat header. This is
+/// technically a non-compliant wave file, but it is the sort of file generated by
+/// 'arecord -f S24_LE -r 48000 -c 2 input.wav' so it should be supported.
+#[test]
+fn read_wav_pcm_wave_format_24bit_4byte() {
+ let mut wav_reader = WavReader::open("testsamples/pcmwaveformat-24bit-4byte-48kHz-stereo.wav")
+ .unwrap();
+
+ assert_eq!(wav_reader.spec().channels, 2);
+ assert_eq!(wav_reader.spec().sample_rate, 48_000);
+ assert_eq!(wav_reader.spec().bits_per_sample, 24);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Int);
+
+ let samples: Vec<i32> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // The test file has been prepared with these exact four samples.
+ assert_eq!(&samples[..], &[-96, 23_052, 8_388_607, -8_360_672]);
+}
+
+/// Regression test for a real-world wav file encountered in Quake.
+#[test]
+fn read_wav_wave_format_ex_8bit() {
+ let mut wav_reader = WavReader::open("testsamples/waveformatex-8bit-11025Hz-mono.wav").unwrap();
+
+ assert_eq!(wav_reader.spec().channels, 1);
+ assert_eq!(wav_reader.spec().bits_per_sample, 8);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Int);
+
+ let samples: Vec<i32> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // The audio data has been zeroed out, but for 8-bit files, a zero means a
+ // sample value of 128.
+ assert_eq!(&samples[..], &[-128, -128, -128, -128]);
+}
+
+/// This test sample tests both reading the WAVEFORMATEXTENSIBLE header, and 24-bit samples.
+#[test]
+fn read_wav_wave_format_extensible_pcm_24bit() {
+ let mut wav_reader = WavReader::open("testsamples/waveformatextensible-24bit-192kHz-mono.wav")
+ .unwrap();
+
+ assert_eq!(wav_reader.spec().channels, 1);
+ assert_eq!(wav_reader.spec().sample_rate, 192_000);
+ assert_eq!(wav_reader.spec().bits_per_sample, 24);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Int);
+
+ let samples: Vec<i32> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // The test file has been prepared with these exact four samples.
+ assert_eq!(&samples[..], &[-17, 4_194_319, -6_291_437, 8_355_817]);
+}
+
+/// This test sample tests both reading the WAVEFORMATEXTENSIBLE header, and 24-bit samples with a
+/// 4 byte container size.
+#[test]
+fn read_wav_wave_format_extensible_pcm_24bit_4byte() {
+ let mut wav_reader = WavReader::open("testsamples/waveformatextensible-24bit-4byte-48kHz-stereo.wav")
+ .unwrap();
+
+ assert_eq!(wav_reader.spec().channels, 2);
+ assert_eq!(wav_reader.spec().sample_rate, 48_000);
+ assert_eq!(wav_reader.spec().bits_per_sample, 24);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Int);
+
+ let samples: Vec<i32> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // The test file has been prepared with these exact four samples.
+ assert_eq!(&samples[..], &[-96, 23_052, 8_388_607, -8_360_672]);
+}
+
+#[test]
+fn read_wav_32bit() {
+ let mut wav_reader = WavReader::open("testsamples/waveformatextensible-32bit-48kHz-stereo.wav")
+ .unwrap();
+
+ assert_eq!(wav_reader.spec().bits_per_sample, 32);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Int);
+
+ let samples: Vec<i32> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // The test file has been prepared with these exact four samples.
+ assert_eq!(&samples[..], &[19, -229_373, 33_587_161, -2_147_483_497]);
+}
+
+#[test]
+fn read_wav_wave_format_extensible_ieee_float() {
+ let mut wav_reader =
+ WavReader::open("testsamples/waveformatextensible-ieeefloat-44100Hz-mono.wav").unwrap();
+
+ assert_eq!(wav_reader.spec().channels, 1);
+ assert_eq!(wav_reader.spec().sample_rate, 44100);
+ assert_eq!(wav_reader.spec().bits_per_sample, 32);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Float);
+
+ let samples: Vec<f32> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ // The test file has been prepared with these exact four samples.
+ assert_eq!(&samples[..], &[2.0, 3.0, -16411.0, 1019.0]);
+}
+
+#[test]
+fn read_wav_nonstandard_01() {
+ // The test sample here is adapted from a file encountered in the wild (data
+ // chunk replaced with two zero samples, some metadata dropped, and the file
+ // length in the header fixed). It is not a valid file according to the
+ // standard, but many players can deal with it nonetheless. (The file even
+ // contains some metadata; open it in a hex editor if you would like to know
+ // which program created it.) The file contains a regular PCM format tag,
+ // but the size of the fmt chunk is one that would be expected of a
+ // WAVEFORMATEXTENSIBLE chunk. The bits per sample is 24, which is invalid
+ // for WAVEFORMATEX, but we can read it nonetheless.
+ let mut wav_reader = WavReader::open("testsamples/nonstandard-01.wav").unwrap();
+
+ assert_eq!(wav_reader.spec().bits_per_sample, 24);
+ assert_eq!(wav_reader.spec().sample_format, SampleFormat::Int);
+
+ let samples: Vec<i32> = wav_reader.samples()
+ .map(|r| r.unwrap())
+ .collect();
+
+ assert_eq!(&samples[..], &[0, 0]);
+}
+
+#[test]
+fn wide_read_should_signal_error() {
+ let mut reader24 = WavReader::open("testsamples/waveformatextensible-24bit-192kHz-mono.wav")
+ .unwrap();
+
+ // Even though we know the first value is 17, and it should fit in an `i8`,
+ // a general 24-bit sample will not fit in an `i8`, so this should fail.
+ // 16-bit is still not wide enough, but 32-bit should do the trick.
+ assert!(reader24.samples::<i8>().next().unwrap().is_err());
+ assert!(reader24.samples::<i16>().next().unwrap().is_err());
+ assert!(reader24.samples::<i32>().next().unwrap().is_ok());
+
+ let mut reader32 = WavReader::open("testsamples/waveformatextensible-32bit-48kHz-stereo.wav")
+ .unwrap();
+
+ // In general, 32-bit samples will not fit in anything but an `i32`.
+ assert!(reader32.samples::<i8>().next().unwrap().is_err());
+ assert!(reader32.samples::<i16>().next().unwrap().is_err());
+ assert!(reader32.samples::<i32>().next().unwrap().is_ok());
+}
+
+#[test]
+fn sample_format_mismatch_should_signal_error() {
+ let mut reader_f32 = WavReader::open("testsamples/waveformatex-ieeefloat-44100Hz-mono.wav")
+ .unwrap();
+
+ assert!(reader_f32.samples::<i8>().next().unwrap().is_err());
+ assert!(reader_f32.samples::<i16>().next().unwrap().is_err());
+ assert!(reader_f32.samples::<i32>().next().unwrap().is_err());
+ assert!(reader_f32.samples::<f32>().next().unwrap().is_ok());
+
+ let mut reader_i8 = WavReader::open("testsamples/pcmwaveformat-8bit-44100Hz-mono.wav").unwrap();
+
+ assert!(reader_i8.samples::<i8>().next().unwrap().is_ok());
+ assert!(reader_i8.samples::<i16>().next().unwrap().is_ok());
+ assert!(reader_i8.samples::<i32>().next().unwrap().is_ok());
+ assert!(reader_i8.samples::<f32>().next().unwrap().is_err());
+}
+
+#[test]
+fn fuzz_crashes_should_be_fixed() {
+ use std::fs;
+ use std::ffi::OsStr;
+
+ // This is a regression test: all crashes and other issues found through
+ // fuzzing should not cause a crash.
+ let dir = fs::read_dir("testsamples/fuzz").ok()
+ .expect("failed to enumerate fuzz test corpus");
+ for path in dir {
+ let path = path.ok().expect("failed to obtain path info").path();
+ let is_file = fs::metadata(&path).unwrap().file_type().is_file();
+ if is_file && path.extension() == Some(OsStr::new("wav")) {
+ println!(" testing {} ...", path.to_str()
+ .expect("unsupported filename"));
+ let mut reader = match WavReader::open(path) {
+ Ok(r) => r,
+ Err(..) => continue,
+ };
+ match reader.spec().sample_format {
+ SampleFormat::Int => {
+ for sample in reader.samples::<i32>() {
+ match sample {
+ Ok(..) => { }
+ Err(..) => break,
+ }
+ }
+ }
+ SampleFormat::Float => {
+ for sample in reader.samples::<f32>() {
+ match sample {
+ Ok(..) => { }
+ Err(..) => break,
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+#[test]
+fn seek_is_consistent() {
+ let files = &["testsamples/pcmwaveformat-16bit-44100Hz-mono.wav",
+ "testsamples/waveformatex-16bit-44100Hz-stereo.wav",
+ "testsamples/waveformatextensible-32bit-48kHz-stereo.wav"];
+ for fname in files {
+ let mut reader = WavReader::open(fname).unwrap();
+
+ // Seeking back to the start should "reset" the reader.
+ let count = reader.samples::<i32>().count();
+ reader.seek(0).unwrap();
+ assert_eq!(reader.samples_read, 0);
+ assert_eq!(count, reader.samples::<i32>().count());
+
+ // Seek to the last sample.
+ let last_time = reader.duration() - 1;
+ let channels = reader.spec.channels;
+ reader.seek(last_time).unwrap();
+ {
+ let mut samples = reader.samples::<i32>();
+ for _ in 0..channels {
+ assert!(samples.next().is_some());
+ }
+ assert!(samples.next().is_none());
+ }
+
+ // Seeking beyond the audio data produces no samples.
+ let num_samples = reader.len();
+ reader.seek(num_samples).unwrap();
+ assert!(reader.samples::<i32>().next().is_none());
+ reader.seek(::std::u32::MAX / channels as u32).unwrap();
+ assert!(reader.samples::<i32>().next().is_none());
+ }
+}
diff --git a/src/write.rs b/src/write.rs
new file mode 100644
index 0000000..585206a
--- /dev/null
+++ b/src/write.rs
@@ -0,0 +1,911 @@
+// Hound -- A wav encoding and decoding library in Rust
+// Copyright (C) 2015 Ruud van Asseldonk
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// A copy of the License has been included in the root of the repository.
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::fs;
+use std::io;
+use std::mem;
+use std::io::{Seek, Write};
+use std::mem::MaybeUninit;
+use std::path;
+use super::{Error, Result, Sample, SampleFormat, WavSpec, WavSpecEx};
+use ::read;
+
+/// Extends the functionality of `io::Write` with additional methods.
+///
+/// The methods may be used on any type that implements `io::Write`.
+pub trait WriteExt: io::Write {
+ /// Writes an unsigned 8-bit integer.
+ fn write_u8(&mut self, x: u8) -> io::Result<()>;
+
+ /// Writes a signed 16-bit integer in little endian format.
+ fn write_le_i16(&mut self, x: i16) -> io::Result<()>;
+
+ /// Writes an unsigned 16-bit integer in little endian format.
+ fn write_le_u16(&mut self, x: u16) -> io::Result<()>;
+
+ /// Writes a signed 24-bit integer in little endian format.
+ ///
+ /// The most significant byte of the `i32` is ignored.
+ fn write_le_i24(&mut self, x: i32) -> io::Result<()>;
+
+ /// Writes a signed 24-bit integer in 4-byte little endian format.
+ ///
+ /// The most significant byte of the `i32` is replaced with zeroes.
+ fn write_le_i24_4(&mut self, x: i32) -> io::Result<()>;
+
+ /// Writes an unsigned 24-bit integer in little endian format.
+ ///
+ /// The most significant byte of the `u32` is ignored.
+ fn write_le_u24(&mut self, x: u32) -> io::Result<()>;
+
+ /// Writes a signed 32-bit integer in little endian format.
+ fn write_le_i32(&mut self, x: i32) -> io::Result<()>;
+
+ /// Writes an unsigned 32-bit integer in little endian format.
+ fn write_le_u32(&mut self, x: u32) -> io::Result<()>;
+
+ /// Writes an IEEE float in little endian format.
+ fn write_le_f32(&mut self, x: f32) -> io::Result<()>;
+}
+
+impl<W> WriteExt for W
+ where W: io::Write
+{
+ #[inline(always)]
+ fn write_u8(&mut self, x: u8) -> io::Result<()> {
+ let buf = [x];
+ self.write_all(&buf)
+ }
+
+ #[inline(always)]
+ fn write_le_i16(&mut self, x: i16) -> io::Result<()> {
+ self.write_le_u16(x as u16)
+ }
+
+ #[inline(always)]
+ fn write_le_u16(&mut self, x: u16) -> io::Result<()> {
+ let mut buf = [0u8; 2];
+ buf[0] = (x & 0xff) as u8;
+ buf[1] = (x >> 8) as u8;
+ self.write_all(&buf)
+ }
+
+ #[inline(always)]
+ fn write_le_i24(&mut self, x: i32) -> io::Result<()> {
+ self.write_le_u24(x as u32)
+ }
+
+ #[inline(always)]
+ fn write_le_i24_4(&mut self, x: i32) -> io::Result<()> {
+ self.write_le_u32((x as u32) & 0x00_ff_ff_ff)
+ }
+
+ #[inline(always)]
+ fn write_le_u24(&mut self, x: u32) -> io::Result<()> {
+ let mut buf = [0u8; 3];
+ buf[0] = ((x >> 00) & 0xff) as u8;
+ buf[1] = ((x >> 08) & 0xff) as u8;
+ buf[2] = ((x >> 16) & 0xff) as u8;
+ self.write_all(&buf)
+ }
+
+ #[inline(always)]
+ fn write_le_i32(&mut self, x: i32) -> io::Result<()> {
+ self.write_le_u32(x as u32)
+ }
+
+ #[inline(always)]
+ fn write_le_u32(&mut self, x: u32) -> io::Result<()> {
+ let mut buf = [0u8; 4];
+ buf[0] = ((x >> 00) & 0xff) as u8;
+ buf[1] = ((x >> 08) & 0xff) as u8;
+ buf[2] = ((x >> 16) & 0xff) as u8;
+ buf[3] = ((x >> 24) & 0xff) as u8;
+ self.write_all(&buf)
+ }
+
+ #[inline(always)]
+ fn write_le_f32(&mut self, x: f32) -> io::Result<()> {
+ let u = unsafe { mem::transmute::<f32, u32>(x) };
+ self.write_le_u32(u)
+ }
+}
+
+/// Generates a bitmask with `channels` ones in the least significant bits.
+///
+/// According to the [spec](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ksmedia/ns-ksmedia-waveformatextensible#remarks),
+/// if `channels` is greater than the number of bits in the channel mask, 18 non-reserved bits,
+/// extra channels are not assigned to any physical speaker location. In this scenario, this
+/// function will return a filled channel mask.
+fn channel_mask(channels: u16) -> u32 {
+ // Clamp to 0-18 to stay within reserved bits.
+ let channels = if channels > 18 { 18 } else { channels };
+ (0..channels as u32).map(|c| 1 << c).fold(0, |a, c| a | c)
+}
+
+#[test]
+fn verify_channel_mask() {
+ assert_eq!(channel_mask(0), 0);
+ assert_eq!(channel_mask(1), 1);
+ assert_eq!(channel_mask(2), 3);
+ assert_eq!(channel_mask(3), 7);
+ assert_eq!(channel_mask(4), 0xF);
+ assert_eq!(channel_mask(8), 0xFF);
+ assert_eq!(channel_mask(16), 0xFFFF);
+ // expect channels >= 18 to yield the same mask
+ assert_eq!(channel_mask(18), 0x3FFFF);
+ assert_eq!(channel_mask(32), 0x3FFFF);
+ assert_eq!(channel_mask(64), 0x3FFFF);
+ assert_eq!(channel_mask(129), 0x3FFFF);
+}
+
+/// A writer that accepts samples and writes the WAVE format.
+///
+/// The writer needs a `WavSpec` or `WavSpecEx` that describes the audio
+/// properties. Then samples can be written with `write_sample`. Channel data is
+/// interleaved. The number of samples written must be a multiple of the number
+/// of channels. After all samples have been written, the file must be
+/// finalized. This can be done by calling `finalize`. If `finalize` is not
+/// called, the file will be finalized upon drop. However, finalization may
+/// fail, and without calling `finalize`, such a failure cannot be observed.
+pub struct WavWriter<W>
+ where W: io::Write + io::Seek
+{
+ /// Specifies properties of the audio data.
+ spec: WavSpec,
+
+ /// The (container) bytes per sample. This is the bit rate / 8 rounded up.
+ bytes_per_sample: u16,
+
+ /// The writer that will be written to.
+ writer: W,
+
+ /// The number of bytes written to the data section.
+ ///
+ /// This is an `u32` because WAVE cannot accomodate more data.
+ data_bytes_written: u32,
+
+ /// Whether the header has been finalized.
+ finalized: bool,
+
+ /// The buffer for the sample writer, which is recycled throughout calls to
+ /// avoid allocating frequently.
+ sample_writer_buffer: Vec<MaybeUninit<u8>>,
+
+ /// The offset of the length field of the data chunk.
+ ///
+ /// This field needs to be overwritten after all data has been written. To
+ /// support different size fmt chunks, and other chunks interspersed, the
+ /// offset is flexible.
+ data_len_offset: u32,
+}
+
+enum FmtKind {
+ PcmWaveFormat,
+ WaveFormatExtensible,
+}
+
+impl<W> WavWriter<W>
+ where W: io::Write + io::Seek
+{
+ /// Creates a writer that writes the WAVE format to the underlying writer.
+ ///
+ /// The underlying writer is assumed to be at offset 0. `WavWriter` employs
+ /// *no* buffering internally. It is recommended to wrap the writer in a
+ /// `BufWriter` to avoid too many `write` calls. The `create()` constructor
+ /// does this automatically.
+ ///
+ /// This writes parts of the header immediately, hence a `Result` is
+ /// returned.
+ pub fn new(writer: W, spec: WavSpec) -> Result<WavWriter<W>> {
+ let spec_ex = WavSpecEx {
+ spec: spec,
+ bytes_per_sample: (spec.bits_per_sample + 7) / 8,
+ };
+ WavWriter::new_with_spec_ex(writer, spec_ex)
+ }
+
+
+ /// Creates a writer that writes the WAVE format to the underlying writer.
+ ///
+ /// The underlying writer is assumed to be at offset 0. `WavWriter` employs
+ /// *no* buffering internally. It is recommended to wrap the writer in a
+ /// `BufWriter` to avoid too many `write` calls. The `create()` constructor
+ /// does this automatically.
+ ///
+ /// This writes parts of the header immediately, hence a `Result` is
+ /// returned.
+ pub fn new_with_spec_ex(writer: W, spec_ex: WavSpecEx) -> Result<WavWriter<W>> {
+ let spec = spec_ex.spec;
+
+ // Write the older PCMWAVEFORMAT structure if possible, because it is
+ // more widely supported. For more than two channels or more than 16
+ // bits per sample, the newer WAVEFORMATEXTENSIBLE is required. See also
+ // https://msdn.microsoft.com/en-us/library/ms713497.aspx.
+ let fmt_kind = if spec.channels > 2 || spec.bits_per_sample > 16 {
+ FmtKind::WaveFormatExtensible
+ } else {
+ FmtKind::PcmWaveFormat
+ };
+
+ let mut writer = WavWriter {
+ spec: spec,
+ bytes_per_sample: spec_ex.bytes_per_sample,
+ writer: writer,
+ data_bytes_written: 0,
+ sample_writer_buffer: Vec::new(),
+ finalized: false,
+ data_len_offset: match fmt_kind {
+ FmtKind::WaveFormatExtensible => 64,
+ FmtKind::PcmWaveFormat => 40,
+ },
+ };
+
+ // Hound can only write those bit depths. If something else was
+ // requested, fail early, rather than writing a header but then failing
+ // at the first sample.
+ let supported = match spec.bits_per_sample {
+ 8 => true,
+ 16 => true,
+ 24 => true,
+ 32 => true,
+ _ => false,
+ };
+
+ if !supported {
+ return Err(Error::Unsupported)
+ }
+
+ // Write headers, up to the point where data should be written.
+ try!(writer.write_headers(fmt_kind));
+
+ Ok(writer)
+ }
+
+ /// Writes the RIFF WAVE header, fmt chunk, and data chunk header.
+ fn write_headers(&mut self, fmt_kind: FmtKind) -> io::Result<()> {
+ // Write to an in-memory buffer before writing to the underlying writer.
+ let mut header = [0u8; 68];
+
+ {
+ let mut buffer = io::Cursor::new(&mut header[..]);
+
+ // Write the headers for the RIFF WAVE format.
+ try!(buffer.write_all("RIFF".as_bytes()));
+
+ // Skip 4 bytes that will be filled with the file size afterwards.
+ try!(buffer.write_le_u32(0));
+
+ try!(buffer.write_all("WAVE".as_bytes()));
+ try!(buffer.write_all("fmt ".as_bytes()));
+
+ match fmt_kind {
+ FmtKind::PcmWaveFormat => {
+ try!(self.write_pcmwaveformat(&mut buffer));
+ }
+ FmtKind::WaveFormatExtensible => {
+ try!(self.write_waveformatextensible(&mut buffer));
+ }
+ }
+
+ // Finally the header of the "data" chunk. The number of bytes
+ // that this will take is not known at this point. The 0 will
+ // be overwritten later.
+ try!(buffer.write_all("data".as_bytes()));
+ try!(buffer.write_le_u32(0));
+ }
+
+ // The data length field are the last 4 bytes of the header.
+ let header_len = self.data_len_offset as usize + 4;
+
+ self.writer.write_all(&header[..header_len])
+ }
+
+ /// Writes the spec as a WAVEFORMAT structure.
+ ///
+ /// The `WAVEFORMAT` struct is a subset of both `WAVEFORMATEX` and
+ /// `WAVEFORMATEXTENSIBLE`. This does not write the `wFormatTag` member.
+ fn write_waveformat(&self, buffer: &mut io::Cursor<&mut [u8]>) -> io::Result<()> {
+ let spec = &self.spec;
+ // The field nChannels.
+ try!(buffer.write_le_u16(spec.channels));
+
+ // The field nSamplesPerSec.
+ try!(buffer.write_le_u32(spec.sample_rate));
+ let bytes_per_sec = spec.sample_rate
+ * self.bytes_per_sample as u32
+ * spec.channels as u32;
+
+ // The field nAvgBytesPerSec;
+ try!(buffer.write_le_u32(bytes_per_sec));
+
+ // The field nBlockAlign. Block align * sample rate = bytes per sec.
+ try!(buffer.write_le_u16((bytes_per_sec / spec.sample_rate) as u16));
+
+ Ok(())
+ }
+
+ /// Writes the content of the fmt chunk as PCMWAVEFORMAT struct.
+ fn write_pcmwaveformat(&mut self, buffer: &mut io::Cursor<&mut [u8]>) -> io::Result<()> {
+ // Write the size of the WAVE header chunk.
+ try!(buffer.write_le_u32(16));
+
+ // The following is based on the PCMWAVEFORMAT struct as documented at
+ // https://msdn.microsoft.com/en-us/library/ms712832.aspx. See also
+ // http://soundfile.sapp.org/doc/WaveFormat/.
+
+ // The field wFormatTag
+ match self.spec.sample_format {
+ // WAVE_FORMAT_PCM
+ SampleFormat::Int => {
+ try!(buffer.write_le_u16(1));
+ },
+ // WAVE_FORMAT_IEEE_FLOAT
+ SampleFormat::Float => {
+ if self.spec.bits_per_sample == 32 {
+ try!(buffer.write_le_u16(3));
+ } else {
+ panic!("Invalid number of bits per sample. \
+ When writing SampleFormat::Float, \
+ bits_per_sample must be 32.");
+ }
+ },
+ };
+
+ try!(self.write_waveformat(buffer));
+
+ // The field wBitsPerSample, the real number of bits per sample.
+ try!(buffer.write_le_u16(self.spec.bits_per_sample));
+
+ // Note: for WAVEFORMATEX, there would be another 16-byte field `cbSize`
+ // here that should be set to zero. And the header size would be 18
+ // rather than 16.
+
+ Ok(())
+ }
+
+ /// Writes the contents of the fmt chunk as WAVEFORMATEXTENSIBLE struct.
+ fn write_waveformatextensible(&mut self, buffer: &mut io::Cursor<&mut [u8]>) -> io::Result<()> {
+ // Write the size of the WAVE header chunk.
+ try!(buffer.write_le_u32(40));
+
+ // The following is based on the WAVEFORMATEXTENSIBLE struct, documented
+ // at https://msdn.microsoft.com/en-us/library/ms713496.aspx and
+ // https://msdn.microsoft.com/en-us/library/ms713462.aspx.
+
+ // The field wFormatTag, value 1 means WAVE_FORMAT_PCM, but we use
+ // the slightly more sophisticated WAVE_FORMAT_EXTENSIBLE.
+ try!(buffer.write_le_u16(0xfffe));
+
+ try!(self.write_waveformat(buffer));
+
+ // The field wBitsPerSample. This is actually the size of the
+ // container, so this is a multiple of 8.
+ try!(buffer.write_le_u16(self.bytes_per_sample as u16 * 8));
+ // The field cbSize, the number of remaining bytes in the struct.
+ try!(buffer.write_le_u16(22));
+ // The field wValidBitsPerSample, the real number of bits per sample.
+ try!(buffer.write_le_u16(self.spec.bits_per_sample));
+ // The field dwChannelMask.
+ // TODO: add the option to specify the channel mask. For now, use
+ // the default assignment.
+ try!(buffer.write_le_u32(channel_mask(self.spec.channels)));
+
+ // The field SubFormat.
+ let subformat_guid = match self.spec.sample_format {
+ // PCM audio with integer samples.
+ SampleFormat::Int => super::KSDATAFORMAT_SUBTYPE_PCM,
+ // PCM audio with 32-bit IEEE float samples.
+ SampleFormat::Float => {
+ if self.spec.bits_per_sample == 32 {
+ super::KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
+ } else {
+ panic!("Invalid number of bits per sample. \
+ When writing SampleFormat::Float, \
+ bits_per_sample must be 32.");
+ }
+ }
+ };
+ try!(buffer.write_all(&subformat_guid));
+
+ Ok(())
+ }
+
+ /// Writes a single sample for one channel.
+ ///
+ /// WAVE interleaves channel data, so the channel that this writes the
+ /// sample to depends on previous writes. This will return an error if the
+ /// sample does not fit in the number of bits specified in the `WavSpec`.
+ #[inline]
+ pub fn write_sample<S: Sample>(&mut self, sample: S) -> Result<()> {
+ try!(sample.write_padded(
+ &mut self.writer,
+ self.spec.bits_per_sample,
+ self.bytes_per_sample,
+ ));
+ self.data_bytes_written += self.bytes_per_sample as u32;
+ Ok(())
+ }
+
+ /// Create an efficient writer that writes 16-bit integer samples only.
+ ///
+ /// When it is known what the kind of samples will be, many dynamic checks
+ /// can be omitted. Furthermore, this writer employs buffering internally,
+ /// which allows omitting return value checks except on flush. The internal
+ /// buffer will be sized such that exactly `num_samples` samples can be
+ /// written to it, and the buffer is recycled across calls to
+ /// `get_i16_writer()` if the previous buffer was sufficiently large.
+ ///
+ /// # Panics
+ ///
+ /// Panics if the spec does not match a 16 bits per sample integer format.
+ ///
+ /// Attempting to write more than `num_samples` samples to the writer will
+ /// panic too.
+ pub fn get_i16_writer<'s>(&'s mut self,
+ num_samples: u32)
+ -> SampleWriter16<'s, W> {
+ if self.spec.sample_format != SampleFormat::Int {
+ panic!("When calling get_i16_writer, the sample format must be int.");
+ }
+ if self.spec.bits_per_sample != 16 {
+ panic!("When calling get_i16_writer, the number of bits per sample must be 16.");
+ }
+
+ let num_bytes = num_samples as usize * 2;
+
+ if self.sample_writer_buffer.len() < num_bytes {
+ // We need a bigger buffer. There is no point in growing the old
+ // one, as we are going to overwrite the samples anyway, so just
+ // allocate a new one.
+ let mut new_buffer = Vec::<MaybeUninit<u8>>::with_capacity(num_bytes);
+
+ // The potentially garbage memory here will not be exposed: the
+ // buffer is only exposed when flushing, but `flush()` asserts that
+ // all samples have been written.
+ unsafe { new_buffer.set_len(num_bytes); }
+
+ self.sample_writer_buffer = new_buffer;
+ }
+
+ SampleWriter16 {
+ writer: &mut self.writer,
+ buffer: &mut self.sample_writer_buffer[..num_bytes],
+ data_bytes_written: &mut self.data_bytes_written,
+ index: 0,
+ }
+ }
+
+ fn update_header(&mut self) -> Result<()> {
+ // The header size minus magic and 32-bit filesize (8 bytes).
+ // The data chunk length (4 bytes) is the last part of the header.
+ let header_size = self.data_len_offset + 4 - 8;
+ let file_size = self.data_bytes_written + header_size;
+
+ try!(self.writer.seek(io::SeekFrom::Start(4)));
+ try!(self.writer.write_le_u32(file_size));
+ try!(self.writer.seek(io::SeekFrom::Start(self.data_len_offset as u64)));
+ try!(self.writer.write_le_u32(self.data_bytes_written));
+
+ // Signal error if the last sample was not finished, but do so after
+ // everything has been written, so that no data is lost, even though
+ // the file is now ill-formed.
+ if (self.data_bytes_written / self.bytes_per_sample as u32)
+ % self.spec.channels as u32 != 0 {
+ Err(Error::UnfinishedSample)
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Updates the WAVE header and flushes the underlying writer.
+ ///
+ /// Flush writes the WAVE header to the underlying writer to make the
+ /// written bytes a valid wav file, and then flushes the writer. It is still
+ /// possible to write more samples after flushing.
+ ///
+ /// Flush can be used for “checkpointing”. Even if after the flush there is
+ /// an IO error or the writing process dies, the file can still be read by a
+ /// compliant decoder up to the last flush.
+ ///
+ /// Note that if the number of samples written is not a multiple of the
+ /// channel count, the intermediate wav file will not be valid. In that case
+ /// `flush()` will still flush the data and write the (invalid) wav file,
+ /// but `Error::UnfinishedSample` will be returned afterwards.
+ ///
+ /// It is not necessary to call `finalize()` directly after `flush()`, if no
+ /// samples have been written after flushing.
+ pub fn flush(&mut self) -> Result<()> {
+ let current_pos = try!(self.writer.seek(io::SeekFrom::Current(0)));
+ try!(self.update_header());
+ try!(self.writer.flush());
+ try!(self.writer.seek(io::SeekFrom::Start(current_pos)));
+ Ok(())
+ }
+
+ /// Updates the WAVE header (which requires knowing all samples).
+ ///
+ /// This method must be called after all samples have been written. If it
+ /// is not called, the destructor will finalize the file, but any errors
+ /// that occur in the process cannot be observed in that manner.
+ pub fn finalize(mut self) -> Result<()> {
+ self.finalized = true;
+ try!(self.update_header());
+ // We need to perform a flush here to truly capture all errors before
+ // the writer is dropped: for a buffered writer, the write to the buffer
+ // may succeed, but the write to the underlying writer may fail. So
+ // flush explicitly.
+ try!(self.writer.flush());
+ Ok(())
+ }
+
+ /// Returns information about the WAVE file being written.
+ ///
+ /// This is the same spec that was passed to `WavWriter::new()`. For a
+ /// writer constructed with `WavWriter::new_append()` or
+ /// `WavWriter::append()`, this method returns the spec of the file being
+ /// appended to.
+ pub fn spec(&self) -> WavSpec {
+ self.spec
+ }
+
+ /// Returns the duration of the file written so far, in samples.
+ ///
+ /// The duration is independent of the number of channels. It is expressed
+ /// in units of samples. The duration in seconds can be obtained by
+ /// dividing this number by the sample rate.
+ pub fn duration(&self) -> u32 {
+ self.data_bytes_written / (self.bytes_per_sample as u32 * self.spec.channels as u32)
+ }
+
+ /// Returns the number of samples in the file written so far.
+ ///
+ /// The length of the file is its duration (in samples) times the number of
+ /// channels.
+ pub fn len(&self) -> u32 {
+ self.data_bytes_written / self.bytes_per_sample as u32
+ }
+}
+
+impl<W> Drop for WavWriter<W>
+ where W: io::Write + io::Seek
+{
+ fn drop(&mut self) {
+ // If the file was not explicitly finalized (to update the headers), do
+ // it in the drop. This can fail, but drop should not panic, so a
+ // failure is ignored silently here.
+ if !self.finalized {
+ let _r = self.update_header();
+ }
+ }
+}
+
+/// Reads the relevant parts of the header required to support append.
+///
+/// Returns (spec_ex, data_len, data_len_offset).
+fn read_append<W: io::Read + io::Seek>(mut reader: &mut W) -> Result<(WavSpecEx, u32, u32)> {
+ let (spec_ex, data_len) = {
+ try!(read::read_wave_header(&mut reader));
+ try!(read::read_until_data(&mut reader))
+ };
+
+ // Record the position of the data chunk length, so we can overwrite it
+ // later.
+ let data_len_offset = try!(reader.seek(io::SeekFrom::Current(0))) as u32 - 4;
+
+ let spec = spec_ex.spec;
+ let num_samples = data_len / spec_ex.bytes_per_sample as u32;
+
+ // There must not be trailing bytes in the data chunk, otherwise the
+ // bytes we write will be off.
+ if num_samples * spec_ex.bytes_per_sample as u32 != data_len {
+ let msg = "data chunk length is not a multiple of sample size";
+ return Err(Error::FormatError(msg));
+ }
+
+ // Hound cannot read or write other bit depths than those, so rather
+ // than refusing to write later, fail early.
+ let supported = match (spec_ex.bytes_per_sample, spec.bits_per_sample) {
+ (1, 8) => true,
+ (2, 16) => true,
+ (3, 24) => true,
+ (4, 32) => true,
+ _ => false,
+ };
+
+ if !supported {
+ return Err(Error::Unsupported);
+ }
+
+ // The number of samples must be a multiple of the number of channels,
+ // otherwise the last inter-channel sample would not have data for all
+ // channels.
+ if num_samples % spec_ex.spec.channels as u32 != 0 {
+ return Err(Error::FormatError("invalid data chunk length"));
+ }
+
+ Ok((spec_ex, data_len, data_len_offset))
+}
+
+impl WavWriter<io::BufWriter<fs::File>> {
+ /// Creates a writer that writes the WAVE format to a file.
+ ///
+ /// This is a convenience constructor that creates the file, wraps it in a
+ /// `BufWriter`, and then constructs a `WavWriter` from it. The file will
+ /// be overwritten if it exists.
+ pub fn create<P: AsRef<path::Path>>(filename: P,
+ spec: WavSpec)
+ -> Result<WavWriter<io::BufWriter<fs::File>>> {
+ let file = try!(fs::File::create(filename));
+ let buf_writer = io::BufWriter::new(file);
+ WavWriter::new(buf_writer, spec)
+ }
+
+ /// Creates a writer that appends samples to an existing file.
+ ///
+ /// This is a convenience constructor that opens the file in append mode,
+ /// reads its header using a buffered reader, and then constructs an
+ /// appending `WavWriter` that writes to the file using a `BufWriter`.
+ ///
+ /// See `WavWriter::new_append()` for more details about append behavior.
+ pub fn append<P: AsRef<path::Path>>(filename: P) -> Result<WavWriter<io::BufWriter<fs::File>>> {
+ // Open the file in append mode, start reading from the start.
+ let mut file = try!(fs::OpenOptions::new().read(true).write(true).open(filename));
+ try!(file.seek(io::SeekFrom::Start(0)));
+
+ // Read the header using a buffered reader.
+ let mut buf_reader = io::BufReader::new(file);
+ let (spec_ex, data_len, data_len_offset) = try!(read_append(&mut buf_reader));
+ let mut file = buf_reader.into_inner();
+
+ // Seek to the data position, and from now on, write using a buffered
+ // writer.
+ try!(file.seek(io::SeekFrom::Current(data_len as i64)));
+ let buf_writer = io::BufWriter::new(file);
+
+ let writer = WavWriter {
+ spec: spec_ex.spec,
+ bytes_per_sample: spec_ex.bytes_per_sample,
+ writer: buf_writer,
+ data_bytes_written: data_len,
+ sample_writer_buffer: Vec::new(),
+ finalized: false,
+ data_len_offset: data_len_offset,
+ };
+
+ Ok(writer)
+ }
+}
+
+impl<W> WavWriter<W> where W: io::Read + io::Write + io::Seek {
+ /// Creates a writer that appends samples to an existing file stream.
+ ///
+ /// This first reads the existing header to obtain the spec, then seeks to
+ /// the end of the writer. The writer then appends new samples to the end of
+ /// the stream.
+ ///
+ /// The underlying writer is assumed to be at offset 0.
+ ///
+ /// If the existing file includes a fact chunk, it will not be updated after
+ /// appending, and hence become outdated. For files produced by Hound this
+ /// is not an issue, because Hound never writes a fact chunk. For all the
+ /// formats that Hound can write, the fact chunk is redundant.
+ pub fn new_append(mut writer: W) -> Result<WavWriter<W>> {
+ let (spec_ex, data_len, data_len_offset) = try!(read_append(&mut writer));
+ try!(writer.seek(io::SeekFrom::Current(data_len as i64)));
+ let writer = WavWriter {
+ spec: spec_ex.spec,
+ bytes_per_sample: spec_ex.bytes_per_sample,
+ writer: writer,
+ data_bytes_written: data_len,
+ sample_writer_buffer: Vec::new(),
+ finalized: false,
+ data_len_offset: data_len_offset,
+ };
+
+ Ok(writer)
+ }
+}
+
+
+/// A writer that specifically only writes integer samples of 16 bits per sample.
+///
+/// The writer buffers written samples internally so they can be written in a
+/// single batch later on. This has two advantages when performance is
+/// important:
+///
+/// * There is no need for error handling during writing, only on flush. This
+/// eliminates a lot of branches.
+/// * The buffer can be written once, which reduces the overhead of the write
+/// call. Because writing to an `io::BufWriter` is implemented with a
+/// `memcpy` (even for single bytes), there is a large overhead to writing
+/// small amounts of data such as a 16-bit sample. By writing large blocks
+/// (or by not using `BufWriter`) this overhead can be avoided.
+///
+/// A `SampleWriter16` can be obtained by calling [`WavWriter::get_i16_writer`](
+/// struct.WavWriter.html#method.get_i16_writer).
+pub struct SampleWriter16<'parent, W> where W: io::Write + io::Seek + 'parent {
+ /// The writer borrowed from the wrapped WavWriter.
+ writer: &'parent mut W,
+
+ /// The internal buffer that samples are written to before they are flushed.
+ buffer: &'parent mut [MaybeUninit<u8>],
+
+ /// Reference to the `data_bytes_written` field of the writer.
+ data_bytes_written: &'parent mut u32,
+
+ /// The index into the buffer where the next bytes will be written.
+ index: u32,
+}
+
+impl<'parent, W: io::Write + io::Seek> SampleWriter16<'parent, W> {
+ /// Writes a single sample for one channel.
+ ///
+ /// WAVE interleaves channel data, so the channel that this writes the
+ /// sample to depends on previous writes.
+ ///
+ /// Unlike `WavWriter::write_sample()`, no range check is performed. Only
+ /// the least significant 16 bits are considered, everything else is
+ /// discarded. Apart from that check, this method is more efficient than
+ /// `WavWriter::write_sample()`, because it can avoid dispatching on the
+ /// number of bits. That was done already when the `SampleWriter16` was
+ /// constructed.
+ ///
+ /// Note that nothing is actually written until `flush()` is called.
+ #[inline(always)]
+ pub fn write_sample<S: Sample>(&mut self, sample: S) {
+ assert!((self.index as usize) + 2 <= self.buffer.len(),
+ "Trying to write more samples than reserved for the sample writer.");
+
+ // SAFETY: We performed the bounds check in the above assertion.
+ unsafe { self.write_sample_unchecked(sample) };
+ }
+
+ unsafe fn write_u16_le_unchecked(&mut self, value: u16) {
+ // On little endian machines the compiler produces assembly code
+ // that merges the following two lines into a single instruction.
+ *self.buffer.get_unchecked_mut(self.index as usize) = MaybeUninit::new(value as u8);
+ self.buffer.get_unchecked_mut(self.index as usize).assume_init();
+ *self.buffer.get_unchecked_mut(self.index as usize + 1) = MaybeUninit::new((value >> 8) as u8);
+ self.buffer.get_unchecked_mut(self.index as usize + 1).assume_init();
+ }
+
+ /// Like `write_sample()`, but does not perform a bounds check when writing
+ /// to the internal buffer.
+ ///
+ /// It is the responsibility of the programmer to ensure that no more
+ /// samples are written than allocated when the writer was created.
+ #[inline(always)]
+ pub unsafe fn write_sample_unchecked<S: Sample>(&mut self, sample: S) {
+ self.write_u16_le_unchecked(sample.as_i16() as u16);
+ self.index += 2;
+ }
+
+ /// Flush the internal buffer to the underlying writer.
+ ///
+ /// # Panics
+ ///
+ /// Panics if insufficient samples (less than specified when the writer was
+ /// constructed) have been written with `write_sample()`.
+ pub fn flush(self) -> Result<()> {
+ if self.index as usize != self.buffer.len() {
+ panic!("Insufficient samples written to the sample writer.");
+ }
+
+ // SAFETY: casting `self.buffer` to a `*const [MaybeUninit<u8>]` is safe
+ // since the caller guarantees that `self.buffer` is initialized, and
+ // `MaybeUninit<u8>` is guaranteed to have the same layout as `u8`. The
+ // pointer obtained is valid since it refers to memory owned by
+ // `self.buffer` which is a reference and thus guaranteed to be valid
+ // for reads. This is copied from the nightly implementation for
+ // slice_assume_init_ref.
+ let slice = unsafe { &*(self.buffer as *const [MaybeUninit<u8>] as *const [u8]) };
+
+ try!(self.writer.write_all(slice));
+
+ *self.data_bytes_written += self.buffer.len() as u32;
+ Ok(())
+ }
+}
+
+#[test]
+fn short_write_should_signal_error() {
+ use SampleFormat;
+
+ let mut buffer = io::Cursor::new(Vec::new());
+
+ let write_spec = WavSpec {
+ channels: 17,
+ sample_rate: 48000,
+ bits_per_sample: 8,
+ sample_format: SampleFormat::Int,
+ };
+
+ // Deliberately write one sample less than 17 * 5.
+ let mut writer = WavWriter::new(&mut buffer, write_spec).unwrap();
+ for s in 0..17 * 5 - 1 {
+ writer.write_sample(s as i16).unwrap();
+ }
+ let error = writer.finalize().err().unwrap();
+
+ match error {
+ Error::UnfinishedSample => {}
+ _ => panic!("UnfinishedSample error should have been returned."),
+ }
+}
+
+#[test]
+fn wide_write_should_signal_error() {
+ let mut buffer = io::Cursor::new(Vec::new());
+
+ let spec8 = WavSpec {
+ channels: 1,
+ sample_rate: 44100,
+ bits_per_sample: 8,
+ sample_format: SampleFormat::Int,
+ };
+ {
+ let mut writer = WavWriter::new(&mut buffer, spec8).unwrap();
+ assert!(writer.write_sample(127_i8).is_ok());
+ assert!(writer.write_sample(127_i16).is_ok());
+ assert!(writer.write_sample(127_i32).is_ok());
+ assert!(writer.write_sample(128_i16).is_err());
+ assert!(writer.write_sample(128_i32).is_err());
+ }
+
+ let spec16 = WavSpec { bits_per_sample: 16, ..spec8 };
+ {
+ let mut writer = WavWriter::new(&mut buffer, spec16).unwrap();
+ assert!(writer.write_sample(32767_i16).is_ok());
+ assert!(writer.write_sample(32767_i32).is_ok());
+ assert!(writer.write_sample(32768_i32).is_err());
+ }
+
+ let spec24 = WavSpec { bits_per_sample: 24, ..spec8 };
+ {
+ let mut writer = WavWriter::new(&mut buffer, spec24).unwrap();
+ assert!(writer.write_sample(8_388_607_i32).is_ok());
+ assert!(writer.write_sample(8_388_608_i32).is_err());
+ }
+}
+
+#[test]
+fn s24_wav_write() {
+ use std::fs::File;
+ use std::io::Read;
+ let mut buffer = io::Cursor::new(Vec::new());
+
+ let spec = WavSpecEx {
+ spec: WavSpec {
+ channels: 2,
+ sample_rate: 48000,
+ bits_per_sample: 24,
+ sample_format: SampleFormat::Int,
+ },
+ bytes_per_sample: 4,
+ };
+ {
+ let mut writer = WavWriter::new_with_spec_ex(&mut buffer, spec).unwrap();
+ assert!(writer.write_sample(-96_i32).is_ok());
+ assert!(writer.write_sample(23_052_i32).is_ok());
+ assert!(writer.write_sample(8_388_607_i32).is_ok());
+ assert!(writer.write_sample(-8_360_672_i32).is_ok());
+ }
+
+ let mut expected = Vec::new();
+ File::open("testsamples/waveformatextensible-24bit-4byte-48kHz-stereo.wav")
+ .unwrap()
+ .read_to_end(&mut expected)
+ .unwrap();
+
+ assert_eq!(buffer.into_inner(), expected);
+}
diff --git a/testsamples/fuzz/crash-24728523ef4be15c838293b676f6853e73723bf4.wav b/testsamples/fuzz/crash-24728523ef4be15c838293b676f6853e73723bf4.wav
new file mode 100644
index 0000000..b092015
--- /dev/null
+++ b/testsamples/fuzz/crash-24728523ef4be15c838293b676f6853e73723bf4.wav
Binary files differ
diff --git a/testsamples/fuzz/crash-b8447179832529c48f9c6bf17feab6337bbc78ea.wav b/testsamples/fuzz/crash-b8447179832529c48f9c6bf17feab6337bbc78ea.wav
new file mode 100644
index 0000000..3c9517d
--- /dev/null
+++ b/testsamples/fuzz/crash-b8447179832529c48f9c6bf17feab6337bbc78ea.wav
Binary files differ
diff --git a/testsamples/fuzz/crash-cbd757427cea12bd8a21f86cd8cf74d98ce56bee.wav b/testsamples/fuzz/crash-cbd757427cea12bd8a21f86cd8cf74d98ce56bee.wav
new file mode 100644
index 0000000..4c0ee74
--- /dev/null
+++ b/testsamples/fuzz/crash-cbd757427cea12bd8a21f86cd8cf74d98ce56bee.wav
Binary files differ
diff --git a/testsamples/fuzz/crash-e5471f5b58397287b509db7d026e95f1724454f5.wav b/testsamples/fuzz/crash-e5471f5b58397287b509db7d026e95f1724454f5.wav
new file mode 100644
index 0000000..44fddd2
--- /dev/null
+++ b/testsamples/fuzz/crash-e5471f5b58397287b509db7d026e95f1724454f5.wav
Binary files differ
diff --git a/testsamples/fuzz/crash-e879de4eb4d206c59e21f0e01def16457af80fdc.wav b/testsamples/fuzz/crash-e879de4eb4d206c59e21f0e01def16457af80fdc.wav
new file mode 100644
index 0000000..b460b72
--- /dev/null
+++ b/testsamples/fuzz/crash-e879de4eb4d206c59e21f0e01def16457af80fdc.wav
Binary files differ
diff --git a/testsamples/fuzz/oom-48ae4cd061ff8578ad3f23dc87624bd365cf5216.wav b/testsamples/fuzz/oom-48ae4cd061ff8578ad3f23dc87624bd365cf5216.wav
new file mode 100644
index 0000000..fd06dca
--- /dev/null
+++ b/testsamples/fuzz/oom-48ae4cd061ff8578ad3f23dc87624bd365cf5216.wav
@@ -0,0 +1 @@
+RIFFPIFFWAVEooooRIF±FF
\ No newline at end of file
diff --git a/testsamples/nonstandard-01.wav b/testsamples/nonstandard-01.wav
new file mode 100644
index 0000000..95afc56
--- /dev/null
+++ b/testsamples/nonstandard-01.wav
Binary files differ
diff --git a/testsamples/nonstandard-02.wav b/testsamples/nonstandard-02.wav
new file mode 100644
index 0000000..8cd1df4
--- /dev/null
+++ b/testsamples/nonstandard-02.wav
Binary files differ
diff --git a/testsamples/pcmwaveformat-16bit-44100Hz-mono-extra.wav b/testsamples/pcmwaveformat-16bit-44100Hz-mono-extra.wav
new file mode 100644
index 0000000..9680aba
--- /dev/null
+++ b/testsamples/pcmwaveformat-16bit-44100Hz-mono-extra.wav
Binary files differ
diff --git a/testsamples/pcmwaveformat-16bit-44100Hz-mono.wav b/testsamples/pcmwaveformat-16bit-44100Hz-mono.wav
new file mode 100644
index 0000000..4a673d3
--- /dev/null
+++ b/testsamples/pcmwaveformat-16bit-44100Hz-mono.wav
Binary files differ
diff --git a/testsamples/pcmwaveformat-24bit-4byte-48kHz-stereo.wav b/testsamples/pcmwaveformat-24bit-4byte-48kHz-stereo.wav
new file mode 100644
index 0000000..1f0d6f6
--- /dev/null
+++ b/testsamples/pcmwaveformat-24bit-4byte-48kHz-stereo.wav
Binary files differ
diff --git a/testsamples/pcmwaveformat-8bit-44100Hz-mono.wav b/testsamples/pcmwaveformat-8bit-44100Hz-mono.wav
new file mode 100644
index 0000000..d51e53a
--- /dev/null
+++ b/testsamples/pcmwaveformat-8bit-44100Hz-mono.wav
Binary files differ
diff --git a/testsamples/pop.wav b/testsamples/pop.wav
new file mode 100644
index 0000000..9e61802
--- /dev/null
+++ b/testsamples/pop.wav
Binary files differ
diff --git a/testsamples/waveformatex-16bit-44100Hz-mono-extra.wav b/testsamples/waveformatex-16bit-44100Hz-mono-extra.wav
new file mode 100644
index 0000000..d3159a9
--- /dev/null
+++ b/testsamples/waveformatex-16bit-44100Hz-mono-extra.wav
Binary files differ
diff --git a/testsamples/waveformatex-16bit-44100Hz-mono.wav b/testsamples/waveformatex-16bit-44100Hz-mono.wav
new file mode 100644
index 0000000..5de7062
--- /dev/null
+++ b/testsamples/waveformatex-16bit-44100Hz-mono.wav
Binary files differ
diff --git a/testsamples/waveformatex-16bit-44100Hz-stereo.wav b/testsamples/waveformatex-16bit-44100Hz-stereo.wav
new file mode 100644
index 0000000..475de3a
--- /dev/null
+++ b/testsamples/waveformatex-16bit-44100Hz-stereo.wav
Binary files differ
diff --git a/testsamples/waveformatex-8bit-11025Hz-mono.wav b/testsamples/waveformatex-8bit-11025Hz-mono.wav
new file mode 100644
index 0000000..95ab441
--- /dev/null
+++ b/testsamples/waveformatex-8bit-11025Hz-mono.wav
Binary files differ
diff --git a/testsamples/waveformatex-ieeefloat-44100Hz-mono.wav b/testsamples/waveformatex-ieeefloat-44100Hz-mono.wav
new file mode 100644
index 0000000..73e51ba
--- /dev/null
+++ b/testsamples/waveformatex-ieeefloat-44100Hz-mono.wav
Binary files differ
diff --git a/testsamples/waveformatextensible-24bit-192kHz-mono.wav b/testsamples/waveformatextensible-24bit-192kHz-mono.wav
new file mode 100644
index 0000000..71cd6ae
--- /dev/null
+++ b/testsamples/waveformatextensible-24bit-192kHz-mono.wav
Binary files differ
diff --git a/testsamples/waveformatextensible-24bit-4byte-48kHz-stereo.wav b/testsamples/waveformatextensible-24bit-4byte-48kHz-stereo.wav
new file mode 100644
index 0000000..f19c243
--- /dev/null
+++ b/testsamples/waveformatextensible-24bit-4byte-48kHz-stereo.wav
Binary files differ
diff --git a/testsamples/waveformatextensible-32bit-48kHz-stereo.wav b/testsamples/waveformatextensible-32bit-48kHz-stereo.wav
new file mode 100644
index 0000000..3984a2e
--- /dev/null
+++ b/testsamples/waveformatextensible-32bit-48kHz-stereo.wav
Binary files differ
diff --git a/testsamples/waveformatextensible-ieeefloat-44100Hz-mono.wav b/testsamples/waveformatextensible-ieeefloat-44100Hz-mono.wav
new file mode 100644
index 0000000..06306ca
--- /dev/null
+++ b/testsamples/waveformatextensible-ieeefloat-44100Hz-mono.wav
Binary files differ
