add tests for buffered, fix buffered parameters_changed

dvdsk · dvdsk · commit 2c60bf1835fc · 2025-02-26T18:27:47.000+01:00
diff --git a/src/source/buffered.rs b/src/source/buffered.rs
@@ -1,19 +1,25 @@
+/// A iterator that stores extracted data in memory while allowing
+/// concurrent reading in real time.
 use std::mem;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
 use super::SeekError;
 use crate::common::{ChannelCount, SampleRate};
+use crate::math::PrevMultipleOf;
 use crate::Source;
 
-/// Iterator that at the same time extracts data from the iterator and stores it in a buffer.
+/// Iterator that at the same time extracts data from the iterator and
+/// stores it in a buffer.
 pub struct Buffered<I>
 where
     I: Source,
 {
     /// Immutable reference to the next span of data. Cannot be `Span::Input`.
     current_span: Arc<Span<I>>,
 
+    parameters_changed: bool,
+
     /// The position in number of samples of this iterator inside `current_span`.
     position_in_span: usize,
 
@@ -30,6 +36,7 @@ impl<I: Source> Buffered<I> {
             current_span: first_span,
             position_in_span: 0,
             total_duration,
+            parameters_changed: false,
         }
     }
 
@@ -46,6 +53,7 @@ impl<I: Source> Buffered<I> {
                 Span::End => next_span_ptr.clone(),
                 Span::Input(input) => {
                     let input = input.lock().unwrap().take().unwrap();
+                    dbg!();
                     extract(input)
                 }
             };
@@ -70,7 +78,7 @@ where
         let current_sample;
         let advance_span;
 
-        match &*self.current_span {
+        match dbg!(&*self.current_span) {
             Span::Data(SpanData { data, .. }) => {
                 current_sample = Some(data[self.position_in_span]);
                 self.position_in_span += 1;
@@ -86,39 +94,31 @@ where
         };
 
         if advance_span {
+            dbg!();
+            self.parameters_changed = true;
             self.next_span();
+        } else {
+            self.parameters_changed = false;
         }
 
         current_sample
     }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        // TODO:
-        (0, None)
-    }
 }
 
-// TODO: implement exactsize iterator when size_hint is done
-
 impl<I> Source for Buffered<I>
 where
     I: Source,
 {
     #[inline]
     fn parameters_changed(&self) -> bool {
-        match &*self.current_span {
-            Span::Data(_) => false,
-            Span::End => true,
-            Span::Input(_) => unreachable!(),
-        }
+        self.parameters_changed
     }
 
     #[inline]
     fn channels(&self) -> ChannelCount {
         match *self.current_span {
             Span::Data(SpanData { channels, .. }) => channels,
-            Span::End => 1,
+            Span::End => 0,
             Span::Input(_) => unreachable!(),
         }
     }
@@ -127,7 +127,7 @@ where
     fn sample_rate(&self) -> SampleRate {
         match *self.current_span {
             Span::Data(SpanData { rate, .. }) => rate,
-            Span::End => 44100,
+            Span::End => 0,
             Span::Input(_) => unreachable!(),
         }
     }
@@ -157,6 +157,7 @@ where
             current_span: self.current_span.clone(),
             position_in_span: self.position_in_span,
             total_duration: self.total_duration,
+            parameters_changed: self.parameters_changed,
         }
     }
 }
@@ -165,8 +166,8 @@ enum Span<I>
 where
     I: Source,
 {
-    /// Data that has already been extracted from the iterator. Also contains a pointer to the
-    /// next span.
+    /// Data that has already been extracted from the iterator.
+    /// Also contains a pointer to the next span.
     Data(SpanData<I>),
 
     /// No more data.
@@ -177,6 +178,16 @@ where
     Input(Mutex<Option<I>>),
 }
 
+impl<I: Source> std::fmt::Debug for Span<I> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Span::Data(_) => f.write_str("Span::Data"),
+            Span::End => f.write_str("Span::End"),
+            Span::Input(_) => f.write_str("Span::Input"),
+        }
+    }
+}
+
 struct SpanData<I>
 where
     I: Source,
@@ -221,26 +232,23 @@ fn extract<I>(mut input: I) -> Arc<Span<I>>
 where
     I: Source,
 {
-    if input.parameters_changed() {
-        return Arc::new(Span::End);
-    }
-
     let channels = input.channels();
     let rate = input.sample_rate();
 
     let mut data = Vec::new();
     loop {
-        let Some(element) = input.next() else { break };
-        data.push(element);
+        let Some(sample) = input.next() else { break };
+        data.push(sample);
+        dbg!(sample);
         if input.parameters_changed() {
             break;
         }
-        if data.len() > 32768 {
+        if data.len() > 32768.prev_multiple_of(channels) {
             break;
         }
     }
 
-    if data.is_empty() {
+    if dbg!(data.is_empty()) {
         return Arc::new(Span::End);
     }
 
diff --git a/tests/buffered.rs b/tests/buffered.rs
@@ -0,0 +1,82 @@
+mod test_support;
+use rodio::Source;
+use test_support::{TestSource, TestSpan};
+
+#[test]
+fn parameters_change_correct() {
+    let mut source = TestSource::new()
+        .with_span(TestSpan::silence().with_sample_count(10))
+        .with_span(TestSpan::silence().with_sample_count(10))
+        .buffered();
+
+    assert_eq!(source.by_ref().take(10).count(), 10);
+    assert!(source.parameters_changed());
+
+    assert!(source.next().is_some());
+    assert!(!source.parameters_changed());
+
+    assert_eq!(source.count(), 9);
+}
+
+#[test]
+fn channel_count_changes() {
+    let mut source = TestSource::new()
+        .with_span(
+            TestSpan::silence()
+                .with_channel_count(1)
+                .with_sample_count(10),
+        )
+        .with_span(
+            TestSpan::silence()
+                .with_channel_count(2)
+                .with_sample_count(10),
+        )
+        .buffered();
+
+    assert_eq!(source.channels(), 1);
+    assert_eq!(source.by_ref().take(10).count(), 10);
+    assert_eq!(source.channels(), 2);
+}
+
+#[test]
+fn buffered_sample_rate_changes() {
+    let mut source = TestSource::new()
+        .with_span(
+            TestSpan::silence()
+                .with_sample_rate(10)
+                .with_sample_count(10),
+        )
+        .with_span(
+            TestSpan::silence()
+                .with_sample_rate(20)
+                .with_sample_count(10),
+        )
+        .buffered();
+
+    assert_eq!(source.sample_rate(), 10);
+    assert_eq!(source.by_ref().take(10).count(), 10);
+    assert_eq!(source.sample_rate(), 20);
+}
+
+#[test]
+fn equals_unbuffered() {
+    let mut source = TestSource::new()
+        .with_span(
+            TestSpan::from_samples((0..10).into_iter().map(|n| n as f32))
+                .with_sample_rate(10)
+                .with_sample_count(10),
+        )
+        .with_span(
+            TestSpan::silence()
+                .with_sample_rate(20)
+                .with_sample_count(10),
+        );
+
+    let mut buffered = source.clone().buffered();
+    for (sample, expected) in buffered.by_ref().zip(source.by_ref()) {
+        assert_eq!(sample, expected);
+    }
+
+    assert!(buffered.next().is_none());
+    assert!(source.next().is_none());
+}
diff --git a/tests/peekable.rs b/tests/peekable.rs
@@ -6,11 +6,11 @@ use test_support::{TestSource, TestSpan};
 fn peeked_matches_next() {
     let source = TestSource::new()
         .with_span(
-            TestSpan::from_samples(&(0..10).map(|n| n as f32).collect::<Vec<_>>())
+            TestSpan::from_samples((0..10).map(|n| n as f32))
                 .with_sample_count(10),
         )
         .with_span(
-            TestSpan::from_samples(&(10..20).map(|n| n as f32).collect::<Vec<_>>())
+            TestSpan::from_samples((10..20).map(|n| n as f32))
                 .with_sample_count(10),
         );
 
diff --git a/tests/test_support/mod.rs b/tests/test_support/mod.rs
@@ -92,8 +92,8 @@ impl TestSpan {
             channels: 1,
         }
     }
-    pub fn from_samples<'a>(samples: impl IntoIterator<Item = &'a f32>) -> TestSpanBuilder {
-        let samples = samples.into_iter().copied().collect::<Vec<f32>>();
+    pub fn from_samples<'a>(samples: impl IntoIterator<Item = Sample>) -> TestSpanBuilder {
+        let samples = samples.into_iter().collect::<Vec<Sample>>();
         TestSpanBuilder {
             sample_source: SampleSource::List(samples),
             sample_rate: 1,
@@ -306,6 +306,7 @@ impl rodio::Source for TestSource {
 
 // test for your tests of course. Leave these in, they guard regression when we
 // expand the functionally which we probably will.
+#[test]
 fn parameters_change_correct() {
     let mut source = TestSource::new()
         .with_span(TestSpan::silence().with_sample_count(10))
@@ -381,3 +382,25 @@ fn sine_abs_avg_not_zero() {
     let avg = sine.clone().map(f32::abs).sum::<f32>() / sine.spans[0].len() as f32;
     assert!(avg > 0.5);
 }
+
+#[test]
+fn size_hint() {
+    let mut source = TestSource::new()
+        .with_span(
+            TestSpan::silence()
+                .with_sample_rate(10)
+                .with_sample_count(10),
+        )
+        .with_span(
+            TestSpan::silence()
+                .with_sample_rate(20)
+                .with_sample_count(10),
+        );
+
+    assert_eq!(source.len(), 20);
+    assert_eq!(source.by_ref().take(10).count(), 10);
+    assert_eq!(source.len(), 10);
+    assert_eq!(source.by_ref().take(10).count(), 10);
+    assert_eq!(source.len(), 0);
+    assert!(source.next().is_none())
+}
