Add integer-samples feature and fix zero detection tests

- Add integer-samples feature to optionally use i16 instead of f32 samples
- Fix unreliable zero detection in WAV and MP4 tests using Sample::is_zero()
- Improve test reliability by checking !all(is_zero) instead of any(!=0.0)

The new feature allows applications to choose between floating-point
and fixed-point sample representation based on their needs, while
maintaining f32 the default for best sound quality.

Author: roderickvd

Diff for: Cargo.toml

@@ -30,17 +30,28 @@ default = ["playback", "flac", "vorbis", "wav", "mp3"]
 tracing = ["dep:tracing"]
 experimental = ["dep:atomic_float"]
 playback = ["dep:cpal"]
+integer-samples = []
 
 flac = ["claxon"]
 vorbis = ["lewton"]
 wav = ["hound"]
 mp3 = ["symphonia-mp3"]
 minimp3 = ["dep:minimp3_fixed"]
+
 noise = ["rand"]
+
 wasm-bindgen = ["cpal/wasm-bindgen"]
 cpal-shared-stdcxx = ["cpal/oboe-shared-stdcxx"]
+
 symphonia-aac = ["symphonia/aac"]
-symphonia-all = ["symphonia-aac", "symphonia-flac", "symphonia-isomp4", "symphonia-mp3", "symphonia-vorbis", "symphonia-wav"]
+symphonia-all = [
+    "symphonia-aac",
+    "symphonia-flac",
+    "symphonia-isomp4",
+    "symphonia-mp3",
+    "symphonia-vorbis",
+    "symphonia-wav",
+]
 symphonia-flac = ["symphonia/flac"]
 symphonia-isomp4 = ["symphonia/isomp4"]
 symphonia-mp3 = ["symphonia/mp3"]

Diff for: benches/shared.rs

@@ -2,6 +2,7 @@ use std::io::Cursor;
 use std::time::Duration;
 use std::vec;
 
+use dasp_sample::Sample;
 use rodio::{ChannelCount, SampleRate, Source};
 
 pub struct TestSource<T> {
@@ -57,7 +58,11 @@ impl TestSource<f32> {
             channels: sound.channels(),
             sample_rate: sound.sample_rate(),
             total_duration: duration,
-            samples: sound.into_iter().collect::<Vec<_>>().into_iter(),
+            samples: sound
+                .into_iter()
+                .map(|s| s.to_sample())
+                .collect::<Vec<_>>()
+                .into_iter(),
         }
     }
 
@@ -70,7 +75,7 @@ impl TestSource<f32> {
             total_duration,
         } = self;
         let samples = samples
-            .map(|s| dasp_sample::Sample::from_sample(s))
+            .map(|s| s.to_sample())
             .collect::<Vec<_>>()
             .into_iter();
         TestSource {

Diff for: src/conversions/sample.rs

@@ -72,6 +72,9 @@ where
 /// You can implement this trait on your own type as well if you wish so.
 ///
 pub trait Sample: DaspSample + ToSample<f32> {
+    /// The value corresponding to the absence of sound.
+    const ZERO_VALUE: Self = DaspSample::EQUILIBRIUM;
+
     /// Linear interpolation between two samples.
     ///
     /// The result should be equivalent to
@@ -93,9 +96,9 @@ pub trait Sample: DaspSample + ToSample<f32> {
     /// Calls `saturating_add` on the sample.
     fn saturating_add(self, other: Self) -> Self;
 
-    /// Returns the value corresponding to the absence of sound.
-    fn zero_value() -> Self {
-        Self::EQUILIBRIUM
+    /// Returns true if the sample is the zero value.
+    fn is_zero(self) -> bool {
+        self == Self::ZERO_VALUE
     }
 }
 

Diff for: src/decoder/mod.rs

@@ -31,6 +31,10 @@ mod vorbis;
 #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
 mod wav;
 
+#[cfg(feature = "integer-samples")]
+/// Output format of the decoders.
+pub type DecoderSample = i16;
+#[cfg(not(feature = "integer-samples"))]
 /// Output format of the decoders.
 pub type DecoderSample = f32;
 

Diff for: src/lib.rs

@@ -133,11 +133,21 @@
 //! The "tracing" feature replaces the print to stderr when a stream error happens with a
 //! recording an error event with tracing.
 //!
-//! ### Feature "Noise"
+//! ### Feature "noise"
 //!
 //! The "noise" feature adds support for white and pink noise sources. This feature requires the
 //! "rand" crate.
 //!
+//! ### Feature "playback"
+//!
+//! The "playback" feature adds support for playing audio. This feature requires the "cpal" crate.
+//!
+//! ### Feature "integer-samples"
+//!
+//! The "integer-samples" changes the output format of the decoders to use `i16` instead of `f32`.
+//! This is useful if you want to decode audio on an exotic, low-spec or old device that does not
+//! have hardware support for floating-point operations.
+//!
 //! ## How it works under the hood
 //!
 //! Rodio spawns a background thread that is dedicated to reading from the sources and sending

Diff for: src/mixer.rs

@@ -197,7 +197,7 @@ where
     }
 
     fn sum_current_sources(&mut self) -> S {
-        let mut sum = S::zero_value();
+        let mut sum = S::ZERO_VALUE;
 
         for mut source in self.current_sources.drain(..) {
             if let Some(value) = source.next() {

Diff for: src/source/channel_volume.rs

@@ -36,11 +36,7 @@ where
         let mut sample = None;
         for _ in 0..input.channels() {
             if let Some(s) = input.next() {
-                sample = Some(
-                    sample
-                        .get_or_insert_with(I::Item::zero_value)
-                        .saturating_add(s),
-                );
+                sample = Some(sample.get_or_insert(I::Item::ZERO_VALUE).saturating_add(s));
             }
         }
         ChannelVolume {
@@ -96,7 +92,7 @@ where
                 if let Some(s) = self.input.next() {
                     self.current_sample = Some(
                         self.current_sample
-                            .get_or_insert_with(I::Item::zero_value)
+                            .get_or_insert(I::Item::ZERO_VALUE)
                             .saturating_add(s),
                     );
                 }

Diff for: src/source/delay.rs

@@ -70,7 +70,7 @@ where
     fn next(&mut self) -> Option<<I as Iterator>::Item> {
         if self.remaining_samples >= 1 {
             self.remaining_samples -= 1;
-            Some(Sample::zero_value())
+            Some(Sample::ZERO_VALUE)
         } else {
             self.input.next()
         }

Diff for: src/source/pausable.rs

@@ -82,12 +82,12 @@ where
     fn next(&mut self) -> Option<I::Item> {
         if self.remaining_paused_samples > 0 {
             self.remaining_paused_samples -= 1;
-            return Some(I::Item::zero_value());
+            return Some(I::Item::ZERO_VALUE);
         }
 
         if let Some(paused_channels) = self.paused_channels {
             self.remaining_paused_samples = paused_channels - 1;
-            return Some(I::Item::zero_value());
+            return Some(I::Item::ZERO_VALUE);
         }
 
         self.input.next()

Diff for: src/source/zero.rs

@@ -54,12 +54,12 @@ where
         if let Some(num_samples) = self.num_samples {
             if num_samples > 0 {
                 self.num_samples = Some(num_samples - 1);
-                Some(S::zero_value())
+                Some(S::ZERO_VALUE)
             } else {
                 None
             }
         } else {
-            Some(S::zero_value())
+            Some(S::ZERO_VALUE)
         }
     }
 }

Diff for: tests/flac_test.rs

@@ -3,6 +3,8 @@ use rodio::Source;
 #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
 use std::time::Duration;
 
+use rodio::Sample;
+
 #[cfg(any(feature = "flac", feature = "symphonia-flac"))]
 #[test]
 fn test_flac_encodings() {
@@ -11,8 +13,9 @@ fn test_flac_encodings() {
     // 16 bit FLAC file exported from Audacity (2 channels, compression level 5)
     let file = std::fs::File::open("assets/audacity16bit_level5.flac").unwrap();
     let mut decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();
+
     // File is not just silence
-    assert!(decoder.any(|x| x != 0.0));
+    assert!(!decoder.all(|x| x.is_zero()));
     // Symphonia does not expose functionality to get the duration so this check must be disabled
     #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
     assert_eq!(decoder.total_duration(), Some(Duration::from_secs(3))); // duration is calculated correctly
@@ -21,7 +24,7 @@ fn test_flac_encodings() {
     for level in &[0, 5, 8] {
         let file = std::fs::File::open(format!("assets/audacity24bit_level{level}.flac")).unwrap();
         let mut decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();
-        assert!(decoder.any(|x| x != 0.0));
+        assert!(!decoder.all(|x| x.is_zero()));
         #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
         assert_eq!(decoder.total_duration(), Some(Duration::from_secs(3)));
     }

Diff for: tests/mp4a_test.rs

@@ -1,6 +1,8 @@
 #![cfg(all(feature = "symphonia-aac", feature = "symphonia-isomp4"))]
 use std::io::BufReader;
 
+use rodio::Sample;
+
 #[test]
 fn test_mp4a_encodings() {
     // mp4a codec downloaded from YouTube
@@ -10,5 +12,5 @@ fn test_mp4a_encodings() {
     // http://creativecommons.org/licenses/by/3.0/
     let file = std::fs::File::open("assets/monkeys.mp4a").unwrap();
     let mut decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();
-    assert!(decoder.any(|x| x != 0.0)); // Assert not all zeros
+    assert!(!decoder.all(|x| x.is_zero())); // Assert not all zeros
 }

Diff for: tests/wav_test.rs

@@ -1,3 +1,5 @@
+use rodio::Sample;
+
 #[cfg(feature = "wav")]
 #[test]
 fn test_wav_encodings() {
@@ -6,30 +8,30 @@ fn test_wav_encodings() {
     // 16 bit wav file exported from Audacity (1 channel)
     let file = std::fs::File::open("assets/audacity16bit.wav").unwrap();
     let mut decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();
-    assert!(decoder.any(|x| x != 0.0)); // Assert not all zeros
+    assert!(!decoder.all(|x| x.is_zero())); // Assert not all zeros
 
     // 16 bit wav file exported from LMMS (2 channels)
     let file = std::fs::File::open("assets/lmms16bit.wav").unwrap();
     let mut decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();
-    assert!(decoder.any(|x| x != 0.0));
+    assert!(!decoder.all(|x| x.is_zero()));
 
     // 24 bit wav file exported from LMMS (2 channels)
     let file = std::fs::File::open("assets/lmms24bit.wav").unwrap();
     let mut decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();
-    assert!(decoder.any(|x| x != 0.0));
+    assert!(!decoder.all(|x| x.is_zero()));
 
     // 32 bit wav file exported from Audacity (1 channel)
     let file = std::fs::File::open("assets/audacity32bit.wav").unwrap();
     let mut decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();
-    assert!(decoder.any(|x| x != 0.0));
+    assert!(!decoder.all(|x| x.is_zero()));
 
     // 32 bit wav file exported from LMMS (2 channels)
     let file = std::fs::File::open("assets/lmms32bit.wav").unwrap();
     let mut decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();
-    assert!(decoder.any(|x| x != 0.0));
+    assert!(!decoder.all(|x| x.is_zero()));
 
     // 32 bit signed integer wav file exported from Audacity (1 channel).
     let file = std::fs::File::open("assets/audacity32bit_int.wav").unwrap();
     let mut decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();
-    assert!(decoder.any(|x| x != 0.0));
+    assert!(!decoder.all(|x| x.is_zero()));
 }