From 4be74582e9c3ccaefa0b270debc6e97727fcca5f Mon Sep 17 00:00:00 2001
From: dvdsk <noreply@davidsk.dev>
Date: Tue, 21 Jan 2025 13:08:26 +0100
Subject: [PATCH 01/11] Adjust Source docs: span must be whole frames.

This was already required by the various parts of rodio but never
mentioned anywhere.
---
 src/source/mod.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/source/mod.rs b/src/source/mod.rs
index 605057e8..00b9e597 100644
--- a/src/source/mod.rs
+++ b/src/source/mod.rs
@@ -152,13 +152,17 @@ pub use self::noise::{pink, white, PinkNoise, WhiteNoise};
 /// the number of samples that remain in the iterator before the samples rate and number of
 /// channels can potentially change.
 ///
+/// ## Span length
+/// A span *must* consists of whole frames and start at the beginning of a frame. In other words:
+/// the first sample of a span must be for channel 0 while the last sample must be for the last
+/// channel. That way the next span again starts at channel 0.
 pub trait Source: Iterator
 where
     Self::Item: Sample,
 {
-    /// Returns the number of samples before the current span ends. `None` means "infinite" or
-    /// "until the sound ends".
-    /// Should never return 0 unless there's no more data.
+    /// Returns the number of samples before the current span ends. This number **must** be a
+    /// multiple of channel count. `None` means "infinite" or "until the sound ends". Should never
+    /// return 0 unless there's no more data.
     ///
     /// After the engine has finished reading the specified number of samples, it will check
     /// whether the value of `channels()` and/or `sample_rate()` have changed.

From bc897b96ba71e462e26f6a413e0e1ed5ac6aef36 Mon Sep 17 00:00:00 2001
From: dvdsk <noreply@davidsk.dev>
Date: Tue, 21 Jan 2025 13:00:04 +0100
Subject: [PATCH 02/11] Fixes frames getting out of order due to constant
 span_length

The `current_span_length` is in samples not frames. Rodio was using a fixed
span_length for all sources regardless of their number of channels. If
that span length was not wholly dividable by the number of channels it
would create an offset.

Credit for finding this goes to: @will3942
---
 src/queue.rs | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/queue.rs b/src/queue.rs
index 2a2f434f..1732574e 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -117,7 +117,6 @@ pub struct SourcesQueueOutput<S> {
     input: Arc<SourcesQueueInput<S>>,
 }
 
-const THRESHOLD: usize = 512;
 impl<S> Source for SourcesQueueOutput<S>
 where
     S: Sample + Send + 'static,
@@ -143,7 +142,7 @@ where
                 && self.input.next_sounds.lock().unwrap().is_empty()
             {
                 // The next source will be a filler silence which will have the length of `THRESHOLD`
-                return Some(THRESHOLD);
+                return Some(self.silent_span_length());
             }
         }
 
@@ -156,7 +155,7 @@ where
         }
 
         // Otherwise we use the constant value.
-        Some(THRESHOLD)
+        Some(self.silent_span_length())
     }
 
     #[inline]
@@ -234,7 +233,10 @@ where
             let mut next = self.input.next_sounds.lock().unwrap();
 
             if next.len() == 0 {
-                let silence = Box::new(Zero::<S>::new_samples(1, 44100, THRESHOLD)) as Box<_>;
+                // queue reports number of channels for the current source. Not the silence source.
+                // `self.silent_span_length` accounts for this.
+                let silence =
+                    Box::new(Zero::<S>::new_samples(1, 44100, self.silent_span_length())) as Box<_>;
                 if self.input.keep_alive_if_empty.load(Ordering::Acquire) {
                     // Play a short silence in order to avoid spinlocking.
                     (silence, None)
@@ -250,6 +252,11 @@ where
         self.signal_after_end = signal_after_end;
         Ok(())
     }
+
+    /// 200 frames of silence
+    fn silent_span_length(&self) -> usize {
+        200 * self.channels() as usize
+    }
 }
 
 #[cfg(test)]

From 11a6a7fc9d96f18f8a0c9fd69a8d7d31cc78ecc1 Mon Sep 17 00:00:00 2001
From: dvdsk <noreply@davidsk.dev>
Date: Wed, 22 Jan 2025 16:45:27 +0100
Subject: [PATCH 03/11] try fixing queue by checking span len

---
 src/queue.rs | 257 +++++++++++++++++++++++++++++++--------------------
 src/sink.rs  |  14 ++-
 2 files changed, 168 insertions(+), 103 deletions(-)

diff --git a/src/queue.rs b/src/queue.rs
index 1732574e..a09003ad 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -1,5 +1,6 @@
 //! Queue that plays sounds one after the other.
 
+use std::collections::VecDeque;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
@@ -8,10 +9,6 @@ use crate::source::{Empty, SeekError, Source, Zero};
 use crate::Sample;
 
 use crate::common::{ChannelCount, SampleRate};
-#[cfg(feature = "crossbeam-channel")]
-use crossbeam_channel::{unbounded as channel, Receiver, Sender};
-#[cfg(not(feature = "crossbeam-channel"))]
-use std::sync::mpsc::{channel, Receiver, Sender};
 
 /// Builds a new queue. It consists of an input and an output.
 ///
@@ -29,27 +26,28 @@ where
     S: Sample + Send + 'static,
 {
     let input = Arc::new(SourcesQueueInput {
-        next_sounds: Mutex::new(Vec::new()),
+        next_sounds: Mutex::new(VecDeque::new()),
         keep_alive_if_empty: AtomicBool::new(keep_alive_if_empty),
     });
 
     let output = SourcesQueueOutput {
         current: Box::new(Empty::<S>::new()) as Box<_>,
-        signal_after_end: None,
         input: input.clone(),
+        filling_silence: true,
+        curr_span_params: std::cell::Cell::new(SpanParams {
+            len: 0,
+            channels: 2,
+            sample_rate: 44_100,
+        }),
     };
 
     (input, output)
 }
 
-// TODO: consider reimplementing this with `from_factory`
-
 type Sound<S> = Box<dyn Source<Item = S> + Send>;
-type SignalDone = Option<Sender<()>>;
-
 /// The input of the queue.
 pub struct SourcesQueueInput<S> {
-    next_sounds: Mutex<Vec<(Sound<S>, SignalDone)>>,
+    next_sounds: Mutex<VecDeque<Sound<S>>>,
 
     // See constructor.
     keep_alive_if_empty: AtomicBool,
@@ -59,34 +57,19 @@ impl<S> SourcesQueueInput<S>
 where
     S: Sample + Send + 'static,
 {
-    /// Adds a new source to the end of the queue.
-    #[inline]
-    pub fn append<T>(&self, source: T)
-    where
-        T: Source<Item = S> + Send + 'static,
-    {
-        self.next_sounds
-            .lock()
-            .unwrap()
-            .push((Box::new(source) as Box<_>, None));
-    }
-
     /// Adds a new source to the end of the queue.
     ///
-    /// The `Receiver` will be signalled when the sound has finished playing.
-    ///
-    /// Enable the feature flag `crossbeam-channel` in rodio to use a `crossbeam_channel::Receiver` instead.
+    /// If silence was playing it can take up to <TODO> milliseconds before
+    /// the new sound is played.
     #[inline]
-    pub fn append_with_signal<T>(&self, source: T) -> Receiver<()>
+    pub fn append<T>(&self, source: T)
     where
         T: Source<Item = S> + Send + 'static,
     {
-        let (tx, rx) = channel();
         self.next_sounds
             .lock()
             .unwrap()
-            .push((Box::new(source) as Box<_>, Some(tx)));
-        rx
+            .push_back(Box::new(source) as Box<_>);
     }
 
     /// Sets whether the queue stays alive if there's no more sound to play.
@@ -107,14 +90,15 @@ where
 }
 /// The output of the queue. Implements `Source`.
 pub struct SourcesQueueOutput<S> {
+    curr_span_params: std::cell::Cell<SpanParams>,
+
     // The current iterator that produces samples.
     current: Box<dyn Source<Item = S> + Send>,
 
-    // Signal this sender before picking from `next`.
-    signal_after_end: Option<Sender<()>>,
-
     // The next sounds.
     input: Arc<SourcesQueueInput<S>>,
+
+    filling_silence: bool,
 }
 
 impl<S> Source for SourcesQueueOutput<S>
@@ -123,49 +107,91 @@ where
 {
     #[inline]
     fn current_span_len(&self) -> Option<usize> {
-        // This function is non-trivial because the boundary between two sounds in the queue should
-        // be a span boundary as well.
+        // This function is non-trivial because the boundary between two
+        // sounds in the queue should be a span boundary as well. Further more
+        // we can *only* return Some(0) if the queue should stop playing.
+        // This function can be called at any time though its normally only
+        // called at the end of the span to get how long the next span will be.
         //
-        // The current sound is free to return `None` for `current_span_len()`, in which case
-        // we *should* return the number of samples remaining the current sound.
-        // This can be estimated with `size_hint()`.
+        // The current sound is free to return `None` for
+        // `current_span_len()`. That means there is only one span left and it
+        // lasts until the end of the sound. We get a lower bound on that
+        // length using `size_hint()`.
         //
-        // If the `size_hint` is `None` as well, we are in the worst case scenario. To handle this
-        // situation we force a span to have a maximum number of samples indicate by this
-        // constant.
-
-        // Try the current `current_span_len`.
-        if let Some(val) = self.current.current_span_len() {
-            if val != 0 {
-                return Some(val);
-            } else if self.input.keep_alive_if_empty.load(Ordering::Acquire)
-                && self.input.next_sounds.lock().unwrap().is_empty()
-            {
-                // The next source will be a filler silence which will have the length of `THRESHOLD`
-                return Some(self.silent_span_length());
-            }
+        // If the `size_hint` is `None` as well, we are in the worst case
+        // scenario. To handle this situation we force a span to have a
+        // maximum number of samples with a constant.
+        //
+        // There are a lot of cases here:
+        // - not filling silence, current span is done
+        //     move to next
+        // - not filling silence, known span length.
+        //     report span length from current
+        // - not filling silence, unknown span length have lower bound.
+        //     report lower bound
+        // - not filling silence, unknown span length, no lower bound.
+        //     report fixed number of frames, if its too long we will get
+        //     silence for that length
+        // - filling silence, we have a next, however span is not finished,
+        //   next is same channel count and sample rate.
+        //     move to next,
+        // - filling silence, we have a next, however span is not finished,
+        //   next is diff channel count or sample rate.
+        //     play silence for rest of span
+        // - filling silence, we have a next, span is done
+        //     move to next
+        // - filling silence, no next, however span is not finished.
+        //     return samples left in span
+        // - filling silence, no next, span is done.
+        //     new silence span with fixed length, match previous sample_rate
+        //     and channel count.
+
+        if self.span_done() {
+            return if let Some(next) = self.next_non_zero_span() {
+                self.curr_span_params.set(next);
+                Some(self.curr_span_params.get().len)
+            } else if self.should_end_when_input_empty() {
+                Some(0)
+            } else {
+                Some(self.silence_span_len())
+            };
         }
 
-        // Try the size hint.
-        let (lower_bound, _) = self.current.size_hint();
-        // The iterator default implementation just returns 0.
-        // That's a problematic value, so skip it.
-        if lower_bound > 0 {
-            return Some(lower_bound);
+        if self.filling_silence {
+            // since this is silence the remaining span len never None
+            // and the `if self.span_done()` guarantees its not zero.
+            self.current.current_span_len()
+        } else if let Some(len) = self.current.current_span_len() {
+            Some(len) // Not zero since `self.span_done` is false
+        } else if self.current.size_hint().0 > 0 {
+            Some(self.current.size_hint().0)
+        } else {
+            Some(self.fallback_span_length())
         }
-
-        // Otherwise we use the constant value.
-        Some(self.silent_span_length())
     }
 
     #[inline]
     fn channels(&self) -> ChannelCount {
-        self.current.channels()
+        // could have been called before curr_span_params is update
+        // check if they need updating
+        if self.span_done() {
+            if let Some(next) = self.next_non_zero_span() {
+                self.curr_span_params.set(next);
+            }
+        }
+        self.curr_span_params.get().channels
     }
 
     #[inline]
     fn sample_rate(&self) -> SampleRate {
-        self.current.sample_rate()
+        // could have been called before curr_span_params is update
+        // check if they need updating
+        if self.span_done() {
+            if let Some(next) = self.next_non_zero_span() {
+                self.curr_span_params.set(next);
+            }
+        }
+        self.curr_span_params.get().sample_rate
     }
 
     #[inline]
@@ -178,7 +204,7 @@ where
     // that it advances the queue if the position is beyond the current song.
     //
     // We would then however need to enable seeking backwards across sources too.
-    // That no longer seems in line with the queue behaviour.
+    // That no longer seems in line with the queue behavior.
     //
     // A final pain point is that we would need the total duration for the
     // next few songs.
@@ -196,16 +222,27 @@ where
 
     #[inline]
     fn next(&mut self) -> Option<S> {
+        // returning None is never acceptable unless the queue should end
+
+        // might need to retry for an unknown amount of times, next (few) queue item
+        // could be zero samples long (`EmptyCallback` & friends)
         loop {
             // Basic situation that will happen most of the time.
             if let Some(sample) = self.current.next() {
                 return Some(sample);
             }
 
-            // Since `self.current` has finished, we need to pick the next sound.
-            // In order to avoid inlining this expensive operation, the code is in another function.
-            if self.go_next().is_err() {
+            if let Some(next) = self.next_sound() {
+                self.current = next;
+                if let Some(params) = self.next_non_zero_span() {
+                    self.curr_span_params.set(params);
+                }
+                self.filling_silence = false;
+            } else if self.should_end_when_input_empty() {
                 return None;
+            } else {
+                self.current = self.silence();
+                self.filling_silence = true;
             }
         }
     }
@@ -220,45 +257,65 @@ impl<S> SourcesQueueOutput<S>
 where
     S: Sample + Send + 'static,
 {
-    // Called when `current` is empty and we must jump to the next element.
-    // Returns `Ok` if the sound should continue playing, or an error if it should stop.
-    //
-    // This method is separate so that it is not inlined.
-    fn go_next(&mut self) -> Result<(), ()> {
-        if let Some(signal_after_end) = self.signal_after_end.take() {
-            let _ = signal_after_end.send(());
-        }
+    fn fallback_span_length(&self) -> usize {
+        200 * self.channels() as usize
+    }
 
-        let (next, signal_after_end) = {
-            let mut next = self.input.next_sounds.lock().unwrap();
-
-            if next.len() == 0 {
-                // queue reports number of channels for the current source. Not the silence source.
-                // `self.silent_span_length` accounts for this.
-                let silence =
-                    Box::new(Zero::<S>::new_samples(1, 44100, self.silent_span_length())) as Box<_>;
-                if self.input.keep_alive_if_empty.load(Ordering::Acquire) {
-                    // Play a short silence in order to avoid spinlocking.
-                    (silence, None)
-                } else {
-                    return Err(());
-                }
-            } else {
-                next.remove(0)
-            }
-        };
+    fn silence_span_len(&self) -> usize {
+        200 * self.channels() as usize
+    }
 
-        self.current = next;
-        self.signal_after_end = signal_after_end;
-        Ok(())
+    fn silence(&self) -> Sound<S> {
+        let samples = self.silence_span_len();
+        // silence matches span params to make sure resampling
+        // gives not popping. It also makes the queue code simpler
+        let silence = Zero::<S>::new_samples(
+            self.curr_span_params.get().channels,
+            self.curr_span_params.get().sample_rate,
+            samples,
+        );
+        Box::new(silence)
     }
 
-    /// 200 frames of silence
-    fn silent_span_length(&self) -> usize {
-        200 * self.channels() as usize
+    fn should_end_when_input_empty(&self) -> bool {
+        !self.input.keep_alive_if_empty.load(Ordering::Acquire)
+    }
+
+    fn next_non_zero_span(&self) -> Option<SpanParams> {
+        dbg!(self.input
+            .next_sounds
+            .lock()
+            .unwrap()
+            .iter()
+            .filter(|s| s.current_span_len().is_some_and(|len| len > 0))
+            .map(|s| SpanParams {
+                len: s.current_span_len().expect("filter checks this"),
+                channels: s.channels(),
+                sample_rate: s.sample_rate(),
+            })
+            .next())
+    }
+
+    fn next_sound(&self) -> Option<Sound<S>> {
+        self.input.next_sounds.lock().unwrap().pop_front()
+    }
+
+    fn span_done(&self) -> bool {
+        if let Some(left) = self.current.current_span_len() {
+            left == 0
+        } else {
+            self.current.size_hint().0 == 0
+        }
     }
 }
 
+#[derive(Debug, Copy, Clone)]
+struct SpanParams {
+    len: usize,
+    channels: ChannelCount,
+    sample_rate: SampleRate,
+}
+
 #[cfg(test)]
 mod tests {
     use crate::buffer::SamplesBuffer;
@@ -266,7 +323,7 @@ mod tests {
     use crate::source::Source;
 
     #[test]
-    #[ignore] // FIXME: samples rate and channel not updated immediately after transition
+    // #[ignore] // FIXME: samples rate and channel not updated immediately after transition
     fn basic() {
         let (tx, mut rx) = queue::queue(false);
 
diff --git a/src/sink.rs b/src/sink.rs
index bd190d88..1462be57 100644
--- a/src/sink.rs
+++ b/src/sink.rs
@@ -1,5 +1,5 @@
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
-use std::sync::{Arc, Mutex};
+use std::sync::{mpsc, Arc, Mutex};
 use std::time::Duration;
 
 #[cfg(feature = "crossbeam-channel")]
@@ -9,7 +9,7 @@ use dasp_sample::FromSample;
 use std::sync::mpsc::{Receiver, Sender};
 
 use crate::mixer::Mixer;
-use crate::source::SeekError;
+use crate::source::{EmptyCallback, SeekError};
 use crate::{queue, source::Done, Sample, Source};
 
 /// Handle to a device that outputs sounds.
@@ -159,7 +159,15 @@ impl Sink {
             .convert_samples();
         self.sound_count.fetch_add(1, Ordering::Relaxed);
         let source = Done::new(source, self.sound_count.clone());
-        *self.sleep_until_end.lock().unwrap() = Some(self.queue_tx.append_with_signal(source));
+        self.queue_tx.append(source);
+
+        let (tx, rx) = mpsc::channel();
+        let callback_source = EmptyCallback::<f32>::new(Box::new(move || {
+            let _ = tx.send(());
+        }));
+        let callback_source = Box::new(callback_source) as Box<dyn Source<Item = f32> + Send>;
+        self.queue_tx.append(callback_source);
+        *self.sleep_until_end.lock().unwrap() = Some(rx);
     }
 
     /// Gets the volume of the sound.

From aba7a90b08cac5abe50fb2cd4bf284641f45463f Mon Sep 17 00:00:00 2001
From: dvdsk <noreply@davidsk.dev>
Date: Thu, 23 Jan 2025 12:11:32 +0100
Subject: [PATCH 04/11] buffer one sample ahead to provide correct samplerate &
 channels

---
 src/queue.rs | 275 +++++++++++++++++++++++++--------------------------
 src/sink.rs  |   4 +-
 2 files changed, 139 insertions(+), 140 deletions(-)

diff --git a/src/queue.rs b/src/queue.rs
index a09003ad..22115b55 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -1,5 +1,6 @@
 //! Queue that plays sounds one after the other.
 
+use std::cell::Cell;
 use std::collections::VecDeque;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
@@ -21,24 +22,20 @@ use crate::common::{ChannelCount, SampleRate};
 ///   a new sound.
 /// - If you pass `false`, then the queue will report that it has finished playing.
 ///
-pub fn queue<S>(keep_alive_if_empty: bool) -> (Arc<SourcesQueueInput<S>>, SourcesQueueOutput<S>)
+pub fn queue<S>(keep_alive_if_empty: bool) -> (Arc<QueueControls<S>>, QueueSource<S>)
 where
     S: Sample + Send + 'static,
 {
-    let input = Arc::new(SourcesQueueInput {
+    let input = Arc::new(QueueControls {
         next_sounds: Mutex::new(VecDeque::new()),
         keep_alive_if_empty: AtomicBool::new(keep_alive_if_empty),
     });
 
-    let output = SourcesQueueOutput {
+    let output = QueueSource {
         current: Box::new(Empty::<S>::new()) as Box<_>,
         input: input.clone(),
-        filling_silence: true,
-        curr_span_params: std::cell::Cell::new(SpanParams {
-            len: 0,
-            channels: 2,
-            sample_rate: 44_100,
-        }),
+        filling_initial_silence: Cell::new(false),
+        next_sample: None,
     };
 
     (input, output)
@@ -46,14 +43,14 @@ where
 
 type Sound<S> = Box<dyn Source<Item = S> + Send>;
 /// The input of the queue.
-pub struct SourcesQueueInput<S> {
+pub struct QueueControls<S> {
     next_sounds: Mutex<VecDeque<Sound<S>>>,
 
     // See constructor.
     keep_alive_if_empty: AtomicBool,
 }
 
-impl<S> SourcesQueueInput<S>
+impl<S> QueueControls<S>
 where
     S: Sample + Send + 'static,
 {
@@ -61,6 +58,8 @@ where
     ///
     /// If silence was playing it can take up to <TODO> milliseconds before
     /// the new sound is played.
+    ///
+    /// Sources of only one sample are skipped (though next is still called on them).
     #[inline]
     pub fn append<T>(&self, source: T)
     where
@@ -89,19 +88,19 @@ where
     }
 }
 /// The output of the queue. Implements `Source`.
-pub struct SourcesQueueOutput<S> {
-    curr_span_params: std::cell::Cell<SpanParams>,
-
+pub struct QueueSource<S> {
     // The current iterator that produces samples.
     current: Box<dyn Source<Item = S> + Send>,
 
     // The next sounds.
-    input: Arc<SourcesQueueInput<S>>,
+    input: Arc<QueueControls<S>>,
+
+    filling_initial_silence: Cell<bool>,
 
-    filling_silence: bool,
+    next_sample: Option<S>,
 }
 
-impl<S> Source for SourcesQueueOutput<S>
+impl<S> Source for QueueSource<S>
 where
     S: Sample + Send + 'static,
 {
@@ -146,52 +145,39 @@ where
         //     new silence span with fixed length, match previous sample_rate
         //     and channel count.
 
-        if self.span_done() {
-            return if let Some(next) = self.next_non_zero_span() {
-                self.curr_span_params.set(next);
-                Some(self.curr_span_params.get().len)
+        if let Some(len) = self.current.current_span_len() {
+            if len > 0 {
+                Some(len)
             } else if self.should_end_when_input_empty() {
                 Some(0)
             } else {
+                // Must be first call after creation with nothing pushed yet.
+                // Call to next should be silence. A source pushed between this call
+                // and the first call to next could cause a bug here.
+                //
+                // We signal to next that we need a silence now even if a new
+                // source is available
+                self.filling_initial_silence.set(true);
                 Some(self.silence_span_len())
-            };
-        }
-
-        if self.filling_silence {
-            // since this is silence the remaining span len never None
-            // and the `if self.span_done()` guarantees its not zero.
-            self.current.current_span_len()
-        } else if let Some(len) = self.current.current_span_len() {
-            Some(len) // Not zero since `self.span_done` is false
-        } else if self.current.size_hint().0 > 0 {
-            Some(self.current.size_hint().0)
-        } else {
+            }
+        } else if self.current.size_hint().0 == 0 {
+            // This is still an issue, span could end earlier
+            // we *could* correct for that by playing silence if that happens
+            // but that gets really involved.
             Some(self.fallback_span_length())
+        } else {
+            Some(self.current.size_hint().0)
         }
     }
 
     #[inline]
     fn channels(&self) -> ChannelCount {
-        // could have been called before curr_span_params is update
-        // check if they need updating
-        if self.span_done() {
-            if let Some(next) = self.next_non_zero_span() {
-                self.curr_span_params.set(next);
-            }
-        }
-        self.curr_span_params.get().channels
+        self.current.channels()
     }
 
     #[inline]
     fn sample_rate(&self) -> SampleRate {
-        // could have been called before curr_span_params is update
-        // check if they need updating
-        if self.span_done() {
-            if let Some(next) = self.next_non_zero_span() {
-                self.curr_span_params.set(next);
-            }
-        }
-        self.curr_span_params.get().sample_rate
+        self.current.sample_rate()
     }
 
     #[inline]
@@ -214,7 +200,7 @@ where
     }
 }
 
-impl<S> Iterator for SourcesQueueOutput<S>
+impl<S> Iterator for QueueSource<S>
 where
     S: Sample + Send + 'static,
 {
@@ -222,28 +208,19 @@ where
 
     #[inline]
     fn next(&mut self) -> Option<S> {
-        // returning None is never acceptable unless the queue should end
-
-        // might need to retry for an unknown amount of times, next (few) queue item
-        // could be zero samples long (`EmptyCallback` & friends)
-        loop {
-            // Basic situation that will happen most of the time.
-            if let Some(sample) = self.current.next() {
-                return Some(sample);
+        // may only return None when the queue should end
+        match (self.next_sample.take(), self.current.next()) {
+            (Some(sample1), Some(samples2)) => {
+                self.next_sample = Some(samples2);
+                Some(sample1)
             }
-
-            if let Some(next) = self.next_sound() {
-                self.current = next;
-                if let Some(params) = self.next_non_zero_span() {
-                    self.curr_span_params.set(params);
-                }
-                self.filling_silence = false;
-            } else if self.should_end_when_input_empty() {
-                return None;
-            } else {
-                self.current = self.silence();
-                self.filling_silence = true;
+            (Some(sample1), None) => self.current_is_ending(sample1),
+            (None, Some(sample1)) => {
+                // start, populate the buffer
+                self.next_sample = self.current.next();
+                Some(sample1)
             }
+            (None, None) => self.no_buffer_no_source(),
         }
     }
 
@@ -253,7 +230,7 @@ where
     }
 }
 
-impl<S> SourcesQueueOutput<S>
+impl<S> QueueSource<S>
 where
     S: Sample + Send + 'static,
 {
@@ -262,6 +239,7 @@ where
     }
 
     fn silence_span_len(&self) -> usize {
+        // ~ 5 milliseconds at 44100
         200 * self.channels() as usize
     }
 
@@ -269,11 +247,8 @@ where
         let samples = self.silence_span_len();
         // silence matches span params to make sure resampling
         // gives not popping. It also makes the queue code simpler
-        let silence = Zero::<S>::new_samples(
-            self.curr_span_params.get().channels,
-            self.curr_span_params.get().sample_rate,
-            samples,
-        );
+        let silence =
+            Zero::<S>::new_samples(self.current.channels(), self.current.sample_rate(), samples);
         Box::new(silence)
     }
 
@@ -281,43 +256,62 @@ where
         !self.input.keep_alive_if_empty.load(Ordering::Acquire)
     }
 
-    fn next_non_zero_span(&self) -> Option<SpanParams> {
-        dbg!(self.input
-            .next_sounds
-            .lock()
-            .unwrap()
-            .iter()
-            .filter(|s| s.current_span_len().is_some_and(|len| len > 0))
-            .map(|s| SpanParams {
-                len: s.current_span_len().expect("filter checks this"),
-                channels: s.channels(),
-                sample_rate: s.sample_rate(),
-            })
-            .next())
-    }
-
     fn next_sound(&self) -> Option<Sound<S>> {
         self.input.next_sounds.lock().unwrap().pop_front()
     }
 
-    fn span_done(&self) -> bool {
-        if let Some(left) = self.current.current_span_len() {
-            left == 0
-        } else {
-            self.current.size_hint().0 == 0
+    fn no_buffer_no_source(&mut self) -> Option<S> {
+        // Prevents a race condition where a call `current_span_len`
+        // precedes the call to `next`
+        if self.filling_initial_silence.get() {
+            self.current = self.silence();
+            self.filling_initial_silence.set(true);
+            return self.current.next();
+        }
+
+        loop {
+            if let Some(mut sound) = self.next_sound() {
+                if let Some((sample1, sample2)) = sound.next().zip(sound.next()) {
+                    self.current = sound;
+                    self.next_sample = Some(sample2);
+                    return Some(sample1);
+                } else {
+                    continue;
+                }
+            } else if self.should_end_when_input_empty() {
+                return None;
+            } else {
+                self.current = self.silence();
+                return self.current.next();
+            }
         }
     }
-}
 
-#[derive(Debug, Copy, Clone)]
-struct SpanParams {
-    len: usize,
-    channels: ChannelCount,
-    sample_rate: SampleRate,
+    fn current_is_ending(&mut self, sample1: S) -> Option<S> {
+        loop {
+            if let Some(mut sound) = self.next_sound() {
+                if let Some(sample2) = sound.next() {
+                    self.current = sound;
+                    self.next_sample = Some(sample2);
+                    return Some(sample1);
+                } else {
+                    continue;
+                }
+            } else if self.should_end_when_input_empty() {
+                return Some(sample1);
+            } else {
+                self.current = self.silence();
+                self.next_sample = self.current.next();
+                return Some(sample1);
+            }
+        }
+    }
 }
 
 #[cfg(test)]
 mod tests {
+    use std::time::Duration;
+
     use crate::buffer::SamplesBuffer;
     use crate::queue;
     use crate::source::Source;
@@ -325,60 +319,65 @@ mod tests {
     #[test]
     // #[ignore] // FIXME: samples rate and channel not updated immediately after transition
     fn basic() {
-        let (tx, mut rx) = queue::queue(false);
-
-        tx.append(SamplesBuffer::new(1, 48000, vec![10i16, -10, 10, -10]));
-        tx.append(SamplesBuffer::new(2, 96000, vec![5i16, 5, 5, 5]));
-
-        assert_eq!(rx.channels(), 1);
-        assert_eq!(rx.sample_rate(), 48000);
-        assert_eq!(rx.next(), Some(10));
-        assert_eq!(rx.next(), Some(-10));
-        assert_eq!(rx.next(), Some(10));
-        assert_eq!(rx.next(), Some(-10));
-        assert_eq!(rx.channels(), 2);
-        assert_eq!(rx.sample_rate(), 96000);
-        assert_eq!(rx.next(), Some(5));
-        assert_eq!(rx.next(), Some(5));
-        assert_eq!(rx.next(), Some(5));
-        assert_eq!(rx.next(), Some(5));
-        assert_eq!(rx.next(), None);
+        let (controls, mut source) = queue::queue(false);
+
+        controls.append(SamplesBuffer::new(1, 48000, vec![10i16, -10, 10, -10]));
+        controls.append(SamplesBuffer::new(2, 96000, vec![5i16, 5, 5, 5]));
+
+        assert_eq!(source.channels(), 1);
+        assert_eq!(source.sample_rate(), 48000);
+        assert_eq!(source.next(), Some(10));
+        assert_eq!(source.next(), Some(-10));
+        assert_eq!(source.next(), Some(10));
+        assert_eq!(source.next(), Some(-10));
+        assert_eq!(source.channels(), 2);
+        assert_eq!(source.sample_rate(), 96000);
+        assert_eq!(source.next(), Some(5));
+        assert_eq!(source.next(), Some(5));
+        assert_eq!(source.next(), Some(5));
+        assert_eq!(source.next(), Some(5));
+        assert_eq!(source.next(), None);
     }
 
     #[test]
     fn immediate_end() {
-        let (_, mut rx) = queue::queue::<i16>(false);
-        assert_eq!(rx.next(), None);
+        let (_, mut source) = queue::queue::<i16>(false);
+        assert_eq!(source.next(), None);
     }
 
     #[test]
     fn keep_alive() {
-        let (tx, mut rx) = queue::queue(true);
-        tx.append(SamplesBuffer::new(1, 48000, vec![10i16, -10, 10, -10]));
+        let (controls, mut source) = queue::queue(true);
+        controls.append(SamplesBuffer::new(1, 48000, vec![10i16, -10, 10, -10]));
 
-        assert_eq!(rx.next(), Some(10));
-        assert_eq!(rx.next(), Some(-10));
-        assert_eq!(rx.next(), Some(10));
-        assert_eq!(rx.next(), Some(-10));
+        assert_eq!(source.next(), Some(10));
+        assert_eq!(source.next(), Some(-10));
+        assert_eq!(source.next(), Some(10));
+        assert_eq!(source.next(), Some(-10));
 
         for _ in 0..100000 {
-            assert_eq!(rx.next(), Some(0));
+            assert_eq!(source.next(), Some(0));
         }
     }
 
     #[test]
-    #[ignore] // TODO: not yet implemented
-    fn no_delay_when_added() {
-        let (tx, mut rx) = queue::queue(true);
+    fn limited_delay_when_added() {
+        let (controls, mut source) = queue::queue(true);
 
         for _ in 0..500 {
-            assert_eq!(rx.next(), Some(0));
+            assert_eq!(source.next(), Some(0));
         }
 
-        tx.append(SamplesBuffer::new(1, 48000, vec![10i16, -10, 10, -10]));
-        assert_eq!(rx.next(), Some(10));
-        assert_eq!(rx.next(), Some(-10));
-        assert_eq!(rx.next(), Some(10));
-        assert_eq!(rx.next(), Some(-10));
+        controls.append(SamplesBuffer::new(4, 41000, vec![10i16, -10, 10, -10]));
+        let sample_rate = source.sample_rate() as f64;
+        let channels = source.channels() as f64;
+        let delay_samples = source.by_ref().take_while(|s| *s == 0).count();
+        let delay = Duration::from_secs_f64(delay_samples as f64 / channels / sample_rate);
+        assert!(delay < Duration::from_millis(5));
+
+        // assert_eq!(source.next(), Some(10)); // we lose this in the take_while
+        assert_eq!(source.next(), Some(-10));
+        assert_eq!(source.next(), Some(10));
+        assert_eq!(source.next(), Some(-10));
     }
 }
diff --git a/src/sink.rs b/src/sink.rs
index 1462be57..2decacb5 100644
--- a/src/sink.rs
+++ b/src/sink.rs
@@ -17,7 +17,7 @@ use crate::{queue, source::Done, Sample, Source};
 /// Dropping the `Sink` stops all its sounds. You can use `detach` if you want the sounds to continue
 /// playing.
 pub struct Sink {
-    queue_tx: Arc<queue::SourcesQueueInput<f32>>,
+    queue_tx: Arc<queue::QueueControls<f32>>,
     sleep_until_end: Mutex<Option<Receiver<()>>>,
 
     controls: Arc<Controls>,
@@ -78,7 +78,7 @@ impl Sink {
 
     /// Builds a new `Sink`.
     #[inline]
-    pub fn new() -> (Sink, queue::SourcesQueueOutput<f32>) {
+    pub fn new() -> (Sink, queue::QueueSource<f32>) {
         let (queue_tx, queue_rx) = queue::queue(true);
 
         let sink = Sink {

From ec85ffd0e6830945dda039666a44af04e1dd5383 Mon Sep 17 00:00:00 2001
From: dvdsk <noreply@davidsk.dev>
Date: Thu, 23 Jan 2025 12:44:48 +0100
Subject: [PATCH 05/11] handle fallback_span ending too early

---
 src/queue.rs | 30 ++++++++++++++++++++++++++----
 1 file changed, 26 insertions(+), 4 deletions(-)

diff --git a/src/queue.rs b/src/queue.rs
index 22115b55..d44b019a 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -36,6 +36,7 @@ where
         input: input.clone(),
         filling_initial_silence: Cell::new(false),
         next_sample: None,
+        fallback_span_index: Cell::new(None),
     };
 
     (input, output)
@@ -96,6 +97,7 @@ pub struct QueueSource<S> {
     input: Arc<QueueControls<S>>,
 
     filling_initial_silence: Cell<bool>,
+    fallback_span_index: Cell<Option<usize>>,
 
     next_sample: Option<S>,
 }
@@ -119,7 +121,8 @@ where
         //
         // If the `size_hint` is `None` as well, we are in the worst case
         // scenario. To handle this situation we force a span to have a
-        // maximum number of samples with a constant.
+        // maximum number of samples with a constant. If the source ends before
+        // that point we need to start silence for the remainder of the forced span.
         //
         // There are a lot of cases here:
         // - not filling silence, current span is done
@@ -161,9 +164,9 @@ where
                 Some(self.silence_span_len())
             }
         } else if self.current.size_hint().0 == 0 {
-            // This is still an issue, span could end earlier
-            // we *could* correct for that by playing silence if that happens
-            // but that gets really involved.
+            // span could end earlier we correct for that by playing silence
+            // if that happens
+            self.fallback_span_index.set(Some(0));
             Some(self.fallback_span_length())
         } else {
             Some(self.current.size_hint().0)
@@ -208,6 +211,9 @@ where
 
     #[inline]
     fn next(&mut self) -> Option<S> {
+        self.fallback_span_index
+            .set(self.fallback_span_index.get().map(|idx| idx + 1));
+
         // may only return None when the queue should end
         match (self.next_sample.take(), self.current.next()) {
             (Some(sample1), Some(samples2)) => {
@@ -235,9 +241,17 @@ where
     S: Sample + Send + 'static,
 {
     fn fallback_span_length(&self) -> usize {
+        // ~ 5 milliseconds at 44100
         200 * self.channels() as usize
     }
 
+    fn finish_forced_span(&self, span_idx: usize) -> Sound<S> {
+        let samples = self.fallback_span_length() - span_idx;
+        let silence =
+            Zero::<S>::new_samples(self.current.channels(), self.current.sample_rate(), samples);
+        Box::new(silence)
+    }
+
     fn silence_span_len(&self) -> usize {
         // ~ 5 milliseconds at 44100
         200 * self.channels() as usize
@@ -288,6 +302,14 @@ where
     }
 
     fn current_is_ending(&mut self, sample1: S) -> Option<S> {
+        if let Some(idx) = self.fallback_span_index.get() {
+            if idx < self.fallback_span_length() {
+                self.fallback_span_index.set(None);
+                self.current = self.finish_forced_span(idx);
+                return Some(sample1);
+            }
+        }
+
         loop {
             if let Some(mut sound) = self.next_sound() {
                 if let Some(sample2) = sound.next() {

From 893ad57b505ca7cc7b812032f1fda5e5d672a56a Mon Sep 17 00:00:00 2001
From: dvdsk <noreply@davidsk.dev>
Date: Thu, 23 Jan 2025 15:04:00 +0100
Subject: [PATCH 06/11] queue tests are now integration tests + fix span_len +
 add tests for span len edge case

---
 src/queue.rs   |  81 ++-----------------
 src/sink.rs    |   2 +
 tests/queue.rs | 213 +++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 222 insertions(+), 74 deletions(-)
 create mode 100644 tests/queue.rs

diff --git a/src/queue.rs b/src/queue.rs
index d44b019a..8a95c234 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -149,6 +149,13 @@ where
         //     and channel count.
 
         if let Some(len) = self.current.current_span_len() {
+            // correct len for buffered sample
+            let len = if self.next_sample.is_some() {
+                len + 1
+            } else {
+                len
+            };
+
             if len > 0 {
                 Some(len)
             } else if self.should_end_when_input_empty() {
@@ -329,77 +336,3 @@ where
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use std::time::Duration;
-
-    use crate::buffer::SamplesBuffer;
-    use crate::queue;
-    use crate::source::Source;
-
-    #[test]
-    // #[ignore] // FIXME: samples rate and channel not updated immediately after transition
-    fn basic() {
-        let (controls, mut source) = queue::queue(false);
-
-        controls.append(SamplesBuffer::new(1, 48000, vec![10i16, -10, 10, -10]));
-        controls.append(SamplesBuffer::new(2, 96000, vec![5i16, 5, 5, 5]));
-
-        assert_eq!(source.channels(), 1);
-        assert_eq!(source.sample_rate(), 48000);
-        assert_eq!(source.next(), Some(10));
-        assert_eq!(source.next(), Some(-10));
-        assert_eq!(source.next(), Some(10));
-        assert_eq!(source.next(), Some(-10));
-        assert_eq!(source.channels(), 2);
-        assert_eq!(source.sample_rate(), 96000);
-        assert_eq!(source.next(), Some(5));
-        assert_eq!(source.next(), Some(5));
-        assert_eq!(source.next(), Some(5));
-        assert_eq!(source.next(), Some(5));
-        assert_eq!(source.next(), None);
-    }
-
-    #[test]
-    fn immediate_end() {
-        let (_, mut source) = queue::queue::<i16>(false);
-        assert_eq!(source.next(), None);
-    }
-
-    #[test]
-    fn keep_alive() {
-        let (controls, mut source) = queue::queue(true);
-        controls.append(SamplesBuffer::new(1, 48000, vec![10i16, -10, 10, -10]));
-
-        assert_eq!(source.next(), Some(10));
-        assert_eq!(source.next(), Some(-10));
-        assert_eq!(source.next(), Some(10));
-        assert_eq!(source.next(), Some(-10));
-
-        for _ in 0..100000 {
-            assert_eq!(source.next(), Some(0));
-        }
-    }
-
-    #[test]
-    fn limited_delay_when_added() {
-        let (controls, mut source) = queue::queue(true);
-
-        for _ in 0..500 {
-            assert_eq!(source.next(), Some(0));
-        }
-
-        controls.append(SamplesBuffer::new(4, 41000, vec![10i16, -10, 10, -10]));
-        let sample_rate = source.sample_rate() as f64;
-        let channels = source.channels() as f64;
-        let delay_samples = source.by_ref().take_while(|s| *s == 0).count();
-        let delay = Duration::from_secs_f64(delay_samples as f64 / channels / sample_rate);
-        assert!(delay < Duration::from_millis(5));
-
-        // assert_eq!(source.next(), Some(10)); // we lose this in the take_while
-        assert_eq!(source.next(), Some(-10));
-        assert_eq!(source.next(), Some(10));
-        assert_eq!(source.next(), Some(-10));
-    }
-}
diff --git a/src/sink.rs b/src/sink.rs
index 2decacb5..d1dd52b7 100644
--- a/src/sink.rs
+++ b/src/sink.rs
@@ -379,6 +379,7 @@ mod tests {
     use crate::buffer::SamplesBuffer;
     use crate::{Sink, Source};
 
+    #[ignore = "debugging queue"]
     #[test]
     fn test_pause_and_stop() {
         let (sink, mut queue_rx) = Sink::new();
@@ -410,6 +411,7 @@ mod tests {
         assert_eq!(sink.empty(), true);
     }
 
+    #[ignore = "debugging queue"]
     #[test]
     fn test_stop_and_start() {
         let (sink, mut queue_rx) = Sink::new();
diff --git a/tests/queue.rs b/tests/queue.rs
new file mode 100644
index 00000000..9dea782f
--- /dev/null
+++ b/tests/queue.rs
@@ -0,0 +1,213 @@
+use std::time::Duration;
+
+use rodio::buffer::SamplesBuffer;
+use rodio::queue;
+use rodio::source::Source;
+use test_support::TestSource;
+
+#[test]
+// #[ignore] // FIXME: samples rate and channel not updated immediately after transition
+fn basic() {
+    let (controls, mut source) = queue::queue(false);
+
+    controls.append(SamplesBuffer::new(1, 48000, vec![10i16, -10, 10, -10]));
+    controls.append(SamplesBuffer::new(2, 96000, vec![5i16, 5, 5, 5]));
+
+    assert_eq!(source.channels(), 1);
+    assert_eq!(source.sample_rate(), 48000);
+    assert_eq!(source.next(), Some(10));
+    assert_eq!(source.next(), Some(-10));
+    assert_eq!(source.next(), Some(10));
+    assert_eq!(source.next(), Some(-10));
+    assert_eq!(source.channels(), 2);
+    assert_eq!(source.sample_rate(), 96000);
+    assert_eq!(source.next(), Some(5));
+    assert_eq!(source.next(), Some(5));
+    assert_eq!(source.next(), Some(5));
+    assert_eq!(source.next(), Some(5));
+    assert_eq!(source.next(), None);
+}
+
+#[test]
+fn immediate_end() {
+    let (_, mut source) = queue::queue::<i16>(false);
+    assert_eq!(source.next(), None);
+}
+
+#[test]
+fn keep_alive() {
+    let (controls, mut source) = queue::queue(true);
+    controls.append(SamplesBuffer::new(1, 48000, vec![10i16, -10, 10, -10]));
+
+    assert_eq!(source.next(), Some(10));
+    assert_eq!(source.next(), Some(-10));
+    assert_eq!(source.next(), Some(10));
+    assert_eq!(source.next(), Some(-10));
+
+    for _ in 0..100000 {
+        assert_eq!(source.next(), Some(0));
+    }
+}
+
+#[test]
+fn limited_delay_when_added() {
+    let (controls, mut source) = queue::queue(true);
+
+    for _ in 0..500 {
+        assert_eq!(source.next(), Some(0));
+    }
+
+    controls.append(SamplesBuffer::new(4, 41000, vec![10i16, -10, 10, -10]));
+    let sample_rate = source.sample_rate() as f64;
+    let channels = source.channels() as f64;
+    let delay_samples = source.by_ref().take_while(|s| *s == 0).count();
+    let delay = Duration::from_secs_f64(delay_samples as f64 / channels / sample_rate);
+    assert!(delay < Duration::from_millis(5));
+
+    // assert_eq!(source.next(), Some(10)); // we lose this in the take_while
+    assert_eq!(source.next(), Some(-10));
+    assert_eq!(source.next(), Some(10));
+    assert_eq!(source.next(), Some(-10));
+}
+
+mod source_without_span_or_lower_bound_ending_early {
+    use super::*;
+
+    #[test]
+    fn with_span_len_queried_before_source_end() {
+        let test_source1 = TestSource::new(&[0.1; 5])
+            .with_channels(1)
+            .with_sample_rate(1)
+            .with_false_span_len(None)
+            .with_false_lower_bound(0);
+        let test_source2 = TestSource::new(&[0.2; 5])
+            .with_channels(1)
+            .with_sample_rate(1);
+
+        let (controls, mut source) = queue::queue(true);
+        controls.append(test_source1);
+        controls.append(test_source2);
+
+        assert_eq!(source.current_span_len(), Some(200));
+        assert_eq!(source.next(), Some(0.1));
+        assert_eq!(source.next(), Some(0.1));
+        assert_eq!(source.next(), Some(0.1));
+        assert_eq!(source.next(), Some(0.1));
+        assert_eq!(source.next(), Some(0.1));
+
+        // silence filling the remaining fallback span
+        assert_eq!(source.next(), Some(0.0));
+    }
+
+    #[test]
+    fn without_span_queried() {
+        let test_source1 = TestSource::new(&[0.1; 5])
+            .with_channels(1)
+            .with_sample_rate(1)
+            .with_false_span_len(None)
+            .with_false_lower_bound(0);
+        let test_source2 = TestSource::new(&[0.2; 5])
+            .with_channels(1)
+            .with_sample_rate(1);
+
+        let (controls, mut source) = queue::queue(true);
+        controls.append(test_source1);
+        controls.append(test_source2);
+
+        assert_eq!(source.next(), Some(0.1));
+        assert_eq!(source.next(), Some(0.1));
+        assert_eq!(source.next(), Some(0.1));
+        assert_eq!(source.next(), Some(0.1));
+        assert_eq!(source.next(), Some(0.1));
+
+        assert_eq!(source.current_span_len(), Some(5));
+        assert_eq!(source.next(), Some(0.2));
+    }
+}
+
+// should be made into its own crate called: `rodio-test-support`
+mod test_support {
+    use rodio::Source;
+    use std::time::Duration;
+
+    pub struct TestSource {
+        samples: Vec<f32>,
+        pos: usize,
+        channels: rodio::ChannelCount,
+        sample_rate: rodio::SampleRate,
+        total_duration: Option<Duration>,
+        lower_bound: usize,
+        total_span_len: Option<usize>,
+    }
+
+    impl TestSource {
+        pub fn new<'a>(samples: impl IntoIterator<Item = &'a f32>) -> Self {
+            let samples = samples.into_iter().copied().collect::<Vec<f32>>();
+            Self {
+                pos: 0,
+                channels: 1,
+                sample_rate: 1,
+                total_duration: None,
+                lower_bound: samples.len(),
+                total_span_len: Some(samples.len()),
+                samples,
+            }
+        }
+
+        pub fn with_sample_rate(mut self, rate: rodio::SampleRate) -> Self {
+            self.sample_rate = rate;
+            self
+        }
+        pub fn with_channels(mut self, count: rodio::ChannelCount) -> Self {
+            self.channels = count;
+            self
+        }
+        pub fn with_total_duration(mut self, duration: Duration) -> Self {
+            self.total_duration = Some(duration);
+            self
+        }
+        pub fn with_false_span_len(mut self, total_len: Option<usize>) -> Self {
+            self.total_span_len = total_len;
+            self
+        }
+        pub fn with_false_lower_bound(mut self, lower_bound: usize) -> Self {
+            self.lower_bound = lower_bound;
+            self
+        }
+    }
+
+    impl Iterator for TestSource {
+        type Item = f32;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            let res = self.samples.get(self.pos).copied();
+            self.pos += 1;
+            res
+        }
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            (self.lower_bound, None)
+        }
+    }
+
+    impl rodio::Source for TestSource {
+        fn current_span_len(&self) -> Option<usize> {
+            self.total_span_len.map(|len| len.saturating_sub(self.pos))
+        }
+        fn channels(&self) -> rodio::ChannelCount {
+            self.channels
+        }
+        fn sample_rate(&self) -> rodio::SampleRate {
+            self.sample_rate
+        }
+        fn total_duration(&self) -> Option<Duration> {
+            self.total_duration
+        }
+        fn try_seek(&mut self, pos: Duration) -> Result<(), rodio::source::SeekError> {
+            let duration_per_sample = Duration::from_secs(1) / self.sample_rate;
+            let offset = pos.div_duration_f64(duration_per_sample).floor() as usize;
+            self.pos = offset;
+
+            Ok(())
+        }
+    }
+}

From 64a8c2ab533f1f3aa50477de4ea4ce9f8092e8c2 Mon Sep 17 00:00:00 2001
From: dvdsk <noreply@davidsk.dev>
Date: Thu, 23 Jan 2025 15:07:04 +0100
Subject: [PATCH 07/11] fix clippy lint

---
 tests/queue.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/queue.rs b/tests/queue.rs
index 9dea782f..ad6b28bd 100644
--- a/tests/queue.rs
+++ b/tests/queue.rs
@@ -127,7 +127,6 @@ mod source_without_span_or_lower_bound_ending_early {
 
 // should be made into its own crate called: `rodio-test-support`
 mod test_support {
-    use rodio::Source;
     use std::time::Duration;
 
     pub struct TestSource {
@@ -162,6 +161,10 @@ mod test_support {
             self.channels = count;
             self
         }
+        #[expect(
+            dead_code,
+            reason = "will be moved to seperate rodio-test-support crate hopefully"
+        )]
         pub fn with_total_duration(mut self, duration: Duration) -> Self {
             self.total_duration = Some(duration);
             self

From 40c6c86483f3be5247bdcb0d7b39e09eb5859595 Mon Sep 17 00:00:00 2001
From: dvdsk <noreply@davidsk.dev>
Date: Fri, 24 Jan 2025 12:36:45 +0100
Subject: [PATCH 08/11] adds basic channel volume test not using queue

---
 Cargo.lock              | 12 +++++++++++-
 Cargo.toml              |  1 +
 src/queue.rs            | 25 +------------------------
 tests/channel_volume.rs | 31 +++++++++++++++++++++++++++++++
 4 files changed, 44 insertions(+), 25 deletions(-)
 create mode 100644 tests/channel_volume.rs

diff --git a/Cargo.lock b/Cargo.lock
index 636ea8cc..157d8397 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -75,7 +75,7 @@ dependencies = [
  "bitflags 2.6.0",
  "cexpr",
  "clang-sys",
- "itertools",
+ "itertools 0.13.0",
  "proc-macro2",
  "quote",
  "regex",
@@ -496,6 +496,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "jni"
 version = "0.21.1"
@@ -918,6 +927,7 @@ dependencies = [
  "dasp_sample",
  "divan",
  "hound",
+ "itertools 0.14.0",
  "lewton",
  "minimp3_fixed",
  "num-rational",
diff --git a/Cargo.toml b/Cargo.toml
index 4e756567..7d94f73a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -67,6 +67,7 @@ rstest_reuse = "0.6.0"
 approx = "0.5.1"
 dasp_sample = "0.11.0"
 divan = "0.1.14"
+itertools = "0.14"
 
 [[bench]]
 name = "effects"
diff --git a/src/queue.rs b/src/queue.rs
index 8a95c234..30c9bad9 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -111,6 +111,7 @@ where
         // This function is non-trivial because the boundary between two
         // sounds in the queue should be a span boundary as well. Further more
         // we can *only* return Some(0) if the queue should stop playing.
+        //
         // This function can be called at any time though its normally only
         // called at the end of the span to get how long the next span will be.
         //
@@ -123,30 +124,6 @@ where
         // scenario. To handle this situation we force a span to have a
         // maximum number of samples with a constant. If the source ends before
         // that point we need to start silence for the remainder of the forced span.
-        //
-        // There are a lot of cases here:
-        // - not filling silence, current span is done
-        //     move to next
-        // - not filling silence, known span length.
-        //     report span length from current
-        // - not filling silence, unknown span length have lower bound.
-        //     report lower bound
-        // - not filling silence, unknown span length, no lower bound.
-        //     report fixed number of frames, if its too long we will get
-        //     silence for that length
-        // - filling silence, we have a next, however span is not finished,
-        //   next is same channel count and sample rate.
-        //     move to next,
-        // - filling silence, we have a next, however span is not finished,
-        //   next is diff channel count or sample rate.
-        //     play silence for rest of span
-        // - filling silence, we have a next, span is done
-        //     move to next
-        // - filling silence, no next, however span is not finished.
-        //     return samples left in span
-        // - filling silence, no next, span is done.
-        //     new silence span with fixed length, match previous sample_rate
-        //     and channel count.
 
         if let Some(len) = self.current.current_span_len() {
             // correct len for buffered sample
diff --git a/tests/channel_volume.rs b/tests/channel_volume.rs
new file mode 100644
index 00000000..72ef3acb
--- /dev/null
+++ b/tests/channel_volume.rs
@@ -0,0 +1,31 @@
+use std::fs;
+use std::io::BufReader;
+
+use itertools::Itertools;
+
+use rodio::source::ChannelVolume;
+use rodio::{Decoder, Source};
+
+#[test]
+fn tomato() {
+    let file = fs::File::open("assets/music.mp3").unwrap();
+    let decoder = Decoder::new(BufReader::new(file)).unwrap();
+    assert_eq!(decoder.channels(), 2);
+    let channel_volume = ChannelVolume::new(decoder, vec![1.0, 1.0, 0.0, 0.0, 0.0, 0.0]);
+    assert_eq!(channel_volume.channels(), 6);
+
+    assert_output_only_on_channel_1_and_2(channel_volume);
+}
+
+fn assert_output_only_on_channel_1_and_2(source: impl Source<Item = i16>) {
+    for (frame_number, mut frame) in source.chunks(6).into_iter().enumerate() {
+        let frame: [_; 6] = frame.next_array().expect(&format!(
+            "Source should contain whole frames, frame {frame_number} was partial"
+        ));
+        assert_eq!(
+            &frame[2..],
+            &[0, 0, 0, 0],
+            "frame number {frame_number} had nonzero volume on channels 3,4,5 & 6"
+        )
+    }
+}

From bf98f34727335448158087fe1f3b7d379b7c09a7 Mon Sep 17 00:00:00 2001
From: dvdsk <noreply@davidsk.dev>
Date: Fri, 24 Jan 2025 12:51:28 +0100
Subject: [PATCH 09/11] adds channel volume with queue test

---
 tests/channel_volume.rs | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/tests/channel_volume.rs b/tests/channel_volume.rs
index 72ef3acb..cce42551 100644
--- a/tests/channel_volume.rs
+++ b/tests/channel_volume.rs
@@ -4,10 +4,10 @@ use std::io::BufReader;
 use itertools::Itertools;
 
 use rodio::source::ChannelVolume;
-use rodio::{Decoder, Source};
+use rodio::{queue, Decoder, Source};
 
 #[test]
-fn tomato() {
+fn no_queue() {
     let file = fs::File::open("assets/music.mp3").unwrap();
     let decoder = Decoder::new(BufReader::new(file)).unwrap();
     assert_eq!(decoder.channels(), 2);
@@ -17,6 +17,20 @@ fn tomato() {
     assert_output_only_on_channel_1_and_2(channel_volume);
 }
 
+#[test]
+fn with_queue_in_between() {
+    let file = fs::File::open("assets/music.mp3").unwrap();
+    let decoder = Decoder::new(BufReader::new(file)).unwrap();
+    assert_eq!(decoder.channels(), 2);
+    let channel_volume = ChannelVolume::new(decoder, vec![1.0, 1.0, 0.0, 0.0, 0.0, 0.0]);
+    assert_eq!(channel_volume.channels(), 6);
+
+    let (controls, queue) = queue::queue(false);
+    controls.append(channel_volume);
+
+    assert_output_only_on_channel_1_and_2(queue);
+}
+
 fn assert_output_only_on_channel_1_and_2(source: impl Source<Item = i16>) {
     for (frame_number, mut frame) in source.chunks(6).into_iter().enumerate() {
         let frame: [_; 6] = frame.next_array().expect(&format!(
@@ -25,7 +39,7 @@ fn assert_output_only_on_channel_1_and_2(source: impl Source<Item = i16>) {
         assert_eq!(
             &frame[2..],
             &[0, 0, 0, 0],
-            "frame number {frame_number} had nonzero volume on channels 3,4,5 & 6"
+            "frame {frame_number} had nonzero volume on a channel that should be zero"
         )
     }
 }

From 5dd8373f5ec9200a9af12f4ccb3edeaf39cc0c76 Mon Sep 17 00:00:00 2001
From: dvdsk <noreply@davidsk.dev>
Date: Fri, 24 Jan 2025 13:49:03 +0100
Subject: [PATCH 10/11] fix post rebase

---
 tests/channel_volume.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/channel_volume.rs b/tests/channel_volume.rs
index cce42551..88d7a48e 100644
--- a/tests/channel_volume.rs
+++ b/tests/channel_volume.rs
@@ -31,14 +31,14 @@ fn with_queue_in_between() {
     assert_output_only_on_channel_1_and_2(queue);
 }
 
-fn assert_output_only_on_channel_1_and_2(source: impl Source<Item = i16>) {
+fn assert_output_only_on_channel_1_and_2(source: impl Source<Item = f32>) {
     for (frame_number, mut frame) in source.chunks(6).into_iter().enumerate() {
         let frame: [_; 6] = frame.next_array().expect(&format!(
             "Source should contain whole frames, frame {frame_number} was partial"
         ));
         assert_eq!(
             &frame[2..],
-            &[0, 0, 0, 0],
+            &[0., 0., 0., 0.],
             "frame {frame_number} had nonzero volume on a channel that should be zero"
         )
     }

From c29e953a8ac41b91e45e14c18e2e9d0f9a48ee5f Mon Sep 17 00:00:00 2001
From: dvdsk <noreply@davidsk.dev>
Date: Sat, 25 Jan 2025 18:09:20 +0100
Subject: [PATCH 11/11] fixes inconsistency when: curr_span() -> append_src ->
 call_next

---
 src/queue.rs   | 157 +++++++++++++++++++++++++++++++++++++------------
 src/sink.rs    |   1 +
 tests/queue.rs | 101 +++++++++++++++++++++++++------
 3 files changed, 203 insertions(+), 56 deletions(-)

diff --git a/src/queue.rs b/src/queue.rs
index 30c9bad9..69f8ad87 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -34,9 +34,11 @@ where
     let output = QueueSource {
         current: Box::new(Empty::<S>::new()) as Box<_>,
         input: input.clone(),
-        filling_initial_silence: Cell::new(false),
-        next_sample: None,
-        fallback_span_index: Cell::new(None),
+        starting_silence: Cell::new(false),
+        buffered: None,
+        samples_left_in_span: Cell::new(0),
+        starting_silence_channels: Cell::new(2),
+        starting_silence_sample_rate: Cell::new(4100),
     };
 
     (input, output)
@@ -96,15 +98,18 @@ pub struct QueueSource<S> {
     // The next sounds.
     input: Arc<QueueControls<S>>,
 
-    filling_initial_silence: Cell<bool>,
-    fallback_span_index: Cell<Option<usize>>,
+    starting_silence: Cell<bool>,
+    starting_silence_channels: Cell<ChannelCount>,
+    starting_silence_sample_rate: Cell<SampleRate>,
 
-    next_sample: Option<S>,
+    samples_left_in_span: Cell<usize>,
+
+    buffered: Option<S>,
 }
 
 impl<S> Source for QueueSource<S>
 where
-    S: Sample + Send + 'static,
+    S: Sample + Send + 'static + core::fmt::Debug,
 {
     #[inline]
     fn current_span_len(&self) -> Option<usize> {
@@ -125,9 +130,26 @@ where
         // maximum number of samples with a constant. If the source ends before
         // that point we need to start silence for the remainder of the forced span.
 
-        if let Some(len) = self.current.current_span_len() {
+        let (span_len, size_lower_bound) = if self.buffered.is_none() {
+            if let Some(next) = self.next_non_empty_sound_params() {
+                (next.span_len, next.size_lower_bound)
+            } else if self.should_end_when_input_empty() {
+                return Some(0);
+            } else {
+                self.starting_silence.set(true);
+                return Some(self.silence_span_len());
+            }
+        } else {
+            (self.current.current_span_len(), self.current.size_hint().0)
+        };
+
+        if self.samples_left_in_span.get() > 0 {
+            return Some(self.samples_left_in_span.get());
+        }
+
+        let res = if let Some(len) = span_len {
             // correct len for buffered sample
-            let len = if self.next_sample.is_some() {
+            let len = if self.buffered.is_some() {
                 len + 1
             } else {
                 len
@@ -144,27 +166,57 @@ where
                 //
                 // We signal to next that we need a silence now even if a new
                 // source is available
-                self.filling_initial_silence.set(true);
+                self.starting_silence.set(true);
+                if let Some(params) = self.next_non_empty_sound_params() {
+                    self.starting_silence_sample_rate.set(params.sample_rate);
+                    self.starting_silence_channels.set(params.channels);
+                } else {
+                    self.starting_silence_sample_rate.set(44_100);
+                    self.starting_silence_channels.set(2);
+                };
                 Some(self.silence_span_len())
             }
-        } else if self.current.size_hint().0 == 0 {
+        } else if size_lower_bound == 0 {
             // span could end earlier we correct for that by playing silence
             // if that happens
-            self.fallback_span_index.set(Some(0));
             Some(self.fallback_span_length())
         } else {
-            Some(self.current.size_hint().0)
+            Some(size_lower_bound)
+        };
+
+        if let Some(len) = res {
+            self.samples_left_in_span.set(len);
         }
+
+        res
     }
 
     #[inline]
     fn channels(&self) -> ChannelCount {
-        self.current.channels()
+        if self.buffered.is_none() {
+            if let Some(next) = self.next_non_empty_sound_params() {
+                next.channels
+            } else {
+                self.starting_silence_channels.set(2);
+                2
+            }
+        } else {
+            self.current.channels()
+        }
     }
 
     #[inline]
     fn sample_rate(&self) -> SampleRate {
-        self.current.sample_rate()
+        if self.buffered.is_none() {
+            if let Some(next) = self.next_non_empty_sound_params() {
+                next.sample_rate
+            } else {
+                self.starting_silence_sample_rate.set(44_100);
+                44100
+            }
+        } else {
+            self.current.sample_rate()
+        }
     }
 
     #[inline]
@@ -189,48 +241,50 @@ where
 
 impl<S> Iterator for QueueSource<S>
 where
-    S: Sample + Send + 'static,
+    S: Sample + Send + 'static + std::fmt::Debug,
 {
     type Item = S;
 
     #[inline]
     fn next(&mut self) -> Option<S> {
-        self.fallback_span_index
-            .set(self.fallback_span_index.get().map(|idx| idx + 1));
-
         // may only return None when the queue should end
-        match (self.next_sample.take(), self.current.next()) {
+        let res = match dbg!((self.buffered.take(), self.current.next())) {
             (Some(sample1), Some(samples2)) => {
-                self.next_sample = Some(samples2);
+                self.buffered = Some(samples2);
                 Some(sample1)
             }
             (Some(sample1), None) => self.current_is_ending(sample1),
             (None, Some(sample1)) => {
                 // start, populate the buffer
-                self.next_sample = self.current.next();
+                self.buffered = self.current.next();
                 Some(sample1)
             }
             (None, None) => self.no_buffer_no_source(),
+        };
+
+        if let Some(samples_left) = self.samples_left_in_span.get().checked_sub(1) {
+            self.samples_left_in_span.set(dbg!(samples_left));
         }
+
+        res
     }
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.current.size_hint().0, None)
+        (0, None)
     }
 }
 
 impl<S> QueueSource<S>
 where
-    S: Sample + Send + 'static,
+    S: Sample + Send + 'static + core::fmt::Debug,
 {
     fn fallback_span_length(&self) -> usize {
         // ~ 5 milliseconds at 44100
         200 * self.channels() as usize
     }
 
-    fn finish_forced_span(&self, span_idx: usize) -> Sound<S> {
-        let samples = self.fallback_span_length() - span_idx;
+    fn finish_span_with_silence(&self, samples: usize) -> Sound<S> {
         let silence =
             Zero::<S>::new_samples(self.current.channels(), self.current.sample_rate(), samples);
         Box::new(silence)
@@ -261,9 +315,9 @@ where
     fn no_buffer_no_source(&mut self) -> Option<S> {
         // Prevents a race condition where a call `current_span_len`
         // precedes the call to `next`
-        if self.filling_initial_silence.get() {
+        if dbg!(self.starting_silence.get()) {
             self.current = self.silence();
-            self.filling_initial_silence.set(true);
+            self.starting_silence.set(true);
             return self.current.next();
         }
 
@@ -271,7 +325,8 @@ where
             if let Some(mut sound) = self.next_sound() {
                 if let Some((sample1, sample2)) = sound.next().zip(sound.next()) {
                     self.current = sound;
-                    self.next_sample = Some(sample2);
+                    self.buffered = Some(sample2);
+                    self.current_span_len();
                     return Some(sample1);
                 } else {
                     continue;
@@ -286,19 +341,25 @@ where
     }
 
     fn current_is_ending(&mut self, sample1: S) -> Option<S> {
-        if let Some(idx) = self.fallback_span_index.get() {
-            if idx < self.fallback_span_length() {
-                self.fallback_span_index.set(None);
-                self.current = self.finish_forced_span(idx);
-                return Some(sample1);
-            }
+        // note sources are free to stop (return None) mid frame and
+        // mid span, we must handle that here
+
+        // check if the span we reported is ended after returning the
+        // buffered source. If not we need to provide a silence to guarantee
+        // the span ends when we promised
+        if self.samples_left_in_span.get() > 1 {
+            dbg!(&self.samples_left_in_span);
+            self.current = self.finish_span_with_silence(self.samples_left_in_span.get() - 1);
+            return Some(sample1);
         }
 
         loop {
             if let Some(mut sound) = self.next_sound() {
                 if let Some(sample2) = sound.next() {
                     self.current = sound;
-                    self.next_sample = Some(sample2);
+                    // updates samples_left_in_span
+                    self.buffered = Some(sample2);
+                    self.current_span_len();
                     return Some(sample1);
                 } else {
                     continue;
@@ -307,9 +368,31 @@ where
                 return Some(sample1);
             } else {
                 self.current = self.silence();
-                self.next_sample = self.current.next();
+                self.current_span_len();
+                self.buffered = self.current.next();
                 return Some(sample1);
             }
         }
     }
+
+    fn next_non_empty_sound_params(&self) -> Option<NonEmptySourceParams> {
+        let next_sounds = self.input.next_sounds.lock().unwrap();
+        next_sounds
+            .iter()
+            .find(|s| s.current_span_len().is_none_or(|l| l > 0))
+            .map(|s| NonEmptySourceParams {
+                size_lower_bound: s.size_hint().0,
+                span_len: s.current_span_len(),
+                channels: s.channels(),
+                sample_rate: s.sample_rate(),
+            })
+    }
+}
+
+#[derive(Debug)]
+struct NonEmptySourceParams {
+    size_lower_bound: usize,
+    span_len: Option<usize>,
+    channels: ChannelCount,
+    sample_rate: SampleRate,
 }
diff --git a/src/sink.rs b/src/sink.rs
index d1dd52b7..94172dae 100644
--- a/src/sink.rs
+++ b/src/sink.rs
@@ -440,6 +440,7 @@ mod tests {
         assert_eq!(queue_rx.next(), src.next());
     }
 
+    #[ignore = "debugging queue"]
     #[test]
     fn test_volume() {
         let (sink, mut queue_rx) = Sink::new();
diff --git a/tests/queue.rs b/tests/queue.rs
index ad6b28bd..51f9f2f6 100644
--- a/tests/queue.rs
+++ b/tests/queue.rs
@@ -10,27 +10,39 @@ use test_support::TestSource;
 fn basic() {
     let (controls, mut source) = queue::queue(false);
 
-    controls.append(SamplesBuffer::new(1, 48000, vec![10i16, -10, 10, -10]));
-    controls.append(SamplesBuffer::new(2, 96000, vec![5i16, 5, 5, 5]));
+    let mut source1 = SamplesBuffer::new(1, 48000, vec![10i16, -10, 10, -10]);
+    let mut source2 = SamplesBuffer::new(2, 96000, vec![5i16, 5, 5, 5]);
+    controls.append(source1.clone());
+    controls.append(source2.clone());
 
-    assert_eq!(source.channels(), 1);
-    assert_eq!(source.sample_rate(), 48000);
-    assert_eq!(source.next(), Some(10));
-    assert_eq!(source.next(), Some(-10));
-    assert_eq!(source.next(), Some(10));
-    assert_eq!(source.next(), Some(-10));
-    assert_eq!(source.channels(), 2);
-    assert_eq!(source.sample_rate(), 96000);
-    assert_eq!(source.next(), Some(5));
-    assert_eq!(source.next(), Some(5));
-    assert_eq!(source.next(), Some(5));
-    assert_eq!(source.next(), Some(5));
+    assert_eq!(source.current_span_len(), Some(4));
+    assert_eq!(source.channels(), source1.channels());
+    assert_eq!(source.sample_rate(), source1.sample_rate());
+    assert_eq!(source.next(), source1.next());
+    assert_eq!(source.next(), source1.next());
+    assert_eq!(source.current_span_len(), Some(2));
+    assert_eq!(source.next(), source1.next());
+    assert_eq!(source.next(), source1.next());
+    assert_eq!(None, source1.next());
+
+    assert_eq!(source.current_span_len(), Some(4));
+    assert_eq!(source.channels(), source2.channels());
+    assert_eq!(source.sample_rate(), source2.sample_rate());
+    assert_eq!(source.next(), source2.next());
+    assert_eq!(source.next(), source2.next());
+    assert_eq!(source.current_span_len(), Some(2));
+    assert_eq!(source.next(), source2.next());
+    assert_eq!(source.next(), source2.next());
+    assert_eq!(None, source2.next());
+
+    assert_eq!(source.current_span_len(), Some(0));
     assert_eq!(source.next(), None);
 }
 
 #[test]
 fn immediate_end() {
     let (_, mut source) = queue::queue::<i16>(false);
+    assert_eq!(source.current_span_len(), Some(0));
     assert_eq!(source.next(), None);
 }
 
@@ -50,7 +62,7 @@ fn keep_alive() {
 }
 
 #[test]
-fn limited_delay_when_added() {
+fn limited_delay_when_added_with_keep_alive() {
     let (controls, mut source) = queue::queue(true);
 
     for _ in 0..500 {
@@ -62,14 +74,31 @@ fn limited_delay_when_added() {
     let channels = source.channels() as f64;
     let delay_samples = source.by_ref().take_while(|s| *s == 0).count();
     let delay = Duration::from_secs_f64(delay_samples as f64 / channels / sample_rate);
-    assert!(delay < Duration::from_millis(5));
+    assert!(delay < Duration::from_millis(10), "delay was: {delay:?}");
 
-    // assert_eq!(source.next(), Some(10)); // we lose this in the take_while
+    // note we lose the first sample in the take_while
     assert_eq!(source.next(), Some(-10));
     assert_eq!(source.next(), Some(10));
     assert_eq!(source.next(), Some(-10));
 }
 
+#[test]
+fn parameters_queried_before_next() {
+    let test_source = TestSource::new(&[0.1; 5])
+        .with_channels(1)
+        .with_sample_rate(1);
+
+    let (controls, mut source) = queue::queue(true);
+
+    assert_eq!(source.current_span_len(), Some(400));
+    controls.append(test_source);
+    assert_eq!(source.next(), Some(0.0));
+    for i in 0..199 {
+        assert_eq!(source.next(), Some(0.0), "iteration {i}");
+    }
+    assert_eq!(source.next(), Some(0.1));
+}
+
 mod source_without_span_or_lower_bound_ending_early {
     use super::*;
 
@@ -120,8 +149,41 @@ mod source_without_span_or_lower_bound_ending_early {
         assert_eq!(source.next(), Some(0.1));
         assert_eq!(source.next(), Some(0.1));
 
-        assert_eq!(source.current_span_len(), Some(5));
-        assert_eq!(source.next(), Some(0.2));
+        assert_eq!(source.current_span_len(), Some(195));
+        assert_eq!(source.take_while(|s| *s == 0.0).count(), 195);
+    }
+
+    #[test]
+    fn span_ending_mid_frame() {
+        let mut test_source1 = TestSource::new(&[0.1, 0.2, 0.1, 0.2, 0.1])
+            .with_channels(2)
+            .with_sample_rate(1)
+            .with_false_span_len(Some(6));
+        let mut test_source2 = TestSource::new(&[0.3, 0.4, 0.3, 0.4])
+            .with_channels(2)
+            .with_sample_rate(1);
+
+        let (controls, mut source) = queue::queue(true);
+        controls.append(test_source1.clone());
+        controls.append(test_source2.clone());
+
+        assert_eq!(source.current_span_len(), Some(6));
+        assert_eq!(source.next(), test_source1.next());
+        assert_eq!(source.next(), test_source1.next());
+        assert_eq!(source.next(), test_source1.next());
+        assert_eq!(source.next(), test_source1.next());
+        assert_eq!(source.next(), test_source1.next());
+        assert_eq!(source.current_span_len(), Some(1));
+        assert_eq!(None, test_source1.next());
+
+        // extra sample to ensure frames are aligned
+        assert_eq!(source.next(), Some(0.0));
+
+        assert_eq!(source.current_span_len(), Some(4));
+        assert_eq!(source.next(), test_source2.next(),);
+        assert_eq!(source.next(), test_source2.next());
+        assert_eq!(source.next(), test_source2.next());
+        assert_eq!(source.next(), test_source2.next());
     }
 }
 
@@ -129,6 +191,7 @@ mod source_without_span_or_lower_bound_ending_early {
 mod test_support {
     use std::time::Duration;
 
+    #[derive(Debug, Clone)]
     pub struct TestSource {
         samples: Vec<f32>,
         pos: usize,