refactor: use SampleRate type throughout

Author: roderickvd

src/decoder/flac.rs

@@ -277,14 +277,15 @@ where
         let reader = FlacReader::new_ext(data, READER_OPTIONS).expect("should still be flac");
 
         let spec = reader.streaminfo();
-        let sample_rate = spec.sample_rate;
+        let sample_rate = SampleRate::new(spec.sample_rate)
+            .expect("flac data should never have a zero sample rate");
         let max_block_size = spec.max_block_size as usize * spec.channels as usize;
 
         // `samples` in FLAC means "inter-channel samples" aka frames
         // so we do not divide by `self.channels` here.
         let total_samples = spec.samples;
         let total_duration =
-            total_samples.map(|s| utils::samples_to_duration(s, sample_rate as u64));
+            total_samples.map(|s| utils::samples_to_duration(s, sample_rate));
 
         Ok(Self {
             reader: Some(reader),
@@ -293,8 +294,7 @@ where
             current_block_off: 0,
             bits_per_sample: BitDepth::new(spec.bits_per_sample)
                 .expect("flac should never have zero bits per sample"),
-            sample_rate: SampleRate::new(sample_rate)
-                .expect("flac data should never have a zero sample rate"),
+            sample_rate,
             channels: ChannelCount::new(
                 spec.channels
                     .try_into()

src/decoder/utils.rs

@@ -30,6 +30,9 @@
 #[cfg(any(feature = "claxon", feature = "hound"))]
 use std::time::Duration;
 
+#[cfg(any(feature = "claxon", feature = "hound"))]
+use crate::SampleRate;
+
 #[cfg(any(
     feature = "claxon",
     feature = "hound",
@@ -62,33 +65,11 @@ use std::io::{Read, Seek, SeekFrom};
 ///
 /// # Edge Cases
 ///
-/// - **Zero sample rate**: Returns `Duration::ZERO` to prevent division by zero
 /// - **Zero samples**: Returns `Duration::ZERO` (mathematically correct)
-/// - **Large values**: Handles overflow gracefully within Duration limits
-///
-/// # Examples
-///
-/// ```ignore
-/// use std::time::Duration;
-/// # use rodio::decoder::utils::samples_to_duration;
-///
-/// // 1 second at 44.1kHz
-/// assert_eq!(samples_to_duration(44100, 44100), Duration::from_secs(1));
-///
-/// // 0.5 seconds at 44.1kHz
-/// assert_eq!(samples_to_duration(22050, 44100), Duration::from_millis(500));
-/// ```
-///
-/// # Performance
-///
-/// This function is optimized for common audio sample rates and performs
-/// integer arithmetic only, making it suitable for real-time applications.
+/// - **Large values**: Handles overflow gracefully within `Duration` limits
 #[cfg(any(feature = "claxon", feature = "hound",))]
-pub(super) fn samples_to_duration(samples: u64, sample_rate: u64) -> Duration {
-    if sample_rate == 0 {
-        return Duration::ZERO;
-    }
-
+pub(super) fn samples_to_duration(samples: u64, sample_rate: SampleRate) -> Duration {
+    let sample_rate = sample_rate.get() as u64;
     let secs = samples / sample_rate;
     let nanos = ((samples % sample_rate) * 1_000_000_000) / sample_rate;
     Duration::new(secs, nanos as u32)
@@ -182,34 +163,31 @@ mod tests {
     #[test]
     fn test_samples_to_duration() {
         // Standard CD quality: 1 second at 44.1kHz
-        assert_eq!(samples_to_duration(44100, 44100), Duration::from_secs(1));
+        let rate_44_1k = SampleRate::new(44100).unwrap();
+        assert_eq!(
+            samples_to_duration(rate_44_1k.get() as u64, rate_44_1k),
+            Duration::from_secs(1)
+        );
 
         // Half second at CD quality
         assert_eq!(
-            samples_to_duration(22050, 44100),
+            samples_to_duration(rate_44_1k.get() as u64 / 2, rate_44_1k),
             Duration::from_millis(500)
         );
 
-        // Professional audio: 1 second at 48kHz
-        assert_eq!(samples_to_duration(48000, 48000), Duration::from_secs(1));
-
-        // High resolution: 1 second at 96kHz
-        assert_eq!(samples_to_duration(96000, 96000), Duration::from_secs(1));
-
         // Edge case: Zero samples should return zero duration
-        assert_eq!(samples_to_duration(0, 44100), Duration::ZERO);
-
-        // Edge case: Zero sample rate should not panic and return zero
-        assert_eq!(samples_to_duration(44100, 0), Duration::ZERO);
+        assert_eq!(samples_to_duration(0, rate_44_1k), Duration::ZERO);
 
         // Precision test: Fractional milliseconds
         // 441 samples at 44.1kHz = 10ms exactly
-        assert_eq!(samples_to_duration(441, 44100), Duration::from_millis(10));
+        assert_eq!(
+            samples_to_duration(rate_44_1k.get() as u64 / 100, rate_44_1k),
+            Duration::from_millis(10)
+        );
 
         // Very small durations should have nanosecond precision
-        // 1 sample at 44.1kHz ≈ 22.676 microseconds
-        let one_sample_duration = samples_to_duration(1, 44100);
-        assert!(one_sample_duration.as_nanos() > 22000);
-        assert!(one_sample_duration.as_nanos() < 23000);
+        // 1 sample at 44.1kHz ≈ 22.675 microseconds
+        let one_sample_duration = samples_to_duration(1, rate_44_1k);
+        assert_eq!(one_sample_duration.as_nanos(), 22675);
     }
 }

src/decoder/vorbis.rs

@@ -840,6 +840,8 @@ fn read_next_non_empty_packet<R: Read + Seek>(
 /// point a final linear scan ensures all granule positions are found. The packet
 /// limit during binary search prevents excessive scanning in dense regions.
 fn find_last_granule<R: Read + Seek>(data: &mut R, byte_len: u64) -> Option<u64> {
+    const BINARY_SEARCH_PACKET_LIMIT: usize = 50;
+
     // Save current position
     let original_pos = data.stream_position().unwrap_or_default();
     let _ = data.rewind();
@@ -853,7 +855,7 @@ fn find_last_granule<R: Read + Seek>(data: &mut R, byte_len: u64) -> Option<u64>
         let mid = left + (right - left) / 2;
 
         // Try to find a granule from this position (limited packet scan during binary search)
-        match find_granule_from_position(data, mid, Some(50)) {
+        match find_granule_from_position(data, mid, Some(BINARY_SEARCH_PACKET_LIMIT)) {
             Some(_granule) => {
                 // Found a granule, this means there's content at or after this position
                 best_start_position = mid;
@@ -894,9 +896,11 @@ fn find_last_granule<R: Read + Seek>(data: &mut R, byte_len: u64) -> Option<u64>
 ///
 /// # Packet Limit Rationale
 ///
+/// Maximum number of packets to scan during binary search optimization.
+///
 /// When used during binary search, the packet limit prevents excessive scanning:
 /// - **Typical Ogg pages**: Contain 1-10 packets depending on content
-/// - **50 packet limit**: Covers roughly 5-50 pages (~20-400KB depending on bitrate)
+/// - **Binary search limit**: Covers roughly 5-50 pages (~20-400KB depending on bitrate)
 /// - **Balance**: Finding granules quickly vs. avoiding excessive I/O during binary search
 /// - **Final scan**: No limit ensures complete coverage from optimized position
 ///

src/decoder/wav.rs

@@ -256,29 +256,32 @@ where
         let spec = reader.spec();
         let len = reader.len() as u64;
         let total_samples = reader.len();
+
+        let sample_rate = SampleRate::new(spec.sample_rate)
+            .expect("wav should have a sample rate higher than zero");
+        let channels = ChannelCount::new(spec.channels)
+            .expect("wav should have at least one channel");
+        let bits_per_sample = BitDepth::new(spec.bits_per_sample.into())
+            .expect("wav should have a bit depth higher than zero");
+
         let reader = SamplesIterator {
             reader,
             samples_read: 0,
             total_samples,
         };
 
-        let sample_rate = spec.sample_rate;
-        let channels = spec.channels;
-
         // len is number of samples, not bytes, so use samples_to_duration
         // Note: hound's len() returns total samples across all channels
-        let samples_per_channel = len / (channels as u64);
-        let total_duration = utils::samples_to_duration(samples_per_channel, sample_rate as u64);
+        let samples_per_channel = len / (channels.get() as u64);
+        let total_duration = utils::samples_to_duration(samples_per_channel, sample_rate);
 
         Ok(Self {
             reader,
             total_duration,
-            sample_rate: SampleRate::new(sample_rate)
-                .expect("wav should have a sample rate higher then zero"),
-            channels: ChannelCount::new(channels).expect("wav should have a least one channel"),
+            sample_rate,
+            channels,
             is_seekable: settings.is_seekable,
-            bits_per_sample: BitDepth::new(spec.bits_per_sample.into())
-                .expect("wav should have a bit depth higher then zero"),
+            bits_per_sample,
         })
     }