use crate::stream::{CacheListener, FragmentCache, FragmentData, MediaTimeline};
use std::fmt;
use std::ops::Range;
use std::sync::{Arc, Mutex, Weak};
use std::time::Duration;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BufferStatus {
pub total: BufferTotal,
pub downloaded: BufferAmount,
pub ranges: Vec<Range<Duration>>,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct BufferAmount {
pub fragments: usize,
pub bytes: u64,
pub time: Duration,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct BufferTotal {
pub fragments: usize,
pub bytes: Option<u64>,
pub time: Duration,
}
impl BufferStatus {
pub fn buffered_until(&self, position: Duration) -> Duration {
let position = position.min(self.total.time);
self.ranges
.iter()
.find(|range| range.contains(&position))
.map_or(position, |range| range.end)
}
pub fn buffered_percent(&self, position: Duration) -> f64 {
percent(
self.buffered_until(position).as_secs_f64(),
self.total.time.as_secs_f64(),
)
}
pub fn downloaded_percent(&self) -> f64 {
percent(
self.downloaded.time.as_secs_f64(),
self.total.time.as_secs_f64(),
)
}
pub fn downloaded_bytes_percent(&self) -> Option<f64> {
let total = self.total.bytes?;
Some(percent(self.downloaded.bytes as f64, total as f64))
}
pub fn is_complete(&self) -> bool {
self.downloaded.fragments == self.total.fragments
}
fn measure(media: &[Arc<FragmentData>], spans: &[Range<Duration>]) -> Self {
let mut status = Self {
total: BufferTotal {
fragments: media.len(),
bytes: Some(0),
time: spans.last().map_or(Duration::ZERO, |span| span.end),
},
downloaded: BufferAmount::default(),
ranges: Vec::new(),
};
let mut previous_downloaded = false;
for (data, span) in media.iter().zip(spans) {
status.total.bytes = status
.total
.bytes
.zip(data.size())
.map(|(total, size)| total + size);
let Some(body) = data.body() else {
previous_downloaded = false;
continue;
};
status.downloaded.fragments += 1;
status.downloaded.bytes += body.len() as u64;
status.downloaded.time += span.end - span.start;
match status.ranges.last_mut() {
Some(range) if previous_downloaded => range.end = span.end,
_ => status.ranges.push(span.clone()),
}
previous_downloaded = true;
}
status
}
}
fn percent(part: f64, whole: f64) -> f64 {
if whole <= 0.0 {
return 100.0;
}
(part / whole * 100.0).min(100.0)
}
#[derive(Clone)]
pub struct BufferHandle(Arc<BufferShared>);
type ChangeCallback = dyn Fn(&BufferStatus) + Send + Sync;
struct BufferShared {
media: Vec<Arc<FragmentData>>,
spans: Vec<Range<Duration>>,
callbacks: Mutex<Vec<Arc<ChangeCallback>>>,
}
impl BufferHandle {
pub(crate) fn new(
cache: &FragmentCache,
media: Vec<Arc<FragmentData>>,
timeline: &MediaTimeline,
) -> Self {
let mut spans = timeline.spans();
let end = spans.last().map_or(Duration::ZERO, |span| span.end);
spans.resize(media.len(), end..end);
let shared = Arc::new(BufferShared {
media,
spans,
callbacks: Mutex::default(),
});
cache.subscribe(Arc::downgrade(&shared) as Weak<dyn CacheListener>);
Self(shared)
}
pub fn status(&self) -> BufferStatus {
self.0.status()
}
pub fn on_change(&self, callback: impl Fn(&BufferStatus) + Send + Sync + 'static) {
self.0
.callbacks
.lock()
.unwrap_or_else(|error| error.into_inner())
.push(Arc::new(callback));
}
}
impl BufferShared {
fn status(&self) -> BufferStatus {
BufferStatus::measure(&self.media, &self.spans)
}
fn changed(&self) {
let callbacks = self
.callbacks
.lock()
.unwrap_or_else(|error| error.into_inner())
.clone();
if callbacks.is_empty() {
return;
}
let status = self.status();
for callback in callbacks {
callback(&status);
}
}
}
impl CacheListener for BufferShared {
fn fragment_changed(&self, data: &FragmentData) {
if self.media.iter().any(|media| std::ptr::eq(&**media, data)) {
self.changed();
}
}
}
impl fmt::Debug for BufferHandle {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("BufferHandle").field(&self.status()).finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Fragment;
fn spans() -> Vec<Range<Duration>> {
MediaTimeline {
timescale: 10,
media_durations: vec![20, 20, 20],
}
.spans()
}
fn media(fragments: [Fragment; 3], bodies: [Option<usize>; 3]) -> Vec<Arc<FragmentData>> {
fragments
.into_iter()
.zip(bodies)
.map(|(fragment, body)| {
let data = FragmentData::new(fragment);
if let Some(len) = body {
data.set_body(&vec![0; len]);
}
Arc::new(data)
})
.collect()
}
fn unranged(bodies: [Option<usize>; 3]) -> Vec<Arc<FragmentData>> {
media(["a".into(), "b".into(), "c".into()], bodies)
}
fn secs(secs: f64) -> Duration {
Duration::from_secs_f64(secs)
}
#[test]
fn nothing_downloaded_buffers_nothing() {
let status = BufferStatus::measure(&unranged([None; 3]), &spans());
assert_eq!(status.total.fragments, 3);
assert_eq!(status.total.bytes, None);
assert_eq!(status.total.time, secs(6.0));
assert_eq!(status.downloaded, BufferAmount::default());
assert!(status.ranges.is_empty());
assert_eq!(status.buffered_until(secs(3.0)), secs(3.0));
assert_eq!(status.buffered_percent(secs(3.0)), 50.0);
assert_eq!(status.downloaded_bytes_percent(), None);
assert!(!status.is_complete());
}
#[test]
fn buffered_until_runs_to_the_end_of_the_range_holding_the_position() {
let status = BufferStatus::measure(&unranged([Some(100), None, Some(300)]), &spans());
assert_eq!(
status.downloaded,
BufferAmount {
fragments: 2,
bytes: 400,
time: secs(4.0)
}
);
assert_eq!(status.ranges, [secs(0.0)..secs(2.0), secs(4.0)..secs(6.0)]);
assert!((status.downloaded_percent() - 200.0 / 3.0).abs() < 1e-9);
assert_eq!(status.buffered_until(secs(1.0)), secs(2.0));
assert!((status.buffered_percent(secs(1.0)) - 100.0 / 3.0).abs() < 1e-9);
assert_eq!(status.buffered_until(secs(3.0)), secs(3.0));
assert_eq!(status.buffered_until(secs(5.0)), secs(6.0));
assert_eq!(status.buffered_percent(secs(5.0)), 100.0);
assert!(!status.is_complete());
}
#[test]
fn adjacent_fragments_merge_into_one_range() {
let status = BufferStatus::measure(&unranged([Some(10), Some(10), Some(10)]), &spans());
assert_eq!(status.ranges, [secs(0.0)..secs(6.0)]);
assert_eq!(status.buffered_until(Duration::ZERO), secs(6.0));
assert_eq!(status.total.bytes, Some(30));
assert_eq!(status.downloaded_bytes_percent(), Some(100.0));
assert!(status.is_complete());
}
#[test]
fn byte_ranges_give_total_bytes_before_download() {
let media = media(
[
Fragment::with_range("f", 0..=99),
Fragment::with_range("f", 100..=199),
Fragment::with_range("f", 200..=499),
],
[Some(100), None, None],
);
let status = BufferStatus::measure(&media, &spans());
assert_eq!(status.total.bytes, Some(500));
assert_eq!(status.downloaded_bytes_percent(), Some(20.0));
}
#[test]
fn position_past_the_end_is_clamped() {
let status = BufferStatus::measure(&unranged([None; 3]), &spans());
assert_eq!(status.buffered_until(secs(60.0)), secs(6.0));
assert_eq!(status.buffered_percent(secs(60.0)), 100.0);
}
}