use std::{
sync::Arc,
time::{Duration, Instant},
};
use objc2::{
AnyThread,
rc::{Retained, autoreleasepool},
};
use objc2_avf_audio::AVAudioPlayer;
use objc2_foundation::{NSData, NSError, NSURL};
use super::{Command, MediaError, Opened, Shared};
mod video;
const STEP: Duration = Duration::from_millis(20);
const APART: f64 = 0.03;
const STARTING: Duration = Duration::from_millis(500);
const INTERRUPTED: Duration = Duration::from_millis(250);
pub(super) fn run(shared: &Arc<Shared>, opened: Opened, heard: bool) {
if !heard || matches!(opened, Opened::Url(..)) {
return video::run(shared, opened, !heard);
}
autoreleasepool(|_| match open(opened) {
Ok(player) => play(shared, &player),
Err(why) => shared.fail(why),
});
}
fn failed(error: &NSError) -> MediaError {
const UNSUPPORTED: [isize; 3] = [0x7479_703F, 0x666D_743F, 0x6474_613F];
if UNSUPPORTED.contains(&error.code()) {
MediaError::Unsupported
} else {
MediaError::Other(Arc::from(error.localizedDescription().to_string()))
}
}
fn open(opened: Opened) -> Result<Retained<AVAudioPlayer>, MediaError> {
let player = unsafe {
match opened {
Opened::File(path) => {
let address = NSURL::from_file_path(&path).ok_or(MediaError::NotFound)?;
AVAudioPlayer::initWithContentsOfURL_error(AVAudioPlayer::alloc(), &address)
}
Opened::Bytes(bytes, _) => AVAudioPlayer::initWithData_error(AVAudioPlayer::alloc(), &NSData::with_bytes(&bytes)),
Opened::Url(..) | Opened::Reader(..) => return Err(MediaError::Unsupported),
}
}
.map_err(|error| failed(&error))?;
unsafe {
player.setEnableRate(true);
player.prepareToPlay();
}
Ok(player)
}
fn play(shared: &Shared, player: &AVAudioPlayer) {
unsafe {
let duration = Some(player.duration()).filter(|duration| duration.is_finite() && *duration > 0.0);
let (mut volume, mut muted) = {
let mut inner = shared.inner();
inner.duration = duration;
inner.sound = true;
inner.opened = true;
inner.waiting = false;
inner.since = Instant::now();
(inner.volume, inner.muted)
};
let level = |volume: f32, muted: bool| if muted { 0.0 } else { volume };
player.setVolume(level(volume, muted));
shared.wake();
let mut gone = 0_u64;
let mut starting: Option<Instant> = None;
let mut interrupted: Option<u64> = None;
loop {
let playing = shared.inner().playing;
let wait = match (playing, interrupted) {
(true, _) => STEP,
(false, Some(_)) => INTERRUPTED,
(false, None) => Duration::from_secs(3600),
};
let mut commands = shared.take(Some(wait));
if !commands.is_empty() {
interrupted = None;
} else if interrupted.is_some_and(|then| super::session::resumes() > then) {
interrupted = None;
commands.push(Command::Play);
}
for command in commands {
match command {
Command::Close => {
player.stop();
return;
}
Command::Play => {
let mut inner = shared.inner();
if inner.ended {
player.setCurrentTime(0.0);
inner.ended = false;
inner.at = 0.0;
}
player.setRate(inner.rate as f32);
if player.play() {
inner.since = Instant::now();
inner.playing = true;
starting = Some(Instant::now());
drop(inner);
shared.wake();
} else {
drop(inner);
shared.fail(MediaError::Other(Arc::from("the system's output would not start")));
return;
}
}
Command::Pause => {
player.pause();
let mut inner = shared.inner();
player.setCurrentTime(inner.at);
inner.since = Instant::now();
inner.playing = false;
starting = None;
}
Command::Seek(to) => {
gone += 1;
let to = duration.map_or(to, |duration| to.min(duration));
player.setCurrentTime(to);
let mut inner = shared.inner();
inner.at = to;
inner.since = Instant::now();
inner.ended = false;
}
Command::Rate(rate) => {
let mut inner = shared.inner();
inner.hold();
inner.rate = rate;
player.setRate(rate as f32);
}
Command::Volume(to) => {
volume = to;
player.setVolume(level(volume, muted));
}
Command::Muted(to) => {
muted = to;
player.setVolume(level(volume, muted));
}
}
}
let mut inner = shared.inner();
if !inner.playing {
continue;
}
if !player.isPlaying() && starting.is_some_and(|told| told.elapsed() < STARTING) {
continue;
}
if player.isPlaying() {
starting = None;
shared.presented_in(&mut inner);
let heard = player.currentTime();
if inner.sent == gone && (heard - inner.position()).abs() > APART {
inner.at = heard;
inner.since = Instant::now();
}
} else {
let at = player.currentTime();
let clock = inner.position();
let over = duration.is_none_or(|duration| at <= 0.05 || at.max(clock) >= duration - 0.3);
if over && inner.looped {
player.setCurrentTime(0.0);
player.play();
inner.at = 0.0;
inner.rounds += 1;
inner.since = Instant::now();
starting = Some(Instant::now());
continue;
}
inner.at = match (over, inner.duration) {
(true, Some(duration)) => duration,
_ => at,
};
inner.since = Instant::now();
inner.ended = over;
inner.playing = false;
drop(inner);
if !over {
interrupted = Some(super::session::resumes());
}
shared.wake();
}
}
}
}