2020-01-02 03:33:21 +00:00
|
|
|
use ruffle_core::backend::audio::{
|
2022-05-10 01:01:13 +00:00
|
|
|
swf, AudioBackend, AudioMixer, AudioMixerProxy, SoundHandle, SoundInstanceHandle,
|
|
|
|
SoundTransform,
|
2020-01-02 03:33:21 +00:00
|
|
|
};
|
2022-05-10 01:01:13 +00:00
|
|
|
use ruffle_core::impl_audio_mixer_backend;
|
2020-04-23 22:04:07 +00:00
|
|
|
use ruffle_web_common::JsResult;
|
2022-05-10 01:01:13 +00:00
|
|
|
use std::sync::{Arc, RwLock};
|
2019-12-04 06:55:58 +00:00
|
|
|
use wasm_bindgen::{closure::Closure, prelude::*, JsCast};
|
2022-05-10 01:01:13 +00:00
|
|
|
use web_sys::AudioContext;
|
2019-08-26 23:38:37 +00:00
|
|
|
|
2022-05-10 01:01:13 +00:00
|
|
|
type Error = Box<dyn std::error::Error>;
|
2020-10-26 02:34:52 +00:00
|
|
|
|
2019-08-26 23:38:37 +00:00
|
|
|
#[allow(dead_code)]
|
2022-05-10 01:01:13 +00:00
|
|
|
pub struct WebAudioBackend {
|
|
|
|
mixer: AudioMixer,
|
|
|
|
context: AudioContext,
|
|
|
|
buffers: Vec<Arc<RwLock<Buffer>>>,
|
|
|
|
time: Arc<RwLock<f64>>,
|
2019-08-26 23:38:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl WebAudioBackend {
|
2022-05-10 01:01:13 +00:00
|
|
|
const BUFFER_SIZE: u32 = 2048;
|
|
|
|
|
2019-08-26 23:38:37 +00:00
|
|
|
pub fn new() -> Result<Self, Error> {
|
2022-05-10 01:01:13 +00:00
|
|
|
let context = AudioContext::new().into_js_result()?;
|
|
|
|
let sample_rate = context.sample_rate();
|
|
|
|
let mut audio = Self {
|
|
|
|
context,
|
|
|
|
mixer: AudioMixer::new(2, sample_rate as u32),
|
|
|
|
buffers: Vec::with_capacity(2),
|
|
|
|
time: Arc::new(RwLock::new(0.0)),
|
|
|
|
};
|
2019-12-04 06:55:58 +00:00
|
|
|
|
2022-05-10 01:01:13 +00:00
|
|
|
// Create and start the audio buffers.
|
|
|
|
// These buffers ping-pong as the audio stream plays.
|
|
|
|
for _ in 0..2 {
|
|
|
|
let buffer = Buffer::new(&audio)?;
|
|
|
|
let _ = buffer.write().unwrap().play();
|
|
|
|
audio.buffers.push(buffer);
|
2019-12-04 06:55:58 +00:00
|
|
|
}
|
|
|
|
|
2022-05-10 01:01:13 +00:00
|
|
|
Ok(audio)
|
2019-08-26 23:38:37 +00:00
|
|
|
}
|
|
|
|
|
2020-10-19 00:11:25 +00:00
|
|
|
/// Returns the JavaScript AudioContext.
|
|
|
|
pub fn audio_context(&self) -> &AudioContext {
|
|
|
|
&self.context
|
|
|
|
}
|
2019-08-26 23:38:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl AudioBackend for WebAudioBackend {
|
2022-05-10 01:01:13 +00:00
|
|
|
impl_audio_mixer_backend!(mixer);
|
2019-08-26 23:38:37 +00:00
|
|
|
|
2020-09-23 01:18:22 +00:00
|
|
|
fn play(&mut self) {
|
2019-08-26 23:38:37 +00:00
|
|
|
let _ = self.context.resume();
|
|
|
|
}
|
2019-09-19 07:21:22 +00:00
|
|
|
|
2020-09-23 01:18:22 +00:00
|
|
|
fn pause(&mut self) {
|
2020-09-18 22:52:35 +00:00
|
|
|
let _ = self.context.suspend();
|
|
|
|
}
|
2022-05-10 01:01:13 +00:00
|
|
|
}
|
2020-09-18 22:52:35 +00:00
|
|
|
|
2022-05-10 01:01:13 +00:00
|
|
|
impl Drop for WebAudioBackend {
|
|
|
|
fn drop(&mut self) {
|
|
|
|
let _ = self.context.close();
|
2019-09-19 07:21:22 +00:00
|
|
|
}
|
2022-05-10 01:01:13 +00:00
|
|
|
}
|
2019-09-27 17:23:53 +00:00
|
|
|
|
2022-05-10 01:01:13 +00:00
|
|
|
struct Buffer {
|
|
|
|
context: AudioContext,
|
|
|
|
mixer_proxy: AudioMixerProxy,
|
|
|
|
audio_buffer: Vec<f32>,
|
|
|
|
js_buffer: web_sys::AudioBuffer,
|
|
|
|
audio_node: Option<web_sys::AudioBufferSourceNode>,
|
|
|
|
on_ended_handler: Closure<dyn FnMut()>,
|
|
|
|
time: Arc<RwLock<f64>>,
|
|
|
|
buffer_timestep: f64,
|
|
|
|
}
|
2021-01-23 02:03:59 +00:00
|
|
|
|
2022-05-10 01:01:13 +00:00
|
|
|
impl Buffer {
|
|
|
|
fn new(audio: &WebAudioBackend) -> Result<Arc<RwLock<Self>>, Error> {
|
|
|
|
let sample_rate = audio.context.sample_rate();
|
|
|
|
let buffer = Arc::new(RwLock::new(Buffer {
|
|
|
|
context: audio.context.clone(),
|
|
|
|
mixer_proxy: audio.mixer.proxy(),
|
|
|
|
audio_node: None,
|
|
|
|
audio_buffer: vec![0.0; 2 * WebAudioBackend::BUFFER_SIZE as usize],
|
|
|
|
js_buffer: audio
|
|
|
|
.context
|
|
|
|
.create_buffer(2, WebAudioBackend::BUFFER_SIZE, sample_rate)
|
|
|
|
.into_js_result()?,
|
|
|
|
on_ended_handler: Closure::new(|| {}),
|
|
|
|
time: audio.time.clone(),
|
|
|
|
buffer_timestep: f64::from(WebAudioBackend::BUFFER_SIZE) / f64::from(sample_rate),
|
|
|
|
}));
|
|
|
|
|
|
|
|
// Swap in the onended handler.
|
|
|
|
let buffer_handle = buffer.clone();
|
|
|
|
buffer.write().unwrap().on_ended_handler = Closure::wrap(Box::new(move || {
|
|
|
|
// Refill and schedule the buffer for playback.
|
|
|
|
let _ = buffer_handle.write().unwrap().play();
|
|
|
|
}) as Box<dyn FnMut()>);
|
2021-01-24 08:16:07 +00:00
|
|
|
|
2022-05-10 01:01:13 +00:00
|
|
|
Ok(buffer)
|
2021-08-13 02:47:20 +00:00
|
|
|
}
|
|
|
|
|
2022-05-10 01:01:13 +00:00
|
|
|
fn play(&mut self) -> Result<(), Error> {
|
|
|
|
// Mix new audio into the output buffer and copy to JS.
|
|
|
|
self.mixer_proxy.mix(&mut self.audio_buffer);
|
|
|
|
copy_to_audio_buffer_interleaved(&self.js_buffer, &self.audio_buffer);
|
2021-08-17 22:19:59 +00:00
|
|
|
|
2022-05-10 01:01:13 +00:00
|
|
|
// Create the audio node to play back the audio buffer.
|
|
|
|
let audio_node = self.context.create_buffer_source().into_js_result()?;
|
|
|
|
audio_node.set_buffer(Some(&self.js_buffer));
|
|
|
|
audio_node
|
|
|
|
.connect_with_audio_node(&self.context.destination())
|
|
|
|
.into_js_result()?;
|
|
|
|
audio_node.set_onended(Some(self.on_ended_handler.as_ref().unchecked_ref()));
|
|
|
|
|
|
|
|
// Sanity: ensure our player time is not in the past. This can happen due to underruns.
|
|
|
|
let mut time = self.time.write().unwrap();
|
|
|
|
*time = f64::max(*time, self.context.current_time());
|
|
|
|
|
|
|
|
// Schedule this buffer for playback and advance the player time.
|
|
|
|
audio_node.start_with_when(*time).into_js_result()?;
|
|
|
|
*time += self.buffer_timestep;
|
|
|
|
|
|
|
|
self.audio_node = Some(audio_node);
|
|
|
|
Ok(())
|
2021-01-24 08:16:07 +00:00
|
|
|
}
|
2022-05-10 01:01:13 +00:00
|
|
|
}
|
2021-10-16 08:25:31 +00:00
|
|
|
|
2022-05-10 01:01:13 +00:00
|
|
|
impl Drop for Buffer {
|
|
|
|
fn drop(&mut self) {
|
|
|
|
if let Some(audio_node) = self.audio_node.take() {
|
|
|
|
audio_node.set_onended(None);
|
|
|
|
}
|
2021-10-16 08:25:31 +00:00
|
|
|
}
|
2019-08-26 23:38:37 +00:00
|
|
|
}
|
|
|
|
|
2020-11-13 20:40:15 +00:00
|
|
|
#[wasm_bindgen(raw_module = "./ruffle-imports.js")]
|
2019-12-04 06:55:58 +00:00
|
|
|
extern "C" {
|
2022-05-10 01:01:13 +00:00
|
|
|
// Imported JS method to copy interleaved audio data into an `AudioBuffer`.
|
|
|
|
#[wasm_bindgen(js_name = "copyToAudioBufferInterleaved")]
|
|
|
|
fn copy_to_audio_buffer_interleaved(
|
2019-12-04 06:55:58 +00:00
|
|
|
audio_buffer: &web_sys::AudioBuffer,
|
2022-05-10 01:01:13 +00:00
|
|
|
interleaved_data: &[f32],
|
2019-12-04 06:55:58 +00:00
|
|
|
);
|
2019-08-26 23:38:37 +00:00
|
|
|
}
|