112 lines
3.8 KiB
Rust
112 lines
3.8 KiB
Rust
use crate::prelude::*;
|
|
|
|
use std::error::Error;
|
|
use std::mem::size_of;
|
|
use std::path::Path;
|
|
|
|
use sdl2::Sdl;
|
|
use sdl2::audio::{AudioCVT, AudioFormat, AudioFormatNum, AudioQueue, AudioSpec, AudioSpecDesired};
|
|
|
|
use crate::base::ControlFlow;
|
|
|
|
pub struct SimpleSdl2AudioComponent {
|
|
src_freq: f64,
|
|
audio_buffer: Vec<i16>,
|
|
queue: AudioQueue<i16>,
|
|
}
|
|
|
|
/// Work around an idiosyncrasy of the sdl2 crate's AudioCVT API.
|
|
///
|
|
/// It only deals in Vec<u8>, but from where I'm sitting it should really be abstracting away the
|
|
/// "u8" part if the rest of the API deals in the appropriate sample type.
|
|
pub(crate) fn resample<C: AudioFormatNum>(converter: &AudioCVT, mut samples: Vec<C>) -> Vec<C> {
|
|
let sample_size = size_of::<C>();
|
|
|
|
let ptr = samples.as_mut_ptr() as *mut u8;
|
|
let length = samples.len() * sample_size;
|
|
let capacity = samples.capacity() * sample_size;
|
|
std::mem::forget(samples);
|
|
let samples_u8 = unsafe { Vec::from_raw_parts(ptr, length, capacity) };
|
|
|
|
let mut resampled_u8 = converter.convert(samples_u8);
|
|
|
|
let ptr = resampled_u8.as_mut_ptr() as *mut C;
|
|
let length = resampled_u8.len() / sample_size;
|
|
let capacity = resampled_u8.capacity() / sample_size;
|
|
std::mem::forget(resampled_u8);
|
|
unsafe { Vec::from_raw_parts(ptr, length, capacity) }
|
|
}
|
|
|
|
impl RetroCallbacks for SimpleSdl2AudioComponent {
|
|
fn audio_samples(&mut self, stereo_pcm: &[i16]) -> usize {
|
|
self.audio_buffer.extend(stereo_pcm);
|
|
stereo_pcm.len() / 2
|
|
}
|
|
|
|
fn set_system_av_info(&mut self, av_info: &SystemAvInfo) -> Option<bool> {
|
|
if Self::make_converter(av_info.timing.sample_rate, self.queue.spec()).is_ok() {
|
|
self.src_freq = av_info.timing.sample_rate;
|
|
Some(true)
|
|
} else {
|
|
Some(false)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl RetroComponent for SimpleSdl2AudioComponent {
|
|
fn post_load_game(&mut self, retro: &mut LibretroWrapper, _rom: &Path) -> Result<(), Box<dyn Error>> {
|
|
self.src_freq = retro.get_system_av_info().timing.sample_rate;
|
|
self.queue.resume();
|
|
Ok(())
|
|
}
|
|
|
|
fn post_run(&mut self, _retro: &mut LibretroWrapper) -> ControlFlow {
|
|
if let Ok(converter) = Self::make_converter(self.src_freq, self.queue.spec()) {
|
|
if !self.audio_buffer.is_empty() {
|
|
let mut samples = std::mem::take(&mut self.audio_buffer);
|
|
samples = resample(&converter, samples);
|
|
self.audio_buffer = samples;
|
|
self.queue.queue(&self.audio_buffer);
|
|
self.audio_buffer.clear();
|
|
}
|
|
}
|
|
ControlFlow::Continue
|
|
}
|
|
}
|
|
|
|
impl SimpleSdl2AudioComponent {
|
|
pub fn new(sdl_context: &mut Sdl) -> Result<Self, Box<dyn std::error::Error>> {
|
|
let audio = sdl_context.audio().unwrap();
|
|
let desired_spec = AudioSpecDesired {
|
|
freq: None,
|
|
channels: Some(2),
|
|
samples: None,
|
|
};
|
|
|
|
let queue = AudioQueue::open_queue(&audio, None, &desired_spec)?;
|
|
|
|
// default to the old libsnes default value until after load_game or set_system_av_info.
|
|
let src_freq = 32040.5;
|
|
|
|
Ok(SimpleSdl2AudioComponent {
|
|
src_freq,
|
|
audio_buffer: Default::default(),
|
|
queue,
|
|
})
|
|
}
|
|
|
|
fn make_converter(src_freq: f64, dest_spec: &AudioSpec) -> Result<AudioCVT, String> {
|
|
// note on the `* 64`: as long as the ratio between src_rate and dst_rate is right,
|
|
// we should be in the clear -- this is to make up for SDL not giving us floats for
|
|
// this, we can at least get some quasi-fixed-point precision going on...
|
|
AudioCVT::new(
|
|
AudioFormat::s16_sys(),
|
|
2,
|
|
(src_freq * 64.0).round() as i32,
|
|
dest_spec.format,
|
|
dest_spec.channels,
|
|
dest_spec.freq * 64,
|
|
)
|
|
}
|
|
}
|