add test and fix take_span

Author: dvdsk

src/source/mix.rs

@@ -81,7 +81,7 @@ where
 {
     #[inline]
     fn parameters_changed(&self) -> bool {
-        self.input1.parameters_changed() || self.input2.parameters_changed()
+        false
     }
 
     #[inline]

src/source/take_span.rs

@@ -7,6 +7,7 @@ use crate::Source;
 /// A source that truncates the given source to a certain duration.
 #[derive(Clone, Debug)]
 pub struct TakeSpan<I> {
+    first: bool,
     input: I,
 }
 
@@ -15,7 +16,7 @@ where
     I: Source,
 {
     pub fn new(input: I) -> Self {
-        Self { input }
+        Self { first: true, input }
     }
 
     /// Returns a mutable reference to the inner source.
@@ -31,16 +32,14 @@ where
     }
 }
 
-impl<I> Iterator for TakeSpan<I>
-where
-    I: Source,
-{
+impl<I: Source> Iterator for TakeSpan<I> {
     type Item = <I as Iterator>::Item;
 
     fn next(&mut self) -> Option<<I as Iterator>::Item> {
-        if self.input.parameters_changed() {
+        if self.input.parameters_changed() && !self.first {
             None
         } else {
+            self.first = false;
             let sample = self.input.next()?;
             Some(sample)
         }

tests/take_span.rs

@@ -0,0 +1,35 @@
+use rodio::Source;
+use test_support::{TestSource, TestSpan};
+
+mod test_support;
+
+#[test]
+fn param_changes_during_skip() {
+    let source = TestSource::new()
+        .with_span(
+            TestSpan::sample_indexes()
+                .with_sample_rate(10)
+                .with_channel_count(1)
+                .with_sample_count(10),
+        )
+        .with_span(
+            TestSpan::sample_indexes()
+                .with_sample_rate(20)
+                .with_channel_count(2)
+                .with_sample_count(10),
+        );
+
+    let mut span_1 = source.take_span();
+    assert_eq!(span_1.by_ref().take(9).count(), 9);
+    assert_eq!(span_1.channels(), 1);
+    assert_eq!(span_1.sample_rate(), 10);
+    assert!(span_1.by_ref().next().is_some());
+    assert_eq!(span_1.by_ref().next(), None);
+
+    let mut span_2 = span_1.into_inner().take_span();
+    assert_eq!(span_2.by_ref().take(9).count(), 9);
+    assert_eq!(span_2.channels(), 2);
+    assert_eq!(span_2.sample_rate(), 20);
+    assert!(span_2.by_ref().next().is_some());
+    assert_eq!(span_2.by_ref().next(), None);
+}

tests/test_support/mod.rs

@@ -17,12 +17,14 @@ pub enum SampleSource {
     },
     Silence,
     List(Vec<f32>),
+    SampleIndex,
 }
 
 impl SampleSource {
     fn get(
         &mut self,
         pos: usize,
+        pos_in_source: usize,
         sample_rate: SampleRate,
         channels: ChannelCount,
         numb_samples: usize,
@@ -39,6 +41,8 @@ impl SampleSource {
                     .collect();
                 samples.get(pos).copied()
             }
+            SampleSource::SampleIndex if pos < numb_samples => Some(pos_in_source as f32),
+            SampleSource::SampleIndex => None,
             SampleSource::SignalGen { samples, .. } => samples.get(pos).copied(),
             SampleSource::Silence { .. } if pos < numb_samples => Some(0.0),
             SampleSource::Silence { .. } => None,
@@ -70,6 +74,13 @@ impl TestSpan {
             channels: 1,
         }
     }
+    pub fn sample_indexes() -> TestSpanBuilder {
+        TestSpanBuilder {
+            sample_source: SampleSource::SampleIndex,
+            sample_rate: 1,
+            channels: 1,
+        }
+    }
     pub fn sine(frequency: f32) -> TestSpanBuilder {
         TestSpanBuilder {
             sample_source: SampleSource::SignalGen {
@@ -101,9 +112,14 @@ impl TestSpan {
         }
     }
 
-    fn get(&mut self, pos: usize) -> Option<Sample> {
-        self.sample_source
-            .get(pos, self.sample_rate, self.channels, self.numb_samples)
+    fn get(&mut self, pos: usize, pos_in_source: usize) -> Option<Sample> {
+        self.sample_source.get(
+            pos,
+            pos_in_source,
+            self.sample_rate,
+            self.channels,
+            self.numb_samples,
+        )
     }
 
     pub fn len(&self) -> usize {
@@ -211,6 +227,7 @@ pub struct TestSource {
     pub spans: Vec<TestSpan>,
     current_span: usize,
     pos_in_span: usize,
+    pos_in_source: usize,
     parameters_changed: bool,
 }
 
@@ -221,6 +238,7 @@ impl TestSource {
             current_span: 0,
             pos_in_span: 0,
             parameters_changed: false,
+            pos_in_source: 0,
         }
     }
     pub fn with_span(mut self, span: TestSpan) -> Self {
@@ -234,7 +252,8 @@ impl Iterator for TestSource {
 
     fn next(&mut self) -> Option<Self::Item> {
         let current_span = self.spans.get_mut(self.current_span)?;
-        let sample = current_span.get(self.pos_in_span)?;
+        let sample = current_span.get(self.pos_in_span, self.pos_in_source)?;
+        self.pos_in_source += 1;
         self.pos_in_span += 1;
 
         // if span is out of samples