Calculate duration for mp3s

src/decoder/read_seek_source.rs

@@ -1,17 +1,36 @@
 use std::io::{Read, Result, Seek, SeekFrom};
 use std::marker::Sync;
+use std::sync::{Mutex, RwLock};
 
 use symphonia::core::io::MediaSource;
 
 pub struct ReadSeekSource<T: Read + Seek + Send + Sync> {
-    inner: T,
+    inner: Mutex<T>,
+    byte_len: RwLock<Option<Option<u64>>>, // One option is for lazy calculation
+}
+
+// Copied from std Seek::stream_len since its unstable
+fn stream_len(stream: &mut impl Seek) -> std::io::Result<u64> {
+    let old_pos = stream.stream_position()?;
+    let len = stream.seek(SeekFrom::End(0))?;
+
+    // Avoid seeking a third time when we were already at the end of the
+    // stream. The branch is usually way cheaper than a seek operation.
+    if old_pos != len {
+        stream.seek(SeekFrom::Start(old_pos))?;
+    }
+
+    Ok(len)
 }
 
 impl<T: Read + Seek + Send + Sync> ReadSeekSource<T> {
     /// Instantiates a new `ReadSeekSource<T>` by taking ownership and wrapping the provided
     /// `Read + Seek`er.
     pub fn new(inner: T) -> Self {
-        ReadSeekSource { inner }
+        ReadSeekSource {
+            inner: Mutex::new(inner),
+            byte_len: RwLock::new(None),
+        }
     }
 }
 
@@ -21,18 +40,31 @@ impl<T: Read + Seek + Send + Sync> MediaSource for ReadSeekSource<T> {
     }
 
     fn byte_len(&self) -> Option<u64> {
-        None
+        // Check if length was calculated before
+        let byte_len = self.byte_len.read().unwrap();
+        if let Some(cached) = *byte_len {
+            return cached;
+        }
+        std::mem::drop(byte_len); // Release read lock
+
+        let mut inner = self.inner.lock().unwrap();
+        let calculated_stream_len = match stream_len(&mut *inner) {
+            Ok(len) => Some(len),
+            Err(_) => None, // Ignore error, cache failure
+        };
+        *self.byte_len.write().unwrap() = Some(calculated_stream_len);
+        calculated_stream_len
     }
 }
 
 impl<T: Read + Seek + Send + Sync> Read for ReadSeekSource<T> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
-        self.inner.read(buf)
+        self.inner.get_mut().unwrap().read(buf)
     }
 }
 
 impl<T: Read + Seek + Send + Sync> Seek for ReadSeekSource<T> {
     fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
-        self.inner.seek(pos)
+        self.inner.get_mut().unwrap().seek(pos)
     }
 }

src/decoder/symphonia.rs

@@ -28,6 +28,7 @@ pub struct SymphoniaDecoder {
     format: Box<dyn FormatReader>,
     buffer: SampleBuffer<i16>,
     spec: SignalSpec,
+    duration: Option<Duration>,
 }
 
 impl SymphoniaDecoder {
@@ -80,6 +81,16 @@ impl SymphoniaDecoder {
             },
         )?;
 
+        // Calculate duration if possible
+        let mut duration = None;
+        if let Some(time_base) = &stream.codec_params.time_base {
+            if let Some(n_frames) = stream.codec_params.n_frames {
+                let time = time_base.calc_time(n_frames);
+                duration =
+                    Some(Duration::from_secs(time.seconds) + Duration::from_secs_f64(time.frac));
+            }
+        }
+
         let mut decode_errors: usize = 0;
         let decoded = loop {
             let current_frame = probed.format.next_packet()?;
@@ -107,6 +118,7 @@ impl SymphoniaDecoder {
             format: probed.format,
             buffer,
             spec,
+            duration,
         }));
     }
 
@@ -137,7 +149,7 @@ impl Source for SymphoniaDecoder {
 
     #[inline]
     fn total_duration(&self) -> Option<Duration> {
-        None
+        self.duration
     }
 }