use rodio::decoder::DecoderBuilder;
use rodio::{DeviceSinkBuilder, MixerDeviceSink, Player};
use std::cell::RefCell;
use std::io::{BufReader, Cursor};
use std::path::Path;
use std::sync::Arc;
use std::time::Duration;
use thiserror::Error;
thread_local! {
static ENGINE: RefCell<Option<AudioEngine>> = const { RefCell::new(None) };
}
struct AudioEngine {
_sink: MixerDeviceSink,
}
impl AudioEngine {
fn try_init() -> Result<(), AudioError> {
ENGINE.with(|e| {
if e.borrow().is_some() {
return Ok(());
}
let mut sink =
DeviceSinkBuilder::open_default_sink().map_err(|_| AudioError::NoDevice)?;
sink.log_on_drop(false);
*e.borrow_mut() = Some(AudioEngine { _sink: sink });
Ok(())
})
}
fn with_mixer<F, T>(f: F) -> Result<T, AudioError>
where
F: FnOnce(&rodio::mixer::Mixer) -> T,
{
Self::try_init()?;
ENGINE.with(|e| {
let engine = e.borrow();
let engine = engine.as_ref().ok_or(AudioError::NoDevice)?;
Ok(f(engine._sink.mixer()))
})
}
}
#[derive(Error, Debug)]
#[cfg_attr(feature = "devtools", derive(serde::Serialize, serde::Deserialize))]
pub enum AudioError {
#[error("No audio output device available")]
NoDevice,
#[error("Failed to decode audio: {0}")]
Decode(String),
#[error("IO error: {0}")]
#[cfg_attr(feature = "devtools", serde(skip))]
Io(#[from] std::io::Error),
#[error("Seek not supported")]
SeekNotSupported,
#[error("Seek error: {0}")]
Seek(String),
}
pub fn play_sound(path: impl AsRef<Path>) -> Result<(), AudioError> {
let file = std::fs::File::open(path.as_ref())?;
let source =
rodio::Decoder::new(BufReader::new(file)).map_err(|e| AudioError::Decode(e.to_string()))?;
AudioEngine::with_mixer(|mixer| mixer.add(source))
}
pub fn play_sound_bytes(data: &[u8]) -> Result<(), AudioError> {
let cursor = Cursor::new(data.to_vec());
let source = rodio::Decoder::new(cursor).map_err(|e| AudioError::Decode(e.to_string()))?;
AudioEngine::with_mixer(|mixer| mixer.add(source))
}
#[derive(Clone, Debug)]
pub struct AudioTrackMeta {
pub duration: Option<Duration>,
pub sample_rate: u32,
pub channels: u16,
}
impl AudioTrackMeta {
fn from_source(source: &impl rodio::Source) -> Self {
Self {
duration: source.total_duration(),
sample_rate: source.sample_rate().get(),
channels: source.channels().get(),
}
}
}
#[derive(Clone, PartialEq, Debug)]
pub enum PlaybackState {
Idle,
Playing,
Paused,
Stopped,
}
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum LoopMode {
None,
One,
}
pub struct AudioPlayer {
player: Arc<Player>,
current_meta: RefCell<Option<AudioTrackMeta>>,
pre_mute_volume: RefCell<f32>,
muted: RefCell<bool>,
playback_state: RefCell<PlaybackState>,
loop_mode: RefCell<LoopMode>,
source_bytes: RefCell<Option<Vec<u8>>>,
source_path: RefCell<Option<String>>,
}
impl AudioPlayer {
pub fn new() -> Result<Self, AudioError> {
AudioEngine::try_init()?;
ENGINE.with(|e| {
let engine = e.borrow();
let engine = engine.as_ref().ok_or(AudioError::NoDevice)?;
let player = Arc::new(Player::connect_new(engine._sink.mixer()));
Ok(Self {
player,
current_meta: RefCell::new(None),
pre_mute_volume: RefCell::new(1.0),
muted: RefCell::new(false),
playback_state: RefCell::new(PlaybackState::Idle),
loop_mode: RefCell::new(LoopMode::None),
source_bytes: RefCell::new(None),
source_path: RefCell::new(None),
})
})
}
pub fn open(&self, path: impl AsRef<Path>) -> Result<AudioTrackMeta, AudioError> {
self.player.clear();
let file = std::fs::File::open(path.as_ref())?;
let source =
rodio::Decoder::try_from(file).map_err(|e| AudioError::Decode(e.to_string()))?;
let meta = AudioTrackMeta::from_source(&source);
*self.source_path.borrow_mut() = Some(path.as_ref().to_string_lossy().to_string());
*self.source_bytes.borrow_mut() = None;
self.player.append(source);
*self.current_meta.borrow_mut() = Some(meta.clone());
Ok(meta)
}
pub fn open_bytes(&self, data: &[u8]) -> Result<AudioTrackMeta, AudioError> {
self.player.clear();
let data_vec = data.to_vec();
let byte_len = data_vec.len() as u64;
let cursor = Cursor::new(data_vec.clone());
let source = DecoderBuilder::new()
.with_data(cursor)
.with_byte_len(byte_len)
.build()
.map_err(|e| AudioError::Decode(e.to_string()))?;
let meta = AudioTrackMeta::from_source(&source);
*self.source_bytes.borrow_mut() = Some(data_vec);
*self.source_path.borrow_mut() = None;
self.player.append(source);
*self.current_meta.borrow_mut() = Some(meta.clone());
Ok(meta)
}
pub fn reload(&self) -> Result<(), AudioError> {
if let Some(ref path) = *self.source_path.borrow() {
let file = std::fs::File::open(path).map_err(|e| AudioError::Io(e))?;
let source =
rodio::Decoder::try_from(file).map_err(|e| AudioError::Decode(e.to_string()))?;
self.player.append(source);
Ok(())
} else if let Some(ref data) = *self.source_bytes.borrow() {
let byte_len = data.len() as u64;
let cursor = Cursor::new(data.clone());
let source = DecoderBuilder::new()
.with_data(cursor)
.with_byte_len(byte_len)
.build()
.map_err(|e| AudioError::Decode(e.to_string()))?;
self.player.append(source);
Ok(())
} else {
Err(AudioError::Decode("No source to reload".into()))
}
}
pub fn current_meta(&self) -> Option<AudioTrackMeta> {
self.current_meta.borrow().clone()
}
pub fn get_pos(&self) -> Duration {
self.player.get_pos()
}
pub fn try_seek(&self, pos: Duration) -> Result<(), AudioError> {
self.player
.try_seek(pos)
.map_err(|e| AudioError::Seek(e.to_string()))
}
pub fn total_duration(&self) -> Option<Duration> {
self.current_meta.borrow().as_ref().and_then(|m| m.duration)
}
pub fn set_speed(&self, speed: f32) {
self.player.set_speed(speed.max(0.1));
}
pub fn speed(&self) -> f32 {
self.player.speed()
}
pub fn set_volume(&self, volume: f32) {
let v = volume.clamp(0.0, 1.0);
self.player.set_volume(v);
if *self.muted.borrow() && v > 0.0 {
*self.muted.borrow_mut() = false;
}
*self.pre_mute_volume.borrow_mut() = v;
}
pub fn volume(&self) -> f32 {
if *self.muted.borrow() {
0.0
} else {
self.player.volume()
}
}
pub fn raw_volume(&self) -> f32 {
self.player.volume()
}
pub fn set_muted(&self, muted: bool) {
if muted == *self.muted.borrow() {
return;
}
if muted {
*self.pre_mute_volume.borrow_mut() = self.player.volume();
self.player.set_volume(0.0);
} else {
self.player.set_volume(*self.pre_mute_volume.borrow());
}
*self.muted.borrow_mut() = muted;
}
pub fn toggle_mute(&self) {
let currently_muted = *self.muted.borrow();
self.set_muted(!currently_muted);
}
pub fn is_muted(&self) -> bool {
*self.muted.borrow()
}
pub fn play(&self) {
self.player.play();
*self.playback_state.borrow_mut() = PlaybackState::Playing;
}
pub fn pause(&self) {
self.player.pause();
*self.playback_state.borrow_mut() = PlaybackState::Paused;
}
pub fn stop(&self) {
self.player.pause();
let _ = self.player.try_seek(Duration::ZERO);
*self.playback_state.borrow_mut() = PlaybackState::Stopped;
}
pub fn is_playing(&self) -> bool {
*self.playback_state.borrow() == PlaybackState::Playing
}
pub fn is_paused(&self) -> bool {
*self.playback_state.borrow() == PlaybackState::Paused
}
pub fn loop_mode(&self) -> LoopMode {
*self.loop_mode.borrow()
}
pub fn set_loop_mode(&self, mode: LoopMode) {
*self.loop_mode.borrow_mut() = mode;
}
pub fn is_empty(&self) -> bool {
self.player.empty()
}
pub fn len(&self) -> usize {
self.player.len()
}
pub fn skip_one(&self) {
self.player.skip_one();
}
pub fn clear_queue(&self) {
self.player.clear();
}
pub fn inner_player(&self) -> Arc<Player> {
self.player.clone()
}
pub fn state(&self) -> PlaybackState {
self.playback_state.borrow().clone()
}
pub fn poll_state(&self) -> PlaybackState {
let was_playing = *self.playback_state.borrow() == PlaybackState::Playing;
if was_playing && self.player.empty() {
*self.playback_state.borrow_mut() = PlaybackState::Idle;
return PlaybackState::Idle;
}
if *self.playback_state.borrow() != PlaybackState::Paused
&& self.player.empty()
&& !was_playing
{
*self.playback_state.borrow_mut() = PlaybackState::Idle;
return PlaybackState::Idle;
}
self.playback_state.borrow().clone()
}
}