#[cfg(not(target_arch = "wasm32"))]
use std::path::Path;
#[cfg(target_arch = "wasm32")]
use std::sync::Mutex;
use std::{
collections::VecDeque,
ops::Range,
sync::{
Arc,
atomic::{AtomicBool, Ordering},
},
time::Duration,
};
use dasp_sample::FromSample;
use rodio::{Player, Source};
use crate::{
PlaybackRangeSource, SoundAsset, SoundEffects, SoundSource, SoundscapeError, decoder,
format_timestamp, scene::SoundGroupId, wsola::Wsola,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PlaybackState {
Idle,
Loading,
Playing,
Paused,
Ended,
Failed,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PlaybackEvent {
StateChanged {
previous: PlaybackState,
current: PlaybackState,
},
}
pub struct SoundNode {
pub(crate) name: String,
pub(crate) group: SoundGroupId,
pub(crate) source: SoundSource,
pub(crate) source_revision: u64,
pub(crate) source_loaded: bool,
pub(crate) wants_playing: bool,
pub(crate) locally_paused: bool,
mixer: rodio::mixer::Mixer,
voice: Player,
duration: Option<Duration>,
position_offset: Duration,
player_position_anchor: Duration,
speed: f32,
preserve_pitch: bool,
volume: f32,
effects: SoundEffects,
looping: Arc<AtomicBool>,
loop_range: Option<Range<Duration>>,
position_is_held: bool,
playback_state: PlaybackState,
playback_events: VecDeque<PlaybackEvent>,
scene_events: VecDeque<PlaybackEvent>,
event_capacity: usize,
#[cfg(target_arch = "wasm32")]
pending_playback: Option<PendingPlayback>,
}
#[cfg(target_arch = "wasm32")]
type PendingPlayback = Arc<Mutex<Option<Result<Arc<[u8]>, SoundscapeError>>>>;
#[derive(Clone, Copy)]
enum SourceMetadata {
Unloaded,
Loaded(Option<Duration>),
}
impl SoundNode {
pub(crate) fn new(
name: String,
group: SoundGroupId,
source: SoundSource,
mixer: rodio::mixer::Mixer,
) -> Result<Self, SoundscapeError> {
let voice = Player::connect_new(&mixer);
let mut sound = Self {
name,
group,
source,
source_revision: 0,
source_loaded: false,
wants_playing: false,
locally_paused: false,
mixer,
voice,
duration: None,
position_offset: Duration::ZERO,
player_position_anchor: Duration::ZERO,
speed: 1.0,
preserve_pitch: false,
volume: 1.0,
effects: SoundEffects::default(),
looping: Arc::new(AtomicBool::new(false)),
loop_range: None,
position_is_held: true,
playback_state: PlaybackState::Idle,
playback_events: VecDeque::new(),
scene_events: VecDeque::new(),
event_capacity: usize::MAX,
#[cfg(target_arch = "wasm32")]
pending_playback: None,
};
sound.source_loaded = sound.load_source()?;
Ok(sound)
}
fn connect_voice(&self) -> Player {
Player::connect_new(&self.mixer)
}
fn has_current_source(&self) -> bool {
self.source_loaded
}
pub(crate) fn replace_routing_preserving_playback(&mut self, mixer: rodio::mixer::Mixer) {
let position = self.position();
let was_playing = self.is_playing();
let was_paused = self.is_paused();
let has_source = self.has_current_source();
self.mixer = mixer;
if (was_playing || was_paused) && has_source {
if self.try_seek(position).is_err() {
self.voice = self.connect_voice();
self.voice.set_volume(self.volume());
self.voice.set_speed(self.player_speed());
self.position_offset = position;
self.player_position_anchor = Duration::ZERO;
self.position_is_held = true;
}
return;
}
self.voice = self.connect_voice();
self.voice.set_volume(self.volume());
self.voice.set_speed(self.player_speed());
}
pub(crate) fn load_source(&mut self) -> Result<bool, SoundscapeError> {
let metadata = Self::source_metadata(&self.source.clone())
.map_err(|error| self.record_failure(error))?;
match metadata {
SourceMetadata::Unloaded => {
self.reset_loaded_source(None);
Ok(false)
}
SourceMetadata::Loaded(duration) => {
self.reset_loaded_source(duration);
Ok(true)
}
}
}
pub(crate) fn replace_source(&mut self, source: SoundSource) -> Result<(), SoundscapeError> {
if self.source.same_resource(&source) {
return Ok(());
}
let metadata = Self::source_metadata(&source)?;
let position = self.position();
let previous_state = self.state();
let was_playing = previous_state == PlaybackState::Playing;
let was_paused = previous_state == PlaybackState::Paused;
let was_locally_paused = self.locally_paused;
self.cancel_pending_playback();
self.source = source;
self.source_revision = self.source_revision.wrapping_add(1);
let (source_loaded, duration) = match metadata {
SourceMetadata::Unloaded => (false, None),
SourceMetadata::Loaded(duration) => (true, duration),
};
let wants_playing = was_playing || was_paused;
self.source_loaded = source_loaded;
self.reset_loaded_source(duration);
let position = duration.map_or(position, |duration| position.min(duration));
self.position_offset = position;
if source_loaded && wants_playing {
self.play_current_source_at(position)?;
if was_paused {
self.pause();
}
}
self.wants_playing = wants_playing;
self.locally_paused = was_locally_paused;
#[cfg(target_arch = "wasm32")]
if !source_loaded
&& wants_playing
&& let SoundSource::Asset(asset) = self.source.clone()
{
self.start_asset_playback(&asset)?;
}
Ok(())
}
fn source_metadata(source: &SoundSource) -> Result<SourceMetadata, SoundscapeError> {
let duration = match source {
SoundSource::Empty => return Ok(SourceMetadata::Unloaded),
SoundSource::StaticBytes(bytes) => decoder::from_static_bytes(bytes)?.total_duration(),
SoundSource::SharedBytes(bytes) => {
decoder::from_shared_bytes(bytes.clone())?.total_duration()
}
#[cfg(not(target_arch = "wasm32"))]
SoundSource::File(path) => decoder::from_file(path)?.total_duration(),
SoundSource::Asset(asset) => {
#[cfg(not(target_arch = "wasm32"))]
{
decoder::from_file(asset.native_path())?.total_duration()
}
#[cfg(target_arch = "wasm32")]
{
let Some(bytes) = asset.cached_browser_bytes() else {
return Ok(SourceMetadata::Unloaded);
};
decoder::from_shared_bytes(bytes)?.total_duration()
}
}
};
Ok(SourceMetadata::Loaded(duration))
}
fn play_source<S>(&mut self, source: S) -> Result<(), SoundscapeError>
where
S: Source + Send + 'static,
f32: FromSample<S::Item>,
{
self.play_source_at(source, None)
}
fn play_source_at<S>(
&mut self,
source: S,
requested_position: Option<Duration>,
) -> Result<(), SoundscapeError>
where
S: Source + Send + 'static,
f32: FromSample<S::Item>,
{
self.queue_source_at(source, requested_position, true)
}
fn queue_source_at<S>(
&mut self,
mut source: S,
requested_position: Option<Duration>,
autoplay: bool,
) -> Result<(), SoundscapeError>
where
S: Source + Send + 'static,
f32: FromSample<S::Item>,
{
let duration = source.total_duration();
let (range_start, range_end) = self
.playback_bounds(duration)
.map_err(|error| self.record_failure(error))?;
let position = if let Some(position) = requested_position {
position
} else if self.is_empty() {
match source.total_duration() {
Some(duration) => self.position_offset.min(duration),
None => self.position_offset,
}
} else {
Duration::ZERO
};
let position = range_end.map_or(position.max(range_start), |end| {
position.clamp(range_start, end)
});
if !position.is_zero() {
source
.try_seek(position)
.map_err(SoundscapeError::Seek)
.map_err(|error| self.record_failure(error))?;
}
let source = PlaybackRangeSource::new(
source,
range_start,
range_end,
position,
self.looping.clone(),
);
let source = self.process_source(source);
self.position_offset = position;
self.player_position_anchor = Duration::ZERO;
self.position_is_held = true;
self.duration = duration;
let new_player = self.connect_voice();
let volume = self.volume();
new_player.set_volume(volume);
new_player.set_speed(self.player_speed());
if !autoplay {
new_player.pause();
}
new_player.append(source);
if autoplay {
new_player.play();
}
self.voice = new_player;
self.position_offset = position;
self.player_position_anchor = Duration::ZERO;
self.position_is_held = false;
if autoplay {
self.set_playback_state(PlaybackState::Playing);
}
Ok(())
}
fn play_current_source_at(&mut self, position: Duration) -> Result<(), SoundscapeError> {
match self.source.clone() {
SoundSource::Empty => Err(self.record_failure(SoundscapeError::NoAudioSource)),
SoundSource::StaticBytes(bytes) => {
let source = decoder::from_static_bytes(bytes)
.map_err(|error| self.record_failure(error))?;
self.play_source_at(source, Some(position))
}
SoundSource::SharedBytes(bytes) => {
let source = decoder::from_shared_bytes(bytes)
.map_err(|error| self.record_failure(error))?;
self.play_source_at(source, Some(position))
}
#[cfg(not(target_arch = "wasm32"))]
SoundSource::File(path) => {
let source =
decoder::from_file(path).map_err(|error| self.record_failure(error))?;
self.play_source_at(source, Some(position))
}
SoundSource::Asset(asset) => {
#[cfg(not(target_arch = "wasm32"))]
let source = decoder::from_file(asset.native_path())
.map_err(|error| self.record_failure(error))?;
#[cfg(target_arch = "wasm32")]
let source = decoder::from_shared_bytes(
asset
.cached_browser_bytes()
.ok_or_else(|| self.record_failure(SoundscapeError::NoAudioSource))?,
)
.map_err(|error| self.record_failure(error))?;
self.play_source_at(source, Some(position))
}
}
}
fn playback_bounds(
&self,
duration: Option<Duration>,
) -> Result<(Duration, Option<Duration>), SoundscapeError> {
let Some(range) = self.loop_range.as_ref() else {
return Ok((Duration::ZERO, duration));
};
let end = duration.map_or(range.end, |duration| range.end.min(duration));
if range.start >= end {
return Err(SoundscapeError::InvalidPlaybackRange);
}
Ok((range.start, Some(end)))
}
fn process_source<S>(&self, source: S) -> Box<dyn Source<Item = f32> + Send>
where
S: Source + Send + 'static,
f32: FromSample<S::Item>,
{
let source = self.effects.apply(source);
if self.preserve_pitch {
Box::new(Wsola::new(source, self.speed))
} else {
source
}
}
fn player_speed(&self) -> f32 {
if self.preserve_pitch { 1.0 } else { self.speed }
}
fn reset_loaded_source(&mut self, duration: Option<Duration>) {
self.voice.stop();
self.position_offset = Duration::ZERO;
self.player_position_anchor = Duration::ZERO;
self.position_is_held = true;
self.duration = duration;
self.set_playback_state(PlaybackState::Idle);
}
#[cfg(target_arch = "wasm32")]
pub(crate) fn load_resolved_bytes(&mut self, bytes: Arc<[u8]>) -> Result<(), SoundscapeError> {
let duration = decoder::from_shared_bytes(bytes)
.map_err(|error| self.record_failure(error))?
.total_duration();
self.reset_loaded_source(duration);
Ok(())
}
#[cfg(not(target_arch = "wasm32"))]
pub fn play_file(&mut self, path: impl AsRef<Path>) -> Result<(), SoundscapeError> {
let path = path.as_ref().to_path_buf();
let source = decoder::from_file(&path).map_err(|error| self.record_failure(error))?;
self.play_source(source)?;
Ok(())
}
pub fn start_asset_playback(&mut self, asset: &SoundAsset) -> Result<(), SoundscapeError> {
#[cfg(not(target_arch = "wasm32"))]
{
self.play_file(asset.native_path())
}
#[cfg(target_arch = "wasm32")]
{
if self.pending_playback.is_some() {
return Ok(());
}
if let Some(bytes) = asset.cached_browser_bytes() {
let source = decoder::from_shared_bytes(bytes.clone())
.map_err(|error| self.record_failure(error))?;
self.play_source(source)?;
return Ok(());
}
let pending_playback = PendingPlayback::default();
let pending_result = pending_playback.clone();
let asset = asset.clone();
wasm_bindgen_futures::spawn_local(async move {
*pending_result.lock().unwrap() = Some(asset.load_browser_bytes().await);
});
self.pending_playback = Some(pending_playback);
self.set_playback_state(PlaybackState::Loading);
Ok(())
}
}
pub fn poll_pending_playback(&mut self) -> Option<Result<(), SoundscapeError>> {
#[cfg(not(target_arch = "wasm32"))]
{
None
}
#[cfg(target_arch = "wasm32")]
{
let result = self.pending_playback.as_ref()?.lock().unwrap().take()?;
self.pending_playback = None;
let result = result.and_then(|bytes| {
let source = decoder::from_shared_bytes(bytes.clone())?;
self.play_source(source)?;
Ok(())
});
if result.is_err() {
self.set_playback_state(PlaybackState::Failed);
}
Some(result)
}
}
pub(crate) fn cancel_pending_playback(&mut self) {
#[cfg(target_arch = "wasm32")]
{
self.pending_playback = None;
}
}
pub fn state(&mut self) -> PlaybackState {
self.refresh_playback_state();
self.playback_state
}
pub fn poll_event(&mut self) -> Option<PlaybackEvent> {
self.refresh_playback_state();
self.playback_events.pop_front()
}
pub(crate) fn poll_scene_event(&mut self) -> Option<PlaybackEvent> {
self.refresh_playback_state();
self.scene_events.pop_front()
}
pub(crate) fn set_event_capacity(&mut self, capacity: usize) {
self.event_capacity = capacity;
while self.playback_events.len() > capacity {
self.playback_events.pop_front();
}
}
fn refresh_playback_state(&mut self) {
let state = self.playback_state;
if matches!(state, PlaybackState::Playing | PlaybackState::Paused) && self.voice.empty() {
self.set_playback_state(PlaybackState::Ended);
}
}
fn set_playback_state(&mut self, state: PlaybackState) {
if self.playback_state == state {
return;
}
let previous = self.playback_state;
self.playback_state = state;
let event = PlaybackEvent::StateChanged {
previous,
current: state,
};
self.scene_events.push_back(event);
if self.event_capacity > 0 {
if self.playback_events.len() >= self.event_capacity {
self.playback_events.pop_front();
}
self.playback_events.push_back(event);
}
}
fn record_failure(&mut self, error: SoundscapeError) -> SoundscapeError {
self.set_playback_state(PlaybackState::Failed);
error
}
pub fn is_loading(&mut self) -> bool {
self.state() == PlaybackState::Loading
}
pub fn try_seek_secs(&mut self, position_secs: f64) -> Result<(), SoundscapeError> {
if position_secs.is_nan() || position_secs.is_infinite() || position_secs < 0.0 {
return Err(self.record_failure(SoundscapeError::InvalidSeekPosition));
}
self.try_seek(Duration::from_secs_f64(position_secs))
}
pub fn try_seek_without_decoding(&mut self, position: Duration) -> Result<(), SoundscapeError> {
if self.set_position_if_empty(position) {
return Ok(());
}
let player_position = if self.speed.is_finite() && self.speed > 0.0 {
position.div_f32(self.speed)
} else {
position
};
self.voice
.try_seek(player_position)
.map_err(SoundscapeError::Seek)
.map_err(|error| self.record_failure(error))?;
self.position_offset = position;
self.player_position_anchor = player_position;
self.position_is_held = false;
Ok(())
}
pub fn try_seek(&mut self, position: Duration) -> Result<(), SoundscapeError> {
if self.set_position_if_empty(position) {
return Ok(());
}
let position = match self.duration() {
Some(duration) => position.min(duration),
None => position,
};
match self.source.clone() {
SoundSource::Empty => Err(SoundscapeError::NoAudioSource),
SoundSource::StaticBytes(bytes) => {
self.seek_with_decode_source(decoder::from_static_bytes(bytes)?, position)
}
SoundSource::SharedBytes(bytes) => {
self.seek_with_decode_source(decoder::from_shared_bytes(bytes)?, position)
}
#[cfg(not(target_arch = "wasm32"))]
SoundSource::File(path) => {
self.seek_with_decode_source(decoder::from_file(path)?, position)
}
SoundSource::Asset(asset) => {
#[cfg(not(target_arch = "wasm32"))]
let source = decoder::from_file(asset.native_path())?;
#[cfg(target_arch = "wasm32")]
let source = decoder::from_shared_bytes(
asset
.cached_browser_bytes()
.ok_or(SoundscapeError::NoAudioSource)?,
)?;
self.seek_with_decode_source(source, position)
}
}
}
fn set_position_if_empty(&mut self, position: Duration) -> bool {
if !self.is_empty() {
return false;
}
let position = match self.duration() {
Some(duration) => position.min(duration),
None => position,
};
let volume = self.volume();
let was_paused = self.is_paused();
let new_player = self.connect_voice();
new_player.set_volume(volume);
new_player.set_speed(self.player_speed());
if was_paused {
new_player.pause();
}
self.voice = new_player;
self.position_offset = position;
self.player_position_anchor = Duration::ZERO;
self.position_is_held = true;
if self.playback_state == PlaybackState::Ended {
self.set_playback_state(PlaybackState::Idle);
}
true
}
fn seek_with_decode_source<S>(
&mut self,
mut source: S,
position: Duration,
) -> Result<(), SoundscapeError>
where
S: Source + Send + 'static,
f32: FromSample<S::Item>,
{
let was_paused = self.voice.is_paused();
let (range_start, range_end) = self
.playback_bounds(source.total_duration())
.map_err(|error| self.record_failure(error))?;
let position = range_end.map_or(position.max(range_start), |end| {
position.clamp(range_start, end)
});
source
.try_seek(position)
.map_err(SoundscapeError::Seek)
.map_err(|error| self.record_failure(error))?;
let source = PlaybackRangeSource::new(
source,
range_start,
range_end,
position,
self.looping.clone(),
);
let source = self.process_source(source);
let volume = self.volume();
let (new_player, output) = Player::new();
new_player.set_volume(volume);
new_player.set_speed(self.player_speed());
if was_paused {
new_player.pause();
}
new_player.append(source);
if !was_paused {
new_player.play();
}
self.mixer.add(output);
self.voice = new_player;
self.position_offset = position;
self.player_position_anchor = Duration::ZERO;
self.position_is_held = false;
Ok(())
}
pub fn effects(&self) -> SoundEffects {
self.effects
}
pub fn set_effects(&mut self, effects: SoundEffects) -> Result<(), SoundscapeError> {
effects.validate()?;
if effects == self.effects {
return Ok(());
}
if self.is_empty() {
self.effects = effects;
return Ok(());
}
let position = self.position();
let previous_effects = std::mem::replace(&mut self.effects, effects);
let result = self.try_seek(position);
if result.is_err() {
self.effects = previous_effects;
}
result
}
pub fn position(&self) -> Duration {
let player_position = if self.position_is_held {
Duration::ZERO
} else {
self.voice.get_pos()
};
self.position_at_player_time(player_position)
}
fn position_at_player_time(&self, player_position: Duration) -> Duration {
let elapsed = player_position.saturating_sub(self.player_position_anchor);
let mut position = self
.position_offset
.saturating_add(elapsed.mul_f32(self.speed));
if self.is_looping()
&& let Ok((start, Some(end))) = self.playback_bounds(self.duration())
&& position >= end
{
let range_duration = end - start;
let range_nanos = range_duration.as_nanos();
if range_nanos > 0 {
let position_nanos = position.saturating_sub(start).as_nanos() % range_nanos;
position = start
+ Duration::new(
(position_nanos / 1_000_000_000) as u64,
(position_nanos % 1_000_000_000) as u32,
);
}
}
match self.duration() {
Some(duration) => position.min(duration),
None => position,
}
}
pub fn position_formatted(&self) -> String {
format_timestamp(self.position())
}
pub fn duration(&self) -> Option<Duration> {
self.duration
}
pub fn duration_formatted(&self) -> String {
self.duration()
.map(format_timestamp)
.unwrap_or_else(|| "0:00".into())
}
pub fn clamped_position(&self) -> Duration {
self.position()
.min(self.duration().unwrap_or_default())
.max(Duration::ZERO)
}
pub fn seek_range(&self) -> std::ops::RangeInclusive<f64> {
0.0..=self.duration().unwrap_or_default().as_secs_f64().max(1.0)
}
pub fn pause(&mut self) {
self.voice.pause();
if self.state() == PlaybackState::Playing {
self.set_playback_state(PlaybackState::Paused);
}
}
pub fn resume(&mut self) {
self.voice.play();
if self.state() == PlaybackState::Paused {
self.set_playback_state(PlaybackState::Playing);
}
}
pub fn stop(&mut self) {
self.voice.stop();
self.position_offset = Duration::ZERO;
self.player_position_anchor = Duration::ZERO;
self.position_is_held = true;
self.set_playback_state(PlaybackState::Idle);
}
pub fn try_play_at(&mut self, position: Duration) -> Result<(), SoundscapeError> {
if !self.has_current_source() {
return Err(self.record_failure(SoundscapeError::NoAudioSource));
}
let duration = self.duration();
let (range_start, range_end) = self
.playback_bounds(duration)
.map_err(|error| self.record_failure(error))?;
let position = range_end.map_or(position.max(range_start), |end| {
position.clamp(range_start, end)
});
let playback_state = self.state();
if playback_state == PlaybackState::Paused && position == self.position() {
self.resume();
return Ok(());
}
if playback_state == PlaybackState::Playing || playback_state == PlaybackState::Paused {
self.try_seek(position)?;
self.resume();
return Ok(());
}
self.play_current_source_at(position)
}
pub fn set_volume(&mut self, volume: f32) {
self.volume = volume;
self.voice.set_volume(volume);
}
pub fn volume(&self) -> f32 {
self.volume
}
pub fn try_set_speed(&mut self, speed: f32) -> Result<(), SoundscapeError> {
if self.preserve_pitch && self.speed != speed && !self.is_empty() {
let position = self.position();
let previous_speed = std::mem::replace(&mut self.speed, speed);
let result = self.try_seek(position);
if result.is_err() {
self.speed = previous_speed;
}
return result;
}
if !self.position_is_held {
let player_position = self.voice.get_pos();
self.position_offset = self.position_at_player_time(player_position);
self.player_position_anchor = player_position;
}
self.speed = speed;
self.voice.set_speed(self.player_speed());
Ok(())
}
pub fn speed(&self) -> f32 {
self.speed
}
pub fn set_preserve_pitch(&mut self, preserve_pitch: bool) -> Result<(), SoundscapeError> {
if preserve_pitch == self.preserve_pitch {
return Ok(());
}
if self.is_empty() {
self.preserve_pitch = preserve_pitch;
self.voice.set_speed(self.player_speed());
return Ok(());
}
let position = self.position();
self.preserve_pitch = preserve_pitch;
let result = self.try_seek(position);
if result.is_err() {
self.preserve_pitch = !preserve_pitch;
}
result
}
pub fn preserves_pitch(&self) -> bool {
self.preserve_pitch
}
pub fn set_looping(&self, looping: bool) {
self.looping.store(looping, Ordering::Relaxed);
}
pub fn is_looping(&self) -> bool {
self.looping.load(Ordering::Relaxed)
}
pub fn set_loop_range(&mut self, range: Range<Duration>) -> Result<(), SoundscapeError> {
if range.start >= range.end {
return Err(SoundscapeError::InvalidPlaybackRange);
}
let state = self.state();
let position = self.position().clamp(range.start, range.end);
let previous_range = self.loop_range.replace(range);
if matches!(state, PlaybackState::Playing | PlaybackState::Paused)
&& let Err(error) = self.try_seek(position)
{
self.loop_range = previous_range;
return Err(error);
}
Ok(())
}
pub fn loop_range(&self) -> Option<Range<Duration>> {
self.loop_range.clone()
}
pub fn clear_loop_range(&mut self) {
self.loop_range = None;
}
pub fn is_playing(&mut self) -> bool {
self.state() == PlaybackState::Playing
}
pub fn is_paused(&mut self) -> bool {
self.state() == PlaybackState::Paused
}
pub fn is_empty(&mut self) -> bool {
!matches!(self.state(), PlaybackState::Playing | PlaybackState::Paused)
}
pub fn wait_until_end(&self) {
self.voice.sleep_until_end();
}
}