use std::{cell::RefCell, collections::HashMap, sync::Arc};
use wasm_bindgen::{JsCast, JsValue, closure::Closure};
use super::{Command, MediaError, Opened, Shared};
use crate::time::Instant;
const APART: f64 = 0.03;
struct Player {
shared: Arc<Shared>,
element: web_sys::HtmlAudioElement,
listeners: Vec<(&'static str, Closure<dyn FnMut(web_sys::Event)>)>,
blob: Option<String>,
gone: u64,
}
thread_local! {
static PLAYERS: RefCell<HashMap<usize, Player>> = RefCell::new(HashMap::new());
}
fn key(shared: &Shared) -> usize {
std::ptr::from_ref(shared) as usize
}
pub(super) fn start(shared: &Arc<Shared>, opened: Opened, heard: bool) {
if !heard {
shared.fail(MediaError::Unavailable(Arc::from(
"a browser's build plays no video yet: it waits for wgpu to take the page's frames",
)));
return;
}
let element = match web_sys::HtmlAudioElement::new() {
Ok(element) => element,
Err(_) => {
shared.fail(MediaError::Unavailable(Arc::from("the page could not make an <audio>")));
return;
}
};
element.set_preload("auto");
let (address, blob) = match opened {
Opened::Url(address, headers) => {
if !headers.is_empty() {
static SAID: std::sync::Once = std::sync::Once::new();
SAID.call_once(|| {
tracing::warn!(target: "lurq::media", "a browser plays an address without the source's headers");
});
}
(address.to_string(), None)
}
Opened::Reader(..) => {
shared.fail(MediaError::Unavailable(Arc::from(
"the page's <audio> reads an address itself",
)));
return;
}
Opened::File(path) => (path.to_string_lossy().replace('\\', "/"), None),
Opened::Bytes(bytes, _) => match blob_address(&bytes) {
Some(address) => (address.clone(), Some(address)),
None => {
shared.fail(MediaError::Other(Arc::from(
"the page could not hold the bytes as a blob",
)));
return;
}
},
};
let mut player = Player {
shared: shared.clone(),
element: element.clone(),
listeners: Vec::new(),
blob,
gone: 0,
};
for kind in [
"loadedmetadata",
"playing",
"waiting",
"pause",
"ended",
"error",
"timeupdate",
"seeked",
] {
let shared = shared.clone();
let listener = Closure::<dyn FnMut(web_sys::Event)>::new(move |_: web_sys::Event| heard_from(&shared, kind));
let _ = element.add_event_listener_with_callback(kind, listener.as_ref().unchecked_ref());
player.listeners.push((kind, listener));
}
{
let inner = shared.inner();
element.set_volume(f64::from(if inner.muted { 0.0 } else { inner.volume }));
}
element.set_src(&address);
PLAYERS.with(|players| players.borrow_mut().insert(key(shared), player));
told(shared);
}
fn blob_address(bytes: &[u8]) -> Option<String> {
let array = js_sys::Uint8Array::from(bytes);
let parts = js_sys::Array::of1(&array);
let blob = web_sys::Blob::new_with_u8_array_sequence(&parts).ok()?;
web_sys::Url::create_object_url_with_blob(&blob).ok()
}
fn heard_from(shared: &Arc<Shared>, kind: &str) {
let Some(element) = PLAYERS.with(|players| players.borrow().get(&key(shared)).map(|player| player.element.clone()))
else {
return;
};
let at = element.current_time();
let mut inner = shared.inner();
match kind {
"loadedmetadata" => {
let duration = element.duration();
inner.duration = (duration.is_finite() && duration > 0.0).then_some(duration);
inner.sound = true;
inner.opened = true;
inner.waiting = false;
}
"playing" => {
inner.waiting = false;
inner.at = at;
inner.since = Instant::now();
shared.presented_in(&mut inner);
}
"waiting" => {
inner.hold();
inner.waiting = true;
}
"pause" if inner.playing && !element.ended() => {
inner.at = at;
inner.since = Instant::now();
inner.playing = false;
}
"ended" if inner.looped => {
element.set_current_time(0.0);
let _ = element.play();
inner.at = 0.0;
inner.rounds += 1;
inner.since = Instant::now();
}
"ended" => {
inner.at = inner.duration.unwrap_or(at);
inner.since = Instant::now();
inner.playing = false;
inner.ended = true;
}
"error" => {
let why = failed(&element);
drop(inner);
shared.fail(why);
return;
}
"seeked" => {
PLAYERS.with(|players| {
if let Some(player) = players.borrow_mut().get_mut(&key(shared)) {
player.gone += 1;
}
});
return;
}
"timeupdate" => {
let gone = PLAYERS.with(|players| players.borrow().get(&key(shared)).map_or(0, |player| player.gone));
if inner.playing && !inner.waiting && inner.sent == gone && (at - inner.position()).abs() > APART {
inner.at = at;
inner.since = Instant::now();
}
if inner.playing && !inner.waiting {
shared.presented_in(&mut inner);
}
return;
}
_ => return,
}
drop(inner);
shared.wake();
}
fn failed(element: &web_sys::HtmlAudioElement) -> MediaError {
let Some(error) = element.error() else {
return MediaError::Other(Arc::from("the browser could not play it"));
};
let said: Arc<str> = Arc::from(error.message());
match error.code() {
web_sys::MediaError::MEDIA_ERR_NETWORK => MediaError::Network(said),
web_sys::MediaError::MEDIA_ERR_DECODE | web_sys::MediaError::MEDIA_ERR_SRC_NOT_SUPPORTED => MediaError::Unsupported,
_ => MediaError::Other(said),
}
}
pub(super) fn told(shared: &Shared) {
let Some((shared, element)) = PLAYERS.with(|players| {
players
.borrow()
.get(&key(shared))
.map(|player| (player.shared.clone(), player.element.clone()))
}) else {
return;
};
let shared = &shared;
for command in shared.take(None) {
match command {
Command::Close => {
close(shared);
return;
}
Command::Play => {
{
let mut inner = shared.inner();
if inner.ended {
element.set_current_time(0.0);
inner.ended = false;
inner.at = 0.0;
}
element.set_playback_rate(inner.rate);
inner.since = Instant::now();
inner.playing = true;
}
if let Ok(started) = element.play() {
let shared = shared.clone();
let refused = Closure::once(move |_: JsValue| {
{
let mut inner = shared.inner();
inner.hold();
inner.playing = false;
}
shared.wake();
});
let _ = started.catch(&refused);
refused.forget();
}
shared.wake();
}
Command::Pause => {
let _ = element.pause();
let at = shared.inner().at;
element.set_current_time(at);
}
Command::Seek(to) => {
let to = shared.inner().duration.map_or(to, |duration| to.min(duration));
element.set_current_time(to);
}
Command::Rate(rate) => {
let mut inner = shared.inner();
inner.hold();
inner.rate = rate;
element.set_playback_rate(rate);
}
Command::Volume(_) | Command::Muted(_) => {
let inner = shared.inner();
element.set_volume(f64::from(if inner.muted { 0.0 } else { inner.volume }));
}
}
}
}
fn close(shared: &Arc<Shared>) {
let Some(player) = PLAYERS.with(|players| players.borrow_mut().remove(&key(shared))) else {
return;
};
let _ = player.element.pause();
for (kind, listener) in &player.listeners {
let _ = player
.element
.remove_event_listener_with_callback(kind, listener.as_ref().unchecked_ref());
}
player.element.remove_attribute("src").ok();
player.element.load();
if let Some(blob) = &player.blob {
let _ = web_sys::Url::revoke_object_url(blob);
}
}