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, 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 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>>,
}
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 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,
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(),
})
}
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();
}
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();
inner.error = Some(why);
inner.playing = false;
inner.waiting = false;
}
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>);
#[derive(Clone)]
pub(crate) enum Opened {
File(std::path::PathBuf),
Bytes(Arc<[u8]>, Option<Arc<str>>),
Url(Arc<str>),
}
enum Asked {
Opened(Opened),
Kept {
path: std::path::PathBuf,
key: u64,
disk: MediaDiskCache,
},
Load {
load: Load,
key: u64,
address: Arc<str>,
disk: MediaDiskCache,
},
}
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,
} => 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((Opened::Url(address), None)),
Err(error) => {
shared.fail(load_failed(error));
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;
};
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(target_arch = "wasm32")]
SourceKind::Url(address) => Ok(Asked::Opened(Opened::Url(address.clone()))),
#[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(),
}
})
}
#[cfg(not(target_arch = "wasm32"))]
SourceKind::Url(address) => Ok(Asked::Opened(Opened::Url(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 { address, .. } => Opened::Url(address),
};
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
}
pub fn state(&self) -> MediaState {
let inner = self.shared().inner();
MediaState {
duration: inner.duration,
position: inner.position(),
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,
}
}
pub fn frame(&self) -> Option<ImageData> {
self.shared().inner().frame.clone()
}
pub fn play(&self) {
self.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 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_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)
}
}