use std::{
collections::VecDeque,
sync::{Arc, Condvar, Mutex, MutexGuard},
};
pub use crate::core::{MediaError, MediaInfo};
use crate::{
images::ImageData,
resources::{Load, LoadError, LoadState, Loader, MediaDiskCache, Reader, Source, SourceKind},
time::{Duration, Instant},
};
#[cfg(any(target_os = "macos", target_os = "ios"))]
mod apple;
mod cache;
mod driven;
mod events;
#[cfg(windows)]
mod mf;
mod session;
#[cfg(all(test, windows))]
pub(crate) fn lose_card_for_test() {
mf::LOSE_CARD.store(true, std::sync::atomic::Ordering::Release);
}
#[cfg(windows)]
mod output;
#[cfg(target_arch = "wasm32")]
mod web;
pub use cache::{DEFAULT_SOUND_CACHE_BYTES, SoundCache, sound_cache};
#[doc(hidden)]
pub use driven::{DrivenMedias, MediaDriver, drive_media};
pub(crate) use events::{LoopNoted, note_loop, tell_news};
pub use session::AudioCategory;
pub(crate) use session::set_category as set_audio_category;
type Waker = Arc<dyn Fn() + Send + Sync>;
#[derive(Clone, Debug, PartialEq)]
pub struct MediaState {
pub duration: Option<f64>,
pub position: f64,
pub buffered: Option<f64>,
pub size: Option<(u32, u32)>,
pub sound: bool,
pub volume: f32,
pub muted: bool,
pub playing: bool,
pub waiting: bool,
pub ended: bool,
pub error: Option<MediaError>,
pub rate: f64,
}
fn load_failed(error: LoadError) -> MediaError {
match error {
LoadError::NotFound => MediaError::NotFound,
LoadError::Denied => MediaError::Denied,
LoadError::Status(status) => MediaError::Server(status),
LoadError::TooLarge { .. } => MediaError::TooLarge,
LoadError::TimedOut => MediaError::TimedOut,
LoadError::Unsupported(why) => MediaError::Unavailable(Arc::from(why)),
LoadError::Io(said) => MediaError::Network(Arc::from(said)),
LoadError::Cancelled => MediaError::Other(Arc::from("the load was stopped")),
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) enum Command {
Play,
Pause,
Seek(f64),
Rate(f64),
Volume(f32),
Muted(bool),
Close,
}
pub(crate) struct Shared {
inner: Mutex<Inner>,
commands: Mutex<VecDeque<Command>>,
told: Condvar,
wakers: Mutex<Vec<Waker>>,
listening: std::sync::OnceLock<Arc<events::Listening>>,
read_failed: Mutex<Option<LoadError>>,
decoding_since: Mutex<Option<Instant>>,
reads_waiting: std::sync::atomic::AtomicUsize,
starved: std::sync::atomic::AtomicBool,
pub(crate) awaits_start: std::sync::atomic::AtomicBool,
eager: std::sync::atomic::AtomicBool,
stream: Mutex<Option<Arc<dyn Reader>>>,
whole: std::sync::atomic::AtomicBool,
}
#[cfg_attr(not(windows), allow(dead_code))]
fn fetched_to(position: f64, duration: f64, len: u64, held: &[std::ops::Range<u64>]) -> f64 {
if duration <= 0.0 || len == 0 {
return position;
}
let position = position.clamp(0.0, duration);
let at = ((position / duration) * len as f64) as u64;
let slack = (len / 50).max(1 << 20);
let mut end = None;
for range in held {
match end {
None if range.start <= at.saturating_add(slack) && at < range.end => end = Some(range.end),
Some(run) if range.start <= run => end = Some(run.max(range.end)),
_ => {}
}
}
match end {
Some(end) if end >= len => duration,
Some(end) => (end as f64 / len as f64 * duration).max(position),
None => position,
}
}
pub(crate) struct Inner {
pub duration: Option<f64>,
pub size: Option<(u32, u32)>,
pub sound: bool,
pub volume: f32,
pub muted: bool,
pub opened: bool,
pub playing: bool,
pub waiting: bool,
pub ended: bool,
pub error: Option<MediaError>,
pub rate: f64,
pub looped: bool,
pub rounds: u64,
pub presented: u64,
pub fetched: Option<f64>,
pub at: f64,
pub since: Instant,
pub sent: u64,
pub frame: Option<ImageData>,
}
impl Inner {
pub fn position(&self) -> f64 {
let moved = if self.playing && !self.waiting {
self.since.elapsed().as_secs_f64() * self.rate
} else {
0.0
};
let position = (self.at + moved).max(0.0);
match self.duration {
Some(duration) => position.min(duration),
None => position,
}
}
pub fn hold(&mut self) {
self.at = self.position();
self.since = Instant::now();
}
}
impl Shared {
fn new() -> Arc<Self> {
Arc::new(Self {
inner: Mutex::new(Inner {
duration: None,
size: None,
sound: false,
volume: 1.0,
muted: false,
opened: false,
playing: false,
waiting: true,
ended: false,
error: None,
rate: 1.0,
looped: false,
rounds: 0,
presented: 0,
fetched: None,
at: 0.0,
since: Instant::now(),
sent: 0,
frame: None,
}),
commands: Mutex::new(VecDeque::new()),
told: Condvar::new(),
wakers: Mutex::new(Vec::new()),
listening: std::sync::OnceLock::new(),
read_failed: Mutex::new(None),
decoding_since: Mutex::new(None),
reads_waiting: std::sync::atomic::AtomicUsize::new(0),
starved: std::sync::atomic::AtomicBool::new(false),
awaits_start: std::sync::atomic::AtomicBool::new(false),
eager: std::sync::atomic::AtomicBool::new(false),
stream: Mutex::new(None),
whole: std::sync::atomic::AtomicBool::new(false),
})
}
pub fn inner(&self) -> MutexGuard<'_, Inner> {
self.inner.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
}
pub fn wake(&self) {
let wakers = self
.wakers
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.clone();
for waker in wakers {
waker();
}
self.noted();
}
pub(crate) fn presented(&self) {
let mut inner = self.inner();
self.presented_in(&mut inner);
let first = inner.presented == 1;
drop(inner);
if first {
self.wake();
}
}
pub(crate) fn presented_in(&self, inner: &mut Inner) {
inner.presented += 1;
if self.awaits_start.swap(false, std::sync::atomic::Ordering::AcqRel) {
self.noted();
}
}
fn noted(&self) {
if let Some(listening) = self.listening.get() {
listening.note();
}
}
fn take_driven(&self, take: bool) -> Vec<Command> {
let mut commands = self.commands.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
if take {
commands.drain(..).collect()
} else {
commands.iter().copied().collect()
}
}
pub fn fail(&self, why: MediaError) {
{
let mut inner = self.inner();
inner.hold();
let read = self
.read_failed
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.take();
inner.error = Some(read.map_or(why, load_failed));
inner.playing = false;
inner.waiting = false;
}
self.wake();
}
#[cfg_attr(not(windows), allow(dead_code))]
pub(crate) fn decoding(&self) -> Decoding<'_> {
*self
.decoding_since
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner()) = Some(Instant::now());
Decoding(self)
}
#[cfg_attr(not(windows), allow(dead_code))]
fn is_starved(&self) -> bool {
let since = *self
.decoding_since
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
since.is_some_and(|since| since.elapsed() >= STARVED_AFTER)
&& self.reads_waiting.load(std::sync::atomic::Ordering::Acquire) > 0
}
#[cfg_attr(not(windows), allow(dead_code))]
fn set_reading(&self, waits: bool) {
{
let mut inner = self.inner();
if !inner.opened || inner.error.is_some() || inner.waiting == waits {
return;
}
inner.hold();
inner.waiting = waits;
}
self.wake();
}
pub fn take(&self, wait: Option<Duration>) -> Vec<Command> {
let mut commands = self.commands.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
if commands.is_empty()
&& let Some(wait) = wait
{
commands = self
.told
.wait_timeout(commands, wait)
.unwrap_or_else(|poisoned| poisoned.into_inner())
.0;
}
commands.drain(..).collect()
}
fn tell(&self, command: Command) {
self
.commands
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.push_back(command);
self.told.notify_all();
#[cfg(target_arch = "wasm32")]
web::told(self);
}
fn closed(&self, wait: Duration) -> bool {
let is = |commands: &VecDeque<Command>| commands.contains(&Command::Close);
let commands = self.commands.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
if is(&commands) {
return true;
}
let commands = self
.told
.wait_timeout(commands, wait)
.unwrap_or_else(|poisoned| poisoned.into_inner())
.0;
is(&commands)
}
}
struct Handle {
shared: Arc<Shared>,
}
impl Drop for Handle {
fn drop(&mut self) {
self.shared.tell(Command::Close);
}
}
#[derive(Clone)]
pub struct Media(Arc<Handle>);
pub(crate) type Headers = Arc<[(Arc<str>, Arc<str>)]>;
#[derive(Clone)]
pub(crate) enum Opened {
File(std::path::PathBuf),
Bytes(Arc<[u8]>, Option<Arc<str>>),
Url(Arc<str>, Headers),
#[cfg_attr(not(windows), allow(dead_code))]
Reader(Arc<dyn Reader>, Arc<str>),
}
fn stream(shared: &Arc<Shared>, loader: &Loader, source: &Source, address: Arc<str>) -> Option<Opened> {
#[cfg(windows)]
match loader.open_to_play(source, shared.eager.load(std::sync::atomic::Ordering::Acquire)) {
Ok(reader) => {
*shared.stream.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = Some(reader.clone());
reader.read_ahead(shared.eager.load(std::sync::atomic::Ordering::Acquire));
return Some(Opened::Reader(Arc::new(Watched::new(reader, shared)), address));
}
Err(LoadError::Unsupported(_)) => {}
Err(error) => {
shared.fail(load_failed(error));
return None;
}
}
let _ = shared;
Some(Opened::Url(address, Arc::from(loader.headers_of(source))))
}
#[cfg_attr(not(windows), allow(dead_code))]
struct Watched {
reader: Arc<dyn Reader>,
shared: std::sync::Weak<Shared>,
}
#[cfg_attr(not(windows), allow(dead_code))]
impl Watched {
fn new(reader: Arc<dyn Reader>, shared: &Arc<Shared>) -> Self {
watch_for_starving(shared);
Self {
reader,
shared: Arc::downgrade(shared),
}
}
}
const STARVED_AFTER: Duration = Duration::from_millis(250);
#[cfg_attr(not(windows), allow(dead_code))]
fn watch_for_starving(shared: &Arc<Shared>) {
use std::sync::atomic::Ordering;
let shared = Arc::downgrade(shared);
let _ = std::thread::Builder::new()
.name("lurq-media-starving".to_owned())
.spawn(move || {
loop {
std::thread::sleep(std::time::Duration::from_millis(40));
let Some(shared) = shared.upgrade() else {
return;
};
if shared.is_starved() && !shared.starved.swap(true, Ordering::AcqRel) {
shared.set_reading(true);
}
}
});
}
pub(crate) struct Decoding<'a>(&'a Shared);
impl Drop for Decoding<'_> {
fn drop(&mut self) {
*self
.0
.decoding_since
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner()) = None;
if self.0.starved.swap(false, std::sync::atomic::Ordering::AcqRel) {
self.0.set_reading(false);
}
}
}
impl Reader for Watched {
fn len(&self) -> Option<u64> {
self.reader.len()
}
fn content_type(&self) -> Option<Arc<str>> {
self.reader.content_type()
}
fn buffered(&self) -> Vec<std::ops::Range<u64>> {
self.reader.buffered()
}
fn read_at(&self, offset: u64, buf: &mut [u8]) -> std::io::Result<usize> {
use std::sync::atomic::Ordering;
let there = self.reader.buffered().iter().any(|range| range.contains(&offset));
let shared = self.shared.upgrade();
if !there && let Some(shared) = &shared {
shared.reads_waiting.fetch_add(1, Ordering::AcqRel);
}
let read = self.reader.read_at(offset, buf);
if !there && let Some(shared) = &shared {
shared.reads_waiting.fetch_sub(1, Ordering::AcqRel);
}
read.map_err(|error| {
let why = LoadError::from(error);
if let Some(shared) = &shared {
*shared
.read_failed
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner()) = Some(why.clone());
}
std::io::Error::other(why)
})
}
}
enum Asked {
Opened(Opened),
Kept {
path: std::path::PathBuf,
key: u64,
disk: MediaDiskCache,
},
Load {
load: Load,
key: u64,
address: Arc<str>,
disk: MediaDiskCache,
loader: Loader,
source: Source,
},
Stream {
loader: Loader,
source: Source,
address: Arc<str>,
},
}
fn loaded(shared: &Arc<Shared>, load: &Load) -> Option<Result<Arc<[u8]>, LoadError>> {
load.wake_with({
let shared = shared.clone();
Arc::new(move || shared.told.notify_all())
});
loop {
match load.state() {
LoadState::Ready(bytes) => return Some(Ok(bytes)),
LoadState::Failed(error) => return Some(Err(error)),
LoadState::Loading { .. } => {}
}
if shared.closed(Duration::from_millis(50)) {
return None;
}
}
}
fn settle(shared: &Arc<Shared>, asked: Asked) -> Option<(Opened, Option<(MediaDiskCache, u64)>)> {
match asked {
Asked::Opened(opened) => Some((opened, None)),
Asked::Kept { path, key, disk } => Some((Opened::File(path), Some((disk, key)))),
Asked::Load {
load,
key,
address,
disk,
loader,
source,
} => match loaded(shared, &load)? {
Ok(bytes) => Some(match disk.put(key, &address, &bytes) {
Some(path) => (Opened::File(path), Some((disk, key))),
None => {
sound_cache().put(key, bytes.clone());
(Opened::Bytes(bytes, Some(address)), None)
}
}),
Err(LoadError::TooLarge { .. } | LoadError::Unsupported(_)) => {
Some((stream(shared, &loader, &source, address)?, None))
}
Err(error) => {
shared.fail(load_failed(error));
None
}
},
Asked::Stream {
loader,
source,
address,
} => Some((stream(shared, &loader, &source, address)?, None)),
}
}
#[cfg_attr(not(any(windows, target_os = "macos", target_os = "ios")), allow(dead_code))]
fn live(shared: &Arc<Shared>, asked: Asked, heard: bool, run: impl FnOnce(&Arc<Shared>, Opened, bool)) {
let Some((opened, kept)) = settle(shared, asked) else {
return;
};
shared.whole.store(
matches!(opened, Opened::File(_) | Opened::Bytes(..)),
std::sync::atomic::Ordering::Release,
);
run(shared, opened, heard);
if let Some((disk, key)) = kept
&& shared.inner().error.is_some()
{
disk.forget_key(key);
}
}
impl Media {
pub fn open(loader: &Loader, source: &Source) -> Self {
Self::start_from(loader, source, false)
}
pub fn sound(loader: &Loader, source: &Source) -> Self {
Self::start_from(loader, source, true)
}
fn of(shared: Arc<Shared>) -> Self {
Self(Arc::new(Handle { shared }))
}
fn start_from(loader: &Loader, source: &Source, heard: bool) -> Self {
let shared = Shared::new();
if driven::take(&shared) {
return Self::of(shared);
}
let asked = match &source.kind {
SourceKind::File(path) => Ok(Asked::Opened(Opened::File(path.clone()))),
SourceKind::Resource(resource) => Ok(Asked::Opened(Opened::File(loader.resource_path(resource)))),
SourceKind::Bytes(bytes) => Ok(Asked::Opened(Opened::Bytes(bytes.clone(), None))),
SourceKind::Url(address) if !loader.allows(address) => Err(MediaError::Denied),
#[cfg(not(target_arch = "wasm32"))]
SourceKind::Url(address) if heard => {
let (key, disk) = (source.cache_key(), loader.media_disk_cache());
sound_cache().follow(disk);
Ok(if let Some(path) = disk.file(key) {
Asked::Kept {
path,
key,
disk: disk.clone(),
}
} else if let Some(bytes) = sound_cache().get(key) {
Asked::Opened(Opened::Bytes(bytes, Some(address.clone())))
} else {
Asked::Load {
load: loader.load(source),
key,
address: address.clone(),
disk: disk.clone(),
loader: loader.clone(),
source: source.clone(),
}
})
}
SourceKind::Url(address) => Ok(Asked::Stream {
loader: loader.clone(),
source: source.clone(),
address: address.clone(),
}),
};
match asked {
Ok(asked) => Self::start(&shared, asked, heard),
Err(why) => shared.fail(why),
}
Self::of(shared)
}
#[cfg(windows)]
fn start(shared: &Arc<Shared>, asked: Asked, heard: bool) {
let thread = shared.clone();
let spawned = std::thread::Builder::new()
.name("lurq-media".to_owned())
.spawn(move || live(&thread, asked, heard, mf::run));
if spawned.is_err() {
shared.fail(MediaError::Other(Arc::from(
"a thread to decode on could not be started",
)));
}
}
#[cfg(any(target_os = "macos", target_os = "ios"))]
fn start(shared: &Arc<Shared>, asked: Asked, heard: bool) {
let thread = shared.clone();
let spawned = std::thread::Builder::new()
.name("lurq-media".to_owned())
.spawn(move || live(&thread, asked, heard, apple::run));
if spawned.is_err() {
shared.fail(MediaError::Other(Arc::from("a thread to play on could not be started")));
}
}
#[cfg(target_arch = "wasm32")]
fn start(shared: &Arc<Shared>, asked: Asked, heard: bool) {
let opened = match asked {
Asked::Opened(opened) => opened,
Asked::Kept { path, .. } => Opened::File(path),
Asked::Load {
loader,
source,
address,
..
}
| Asked::Stream {
loader,
source,
address,
} => Opened::Url(address, Arc::from(loader.headers_of(&source))),
};
web::start(shared, opened, heard);
}
#[cfg(not(any(windows, target_os = "macos", target_os = "ios", target_arch = "wasm32")))]
fn start(shared: &Arc<Shared>, _: Asked, _: bool) {
shared.fail(MediaError::Unavailable(Arc::from(
"this build has no decoder for this system yet",
)));
}
fn shared(&self) -> &Shared {
&self.0.shared
}
fn buffered(&self, duration: f64, position: f64) -> Option<f64> {
let shared = self.shared();
if shared.whole.load(std::sync::atomic::Ordering::Acquire) {
return Some(duration);
}
let stream = shared
.stream
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.clone()?;
Some(fetched_to(position, duration, stream.len()?, &stream.buffered()))
}
pub fn state(&self) -> MediaState {
let (mut state, opened, fetched) = {
let inner = self.shared().inner();
let state = MediaState {
duration: inner.duration,
position: inner.position(),
buffered: None,
size: inner.size,
sound: inner.sound,
volume: inner.volume,
muted: inner.muted,
playing: inner.playing,
waiting: inner.waiting,
ended: inner.ended,
error: inner.error.clone(),
rate: inner.rate,
};
(state, inner.opened, inner.fetched)
};
state.buffered = fetched.or_else(|| {
let duration = state.duration.filter(|_| opened)?;
self.buffered(duration, state.position)
});
state
}
pub fn frame(&self) -> Option<ImageData> {
self.shared().inner().frame.clone()
}
pub fn play(&self) {
let shared = self.shared();
shared.eager.store(true, std::sync::atomic::Ordering::Release);
let stream = shared
.stream
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.clone();
if let Some(stream) = stream {
stream.read_ahead(true);
}
shared.tell(Command::Play);
}
pub fn pause(&self) {
{
let mut inner = self.shared().inner();
inner.hold();
inner.playing = false;
}
self.shared().noted();
self.shared().tell(Command::Pause);
}
pub fn seek(&self, seconds: f64) {
if !seconds.is_finite() {
return;
}
let to = {
let mut inner = self.shared().inner();
let to = match inner.duration {
Some(duration) => seconds.clamp(0.0, duration),
None => seconds.max(0.0),
};
inner.at = to;
inner.since = Instant::now();
inner.ended = false;
inner.sent += 1;
to
};
self.shared().noted();
self.shared().tell(Command::Seek(to));
}
pub fn set_rate(&self, rate: f64) {
if rate.is_finite() && rate > 0.0 {
self.shared().tell(Command::Rate(rate));
}
}
pub fn set_volume(&self, volume: f32) {
if volume.is_finite() {
let volume = volume.clamp(0.0, 1.0);
self.shared().inner().volume = volume;
self.shared().tell(Command::Volume(volume));
}
}
pub fn set_muted(&self, muted: bool) {
self.shared().inner().muted = muted;
self.shared().tell(Command::Muted(muted));
}
pub fn is_open(&self) -> bool {
self.shared().inner().opened
}
pub fn has_frame(&self) -> bool {
let inner = self.shared().inner();
inner.size.is_some() && inner.presented > 0
}
pub fn set_looped(&self, looped: bool) {
self.shared().inner().looped = looped;
self.shared().told.notify_all();
}
pub fn looped(&self) -> bool {
self.shared().inner().looped
}
pub fn on_change(&self, wake: impl Fn() + Send + Sync + 'static) {
self
.shared()
.wakers
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.push(Arc::new(wake));
}
pub fn on_load(&self, handler: impl Fn(&MediaInfo) + Send + Sync + 'static) {
self.listening().handlers().load.push(Arc::new(handler));
}
pub fn on_error(&self, handler: impl Fn(&MediaError) + Send + Sync + 'static) {
self.listening().handlers().error.push(Arc::new(handler));
}
pub fn on_ended(&self, handler: impl Fn() + Send + Sync + 'static) {
self.listening().handlers().ended.push(Arc::new(handler));
}
pub fn on_started(&self, handler: impl Fn() + Send + Sync + 'static) {
self.listening().handlers().started.push(Arc::new(handler));
}
pub fn on_playing_change(&self, handler: impl Fn(bool) + Send + Sync + 'static) {
self.listening().handlers().playing.push(Arc::new(handler));
}
pub fn on_waiting_change(&self, handler: impl Fn(bool) + Send + Sync + 'static) {
self.listening().handlers().waiting.push(Arc::new(handler));
}
fn listening(&self) -> &Arc<events::Listening> {
events::Listening::of(&self.0.shared)
}
}
#[cfg(test)]
mod tests {
use std::sync::atomic::Ordering;
use super::*;
const MIB: u64 = 1 << 20;
#[test]
fn how_far_it_is_fetched_is_the_end_of_the_ranges_held_in_a_row_from_where_it_is() {
let (long, len) = (100.0, 100 * MIB);
let to = |position: f64, held: &[std::ops::Range<u64>]| fetched_to(position, long, len, held);
assert_eq!(to(0.0, &[0..10 * MIB]), 10.0);
assert_eq!(to(5.0, &[0..10 * MIB]), 10.0, "from anywhere in the range");
assert_eq!(
to(0.0, &[0..10 * MIB, 10 * MIB..20 * MIB]),
20.0,
"ranges that touch are one"
);
let apart = [0..MIB, 50 * MIB..60 * MIB];
assert_eq!(to(0.0, &apart), 1.0);
assert_eq!(to(50.0, &apart), 60.0);
assert_eq!(to(30.0, &apart), 30.0, "sent to a part that is not fetched");
assert_eq!(
to(49.0, &apart),
60.0,
"a range that begins a little after its share holds it"
);
assert_eq!(
to(90.0, &[80 * MIB..len]),
long,
"to the end of its bytes is its whole length"
);
assert_eq!(to(7.0, &[]), 7.0);
assert_eq!(fetched_to(3.0, 0.0, len, &[0..len]), 3.0, "of no length");
}
fn opened() -> Arc<Shared> {
let shared = Shared::new();
shared.inner().opened = true;
shared.inner().waiting = false;
shared
}
fn after(millis: u64) {
std::thread::sleep(std::time::Duration::from_millis(millis));
}
#[test]
fn a_read_ahead_on_the_network_while_there_is_something_to_show_is_no_waiting() {
let shared = opened();
watch_for_starving(&shared);
shared.reads_waiting.fetch_add(1, Ordering::AcqRel);
after(400);
assert!(!shared.inner().waiting);
shared.reads_waiting.fetch_sub(1, Ordering::AcqRel);
let decoding = shared.decoding();
after(400);
assert!(!shared.inner().waiting);
drop(decoding);
}
#[test]
fn waiting_for_the_next_sample_while_its_read_is_on_the_network_is_waiting_after_a_moment() {
let shared = opened();
watch_for_starving(&shared);
shared.reads_waiting.fetch_add(1, Ordering::AcqRel);
let decoding = shared.decoding();
after(100);
assert!(!shared.inner().waiting, "a block that comes at once shows nothing");
after(400);
assert!(shared.inner().waiting, "starved, it waits");
shared.reads_waiting.fetch_sub(1, Ordering::AcqRel);
drop(decoding);
assert!(!shared.inner().waiting, "and goes on as the sample comes");
}
}