rename ch! macro to nz and make SampleRate NonZero

Similar to the channels situation a lot of bugs seem to be caused by
zero sample_rate. Since audio can literally not play at zero speed it
makes no sense to have zero sample_rate's.

Author: dvdsk

benches/pipeline.rs

@@ -1,3 +1,4 @@
+use std::num::NonZero;
 use std::time::Duration;
 
 use divan::Bencher;
@@ -32,8 +33,11 @@ fn long(bencher: Bencher) {
             .buffered()
             .reverb(Duration::from_secs_f32(0.05), 0.3)
             .skippable();
-        let resampled =
-            UniformSourceIterator::new(effects_applied, ChannelCount::new(2).unwrap(), 40_000);
+        let resampled = UniformSourceIterator::new(
+            effects_applied,
+            ChannelCount::new(2).unwrap(),
+            NonZero::new(40_000).unwrap(),
+        );
         resampled.for_each(divan::black_box_drop)
     })
 }

benches/resampler.rs

@@ -4,7 +4,7 @@ use rodio::source::UniformSourceIterator;
 mod shared;
 use shared::music_wav;
 
-use rodio::Source;
+use rodio::{SampleRate, Source};
 
 fn main() {
     divan::main();
@@ -31,6 +31,7 @@ const COMMON_SAMPLE_RATES: [u32; 12] = [
 
 #[divan::bench(args = COMMON_SAMPLE_RATES)]
 fn resample_to(bencher: Bencher, target_sample_rate: u32) {
+    let target_sample_rate = SampleRate::new(target_sample_rate).unwrap();
     bencher
         .with_inputs(|| {
             let source = music_wav();

benches/shared.rs

@@ -7,7 +7,7 @@ use rodio::{ChannelCount, Sample, SampleRate, Source};
 pub struct TestSource {
     samples: vec::IntoIter<Sample>,
     channels: ChannelCount,
-    sample_rate: u32,
+    sample_rate: SampleRate,
     total_duration: Duration,
 }
 

examples/custom_config.rs

@@ -3,6 +3,7 @@ use cpal::{BufferSize, SampleFormat};
 use rodio::source::SineWave;
 use rodio::Source;
 use std::error::Error;
+use std::num::NonZero;
 use std::thread;
 use std::time::Duration;
 
@@ -15,7 +16,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         // No need to set all parameters explicitly here,
         // the defaults were set from the device's description.
         .with_buffer_size(BufferSize::Fixed(256))
-        .with_sample_rate(48_000)
+        .with_sample_rate(NonZero::new(48_000).unwrap())
         .with_sample_format(SampleFormat::F32)
         // Note that the function below still tries alternative configs if the specified one fails.
         // If you need to only use the exact specified configuration,

examples/mix_multiple_sources.rs

@@ -6,7 +6,7 @@ use std::time::Duration;
 
 fn main() -> Result<(), Box<dyn Error>> {
     // Construct a dynamic controller and mixer, stream_handle, and sink.
-    let (controller, mixer) = mixer::mixer(NonZero::new(2).unwrap(), 44_100);
+    let (controller, mixer) = mixer::mixer(NonZero::new(2).unwrap(), NonZero::new(44_100).unwrap());
     let stream_handle = rodio::OutputStreamBuilder::open_default_stream()?;
     let sink = rodio::Sink::connect_new(&stream_handle.mixer());
 

examples/signal_generator.rs

@@ -1,6 +1,7 @@
 //! Test signal generator example.
 
 use std::error::Error;
+use std::num::NonZero;
 
 fn main() -> Result<(), Box<dyn Error>> {
     use rodio::source::{chirp, Function, SignalGenerator, Source};
@@ -11,7 +12,7 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     let test_signal_duration = Duration::from_millis(1000);
     let interval_duration = Duration::from_millis(1500);
-    let sample_rate = 48000;
+    let sample_rate = NonZero::new(48000).unwrap();
 
     println!("Playing 1000 Hz tone");
     stream_handle.mixer().add(

src/buffer.rs

@@ -7,7 +7,7 @@
 //! ```
 //! use rodio::buffer::SamplesBuffer;
 //! use rodio::ChannelCount;
-//! let _ = SamplesBuffer::new(ChannelCount::new(1).unwrap(), 44100, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
+//! let _ = SamplesBuffer::new(ChannelCount::new(1).unwrap(), nz!(44100), vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
 //! ```
 //!
 
@@ -39,11 +39,9 @@ impl SamplesBuffer {
     where
         D: Into<Vec<Sample>>,
     {
-        assert!(sample_rate >= 1);
-
         let data = data.into();
         let duration_ns = 1_000_000_000u64.checked_mul(data.len() as u64).unwrap()
-            / sample_rate as u64
+            / sample_rate.get() as u64
             / channels.get() as u64;
         let duration = Duration::new(
             duration_ns / 1_000_000_000,
@@ -89,7 +87,8 @@ impl Source for SamplesBuffer {
         // sample directly.
 
         let curr_channel = self.pos % self.channels().get() as usize;
-        let new_pos = pos.as_secs_f32() * self.sample_rate() as f32 * self.channels().get() as f32;
+        let new_pos =
+            pos.as_secs_f32() * self.sample_rate().get() as f32 * self.channels().get() as f32;
         // saturate pos at the end of the source
         let new_pos = new_pos as usize;
         let new_pos = new_pos.min(self.data.len());
@@ -122,31 +121,31 @@ impl Iterator for SamplesBuffer {
 #[cfg(test)]
 mod tests {
     use crate::buffer::SamplesBuffer;
-    use crate::math::ch;
+    use crate::math::nz;
     use crate::source::Source;
 
     #[test]
     fn basic() {
-        let _ = SamplesBuffer::new(ch!(1), 44100, vec![0.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
+        let _ = SamplesBuffer::new(nz!(1), nz!(44100), vec![0.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
     }
 
     #[test]
     #[should_panic]
     fn panic_if_zero_sample_rate() {
-        SamplesBuffer::new(ch!(1), 0, vec![0.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
+        SamplesBuffer::new(nz!(1), nz!(0), vec![0.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
     }
 
     #[test]
     fn duration_basic() {
-        let buf = SamplesBuffer::new(ch!(2), 2, vec![0.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
+        let buf = SamplesBuffer::new(nz!(2), nz!(2), vec![0.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
         let dur = buf.total_duration().unwrap();
         assert_eq!(dur.as_secs(), 1);
         assert_eq!(dur.subsec_nanos(), 500_000_000);
     }
 
     #[test]
     fn iteration() {
-        let mut buf = SamplesBuffer::new(ch!(1), 44100, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
+        let mut buf = SamplesBuffer::new(nz!(1), nz!(44100), vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
         assert_eq!(buf.next(), Some(1.0));
         assert_eq!(buf.next(), Some(2.0));
         assert_eq!(buf.next(), Some(3.0));
@@ -165,8 +164,8 @@ mod tests {
 
         #[test]
         fn channel_order_stays_correct() {
-            const SAMPLE_RATE: SampleRate = 100;
-            const CHANNELS: ChannelCount = ch!(2);
+            const SAMPLE_RATE: SampleRate = nz!(100);
+            const CHANNELS: ChannelCount = nz!(2);
             let mut buf = SamplesBuffer::new(
                 CHANNELS,
                 SAMPLE_RATE,
@@ -178,7 +177,7 @@ mod tests {
             buf.try_seek(Duration::from_secs(5)).unwrap();
             assert_eq!(
                 buf.next(),
-                Some(5.0 * SAMPLE_RATE as f32 * CHANNELS.get() as f32)
+                Some(5.0 * SAMPLE_RATE.get() as f32 * CHANNELS.get() as f32)
             );
 
             assert!(buf.next().is_some_and(|s| s.trunc() as i32 % 2 == 1));

src/common.rs

@@ -1,7 +1,7 @@
 use std::num::NonZero;
 
 /// Stream sample rate (a frame rate or samples per second per channel).
-pub type SampleRate = u32;
+pub type SampleRate = NonZero<u32>;
 
 /// Number of channels in a stream. Can never be Zero
 pub type ChannelCount = NonZero<u16>;

src/conversions/channels.rs

@@ -108,37 +108,37 @@ impl<I> ExactSizeIterator for ChannelCountConverter<I> where I: ExactSizeIterato
 mod test {
     use super::ChannelCountConverter;
     use crate::common::ChannelCount;
-    use crate::math::ch;
+    use crate::math::nz;
     use crate::Sample;
 
     #[test]
     fn remove_channels() {
         let input = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
         let output =
-            ChannelCountConverter::new(input.into_iter(), ch!(3), ch!(2)).collect::<Vec<_>>();
+            ChannelCountConverter::new(input.into_iter(), nz!(3), nz!(2)).collect::<Vec<_>>();
         assert_eq!(output, [1.0, 2.0, 4.0, 5.0]);
 
         let input = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
         let output =
-            ChannelCountConverter::new(input.into_iter(), ch!(4), ch!(1)).collect::<Vec<_>>();
+            ChannelCountConverter::new(input.into_iter(), nz!(4), nz!(1)).collect::<Vec<_>>();
         assert_eq!(output, [1.0, 5.0]);
     }
 
     #[test]
     fn add_channels() {
         let input = vec![1.0, 2.0, 3.0, 4.0];
         let output =
-            ChannelCountConverter::new(input.into_iter(), ch!(1), ch!(2)).collect::<Vec<_>>();
+            ChannelCountConverter::new(input.into_iter(), nz!(1), nz!(2)).collect::<Vec<_>>();
         assert_eq!(output, [1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0]);
 
         let input = vec![1.0, 2.0];
         let output =
-            ChannelCountConverter::new(input.into_iter(), ch!(1), ch!(4)).collect::<Vec<_>>();
+            ChannelCountConverter::new(input.into_iter(), nz!(1), nz!(4)).collect::<Vec<_>>();
         assert_eq!(output, [1.0, 1.0, 0.0, 0.0, 2.0, 2.0, 0.0, 0.0]);
 
         let input = vec![1.0, 2.0, 3.0, 4.0];
         let output =
-            ChannelCountConverter::new(input.into_iter(), ch!(2), ch!(4)).collect::<Vec<_>>();
+            ChannelCountConverter::new(input.into_iter(), nz!(2), nz!(4)).collect::<Vec<_>>();
         assert_eq!(output, [1.0, 2.0, 0.0, 0.0, 3.0, 4.0, 0.0, 0.0]);
     }
 
@@ -155,24 +155,24 @@ mod test {
             assert_eq!(converter.size_hint(), (0, Some(0)));
         }
 
-        test(&[1.0, 2.0, 3.0], ch!(1), ch!(2));
-        test(&[1.0, 2.0, 3.0, 4.0], ch!(2), ch!(4));
-        test(&[1.0, 2.0, 3.0, 4.0], ch!(4), ch!(2));
-        test(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], ch!(3), ch!(8));
-        test(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], ch!(4), ch!(1));
+        test(&[1.0, 2.0, 3.0], nz!(1), nz!(2));
+        test(&[1.0, 2.0, 3.0, 4.0], nz!(2), nz!(4));
+        test(&[1.0, 2.0, 3.0, 4.0], nz!(4), nz!(2));
+        test(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], nz!(3), nz!(8));
+        test(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], nz!(4), nz!(1));
     }
 
     #[test]
     fn len_more() {
         let input = vec![1.0, 2.0, 3.0, 4.0];
-        let output = ChannelCountConverter::new(input.into_iter(), ch!(2), ch!(3));
+        let output = ChannelCountConverter::new(input.into_iter(), nz!(2), nz!(3));
         assert_eq!(output.len(), 6);
     }
 
     #[test]
     fn len_less() {
         let input = vec![1.0, 2.0, 3.0, 4.0];
-        let output = ChannelCountConverter::new(input.into_iter(), ch!(2), ch!(1));
+        let output = ChannelCountConverter::new(input.into_iter(), nz!(2), nz!(1));
         assert_eq!(output.len(), 2);
     }
 }