Adds split_once to Source

examples/fadeout_end.rs

@@ -0,0 +1,25 @@
+use std::error::Error;
+use std::io::BufReader;
+use std::time::Duration;
+
+use rodio::Source;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let stream_handle = rodio::OutputStreamBuilder::open_default_stream()?;
+    let sink = rodio::Sink::connect_new(&stream_handle.mixer());
+
+    let file = std::fs::File::open("assets/music.wav")?;
+    let music = rodio::Decoder::new(BufReader::new(file))?;
+    let [start, end] = music.split_once(Duration::from_secs(3));
+    let end_duration = end
+        .total_duration()
+        .expect("can only fade out at the end if we know the total duration");
+    let end = end.fade_out(end_duration);
+
+    sink.append(start);
+    sink.append(end);
+
+    sink.sleep_until_end();
+
+    Ok(())
+}

src/source/blt.rs

@@ -122,10 +122,7 @@ where
             self.applier = Some(self.formula.to_applier(self.input.sample_rate()));
         }
 
-        let sample = match self.input.next() {
-            None => return None,
-            Some(s) => s,
-        };
+        let sample = self.input.next()?;
 
         let result = self
             .applier

src/source/mod.rs

@@ -6,6 +6,7 @@ use core::time::Duration;
 use crate::common::{ChannelCount, SampleRate};
 use crate::Sample;
 use dasp_sample::FromSample;
+use split_at::SplitAt;
 
 pub use self::agc::AutomaticGainControl;
 pub use self::amplify::Amplify;
@@ -72,6 +73,7 @@ mod skip;
 mod skippable;
 mod spatial;
 mod speed;
+mod split_at;
 mod square;
 mod stoppable;
 mod take;
@@ -498,6 +500,15 @@ where
         skippable::skippable(self)
     }
 
+    /// returns two sources, the second source is inactive and will return
+    /// `None` until the first has passed the split_point.
+    fn split_once(self, at: Duration) -> [SplitAt<Self>; 2]
+    where
+        Self: Sized,
+    {
+        SplitAt::new(self, at)
+    }
+
     /// Start tracking the elapsed duration since the start of the underlying
     /// source.
     ///
@@ -606,6 +617,8 @@ pub enum SeekError {
     // own `try_seek` implementations.
     /// Any other error probably in a custom Source
     Other(Box<dyn std::error::Error + Send>),
+    /// Can not seek, this part of the split is not active
+    SplitNotActive,
 }
 impl fmt::Display for SeekError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -622,6 +635,9 @@ impl fmt::Display for SeekError {
             #[cfg(feature = "wav")]
             SeekError::HoundDecoder(err) => write!(f, "Error seeking in wav source: {}", err),
             SeekError::Other(_) => write!(f, "An error occurred"),
+            SeekError::SplitNotActive => {
+                write!(f, "Can not seek, this part of the split is still active")
+            }
         }
     }
 }
@@ -634,6 +650,7 @@ impl std::error::Error for SeekError {
             #[cfg(feature = "wav")]
             SeekError::HoundDecoder(err) => Some(err),
             SeekError::Other(err) => Some(err.as_ref()),
+            SeekError::SplitNotActive => None,
         }
     }
 }
@@ -656,6 +673,7 @@ impl SeekError {
             #[cfg(feature = "wav")]
             SeekError::HoundDecoder(_) => false,
             SeekError::Other(_) => false,
+            SeekError::SplitNotActive => true,
         }
     }
 }

src/source/split_at.rs

@@ -0,0 +1,123 @@
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::time::Duration;
+
+use crate::ChannelCount;
+use crate::SampleRate;
+
+use super::Source;
+use super::TrackPosition;
+
+pub struct SplitAt<S> {
+    shared_source: Arc<Mutex<Option<TrackPosition<S>>>>,
+    active: Option<TrackPosition<S>>,
+    split_duration: Option<Duration>,
+    split_point: Duration,
+    first_span_sample_rate: SampleRate,
+    first_span_channel_count: ChannelCount,
+}
+
+impl<S> SplitAt<S>
+where
+    S: Source,
+    <S as Iterator>::Item: crate::Sample,
+{
+    /// returns two sources, the second is inactive and will return
+    /// none until the first has passed the split_point.
+    pub(crate) fn new(input: S, split_point: Duration) -> [Self; 2] {
+        let shared_source = Arc::new(Mutex::new(None));
+        let first_span_sample_rate = input.sample_rate();
+        let first_span_channel_count = input.channels();
+        let total_duration = input.total_duration();
+        [
+            Self {
+                shared_source: shared_source.clone(),
+                active: Some(input.track_position()),
+                split_duration: Some(split_point),
+                split_point,
+                first_span_sample_rate,
+                first_span_channel_count,
+            },
+            Self {
+                shared_source,
+                active: None,
+                split_duration: total_duration.map(|d| d.saturating_sub(split_point)),
+                split_point: Duration::MAX,
+                first_span_sample_rate,
+                first_span_channel_count,
+            },
+        ]
+    }
+}
+
+impl<S> Iterator for SplitAt<S>
+where
+    S: Source,
+    S::Item: crate::Sample,
+{
+    type Item = <S as Iterator>::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let input = if let Some(active) = self.active.as_mut() {
+            active
+        } else {
+            // did they other stop?
+            let shared = self
+                .shared_source
+                .lock()
+                .expect("audio thread should not panic")
+                .take();
+            self.active = shared;
+            self.active.as_mut()?
+        };
+
+        // There is some optimization potential here we are not using currently.
+        // Calling get_pos once per span should be enough
+        if input.get_pos() < self.split_point {
+            input.next()
+        } else {
+            let source = self.active.take();
+            *self
+                .shared_source
+                .lock()
+                .expect("audio thread should not panic") = source;
+            None
+        }
+    }
+}
+
+impl<S> Source for SplitAt<S>
+where
+    S: Source,
+    S::Item: crate::Sample,
+{
+    fn current_span_len(&self) -> Option<usize> {
+        self.active.as_ref()?.current_span_len()
+    }
+
+    fn channels(&self) -> ChannelCount {
+        self.active
+            .as_ref()
+            .map(Source::channels)
+            .unwrap_or(self.first_span_channel_count)
+    }
+
+    fn sample_rate(&self) -> SampleRate {
+        self.active
+            .as_ref()
+            .map(Source::sample_rate)
+            .unwrap_or(self.first_span_sample_rate)
+    }
+
+    fn total_duration(&self) -> Option<Duration> {
+        self.split_duration
+    }
+
+    fn try_seek(&mut self, pos: Duration) -> Result<(), super::SeekError> {
+        if let Some(active) = self.active.as_mut() {
+            active.try_seek(pos)
+        } else {
+            Err(super::SeekError::SplitNotActive)
+        }
+    }
+}