Add Elapsed filter

examples/elapsed.rs

@@ -0,0 +1,26 @@
+extern crate rodio;
+
+use rodio::Source;
+use std::io::BufReader;
+use std::time::{Duration};
+use std::sync::{Mutex, Arc};
+use std::thread;
+
+fn main() {
+    let device = rodio::default_output_device().unwrap();
+    let sink = rodio::Sink::new(&device);
+
+    let file = std::fs::File::open("examples/music.ogg").unwrap();
+    let source = rodio::Decoder::new(BufReader::new(file)).unwrap();
+
+    let timer = Arc::new(Mutex::new(Duration::from_secs(0)));
+    let with_elapsed = source.buffered().elapsed(Arc::clone(&timer));
+    sink.append(with_elapsed);
+
+    while !sink.empty() {
+        let val = *timer.lock().unwrap();
+
+        println!("Music has played for {}.{} seconds", val.as_secs(), val.subsec_millis());
+        thread::sleep(Duration::from_secs(1));
+    }
+}

src/source/elapsed.rs

@@ -0,0 +1,76 @@
+use std::time::Duration;
+use std::sync::{Mutex, Arc};
+
+use Sample;
+use Source;
+
+/// Internal function that builds a `Elapsed` object.
+pub fn elapsed<I>(input: I, duration: Arc<Mutex<Duration>>) -> Elapsed<I>
+where
+    I: Source,
+    I::Item: Sample,
+{
+    Elapsed {
+        input: input,
+        duration: duration,
+    }
+}
+
+/// Filter that updates a `Duration` with the current elapsed time.
+#[derive(Clone, Debug)]
+pub struct Elapsed<I> {
+    input: I,
+    duration: Arc<Mutex<Duration>>,
+}
+
+impl<I> Iterator for Elapsed<I>
+where
+    I: Source,
+    I::Item: Sample,
+{
+    type Item = I::Item;
+
+    #[inline]
+    fn next(&mut self) -> Option<I::Item> {
+        let mut duration = self.duration.lock().unwrap();
+
+        // Calculate sample_time in nanoseconds
+        let sample_time = (1_000_000_000 / self.sample_rate()) / self.channels() as u32;
+
+        let time_elapsed = Duration::from_nanos(sample_time.into());
+        *duration += time_elapsed;
+
+        self.input.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.input.size_hint()
+    }
+}
+
+impl<I> Source for Elapsed<I>
+where
+    I: Source,
+    I::Item: Sample,
+{
+    #[inline]
+    fn current_frame_len(&self) -> Option<usize> {
+        self.input.current_frame_len()
+    }
+
+    #[inline]
+    fn channels(&self) -> u16 {
+        self.input.channels()
+    }
+
+    #[inline]
+    fn sample_rate(&self) -> u32 {
+        self.input.sample_rate()
+    }
+
+    #[inline]
+    fn total_duration(&self) -> Option<Duration> {
+        self.input.total_duration()
+    }
+}

src/source/mod.rs

@@ -1,6 +1,7 @@
 //! Sources of sound and various filters.
 
 use std::time::Duration;
+use std::sync::{Arc, Mutex};
 
 use Sample;
 
@@ -13,6 +14,7 @@ pub use self::delay::Delay;
 pub use self::done::Done;
 pub use self::empty::Empty;
 pub use self::fadein::FadeIn;
+pub use self::elapsed::Elapsed;
 pub use self::from_factory::{from_factory, FromFactoryIter};
 pub use self::from_iter::{from_iter, FromIter};
 pub use self::mix::Mix;
@@ -37,6 +39,7 @@ mod delay;
 mod done;
 mod empty;
 mod fadein;
+mod elapsed;
 mod from_factory;
 mod from_iter;
 mod mix;
@@ -225,6 +228,24 @@ where
         fadein::fadein(self, duration)
     }
 
+    /// Updates the supplied `Duration` with the total elapsed time for the source
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use std::time::Duration;
+    ///
+    /// let duration = Arc::new(Mutex::new(Duration::from_secs(0)));
+    /// let source = source.buffered().elapsed(Arc::clone(&duration));
+    /// ```
+    #[inline]
+    fn elapsed(self, duration: Arc<Mutex<Duration>>) -> Elapsed<Self>
+    where
+        Self: Sized,
+    {
+        elapsed::elapsed(self, duration)
+    }
+
     /// Calls the `access` closure on `Self` the first time the source is iterated and every
     /// time `period` elapses.
     ///