124 lines
3.7 KiB
Rust
124 lines
3.7 KiB
Rust
use std::sync::{Arc, Mutex};
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
use std::thread::JoinHandle;
|
|
use std::time::Instant;
|
|
use cpal::{default_host, BufferSize, Device, SampleRate, Stream, StreamConfig, SupportedStreamConfig};
|
|
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
|
|
use crate::core::mixer::AudioMixer;
|
|
use crate::domain::event::{Event, EventBus};
|
|
use crate::utils::real_time_event::RealTimeEvent;
|
|
|
|
#[derive(Clone)]
|
|
pub struct Speaker {
|
|
device: Device
|
|
}
|
|
|
|
pub struct AudioPlayback {
|
|
event_bus: EventBus,
|
|
speaker: Speaker,
|
|
running: Arc<AtomicBool>,
|
|
stream: Option<Stream>,
|
|
worker: Option<JoinHandle<()>>,
|
|
mixer: AudioMixer
|
|
}
|
|
|
|
impl Speaker {
|
|
pub fn new(device: Device) -> Self {
|
|
Speaker {
|
|
device
|
|
}
|
|
}
|
|
|
|
pub fn default() -> Self {
|
|
let host = default_host();
|
|
let device = host.default_output_device().unwrap();
|
|
Speaker::new(device)
|
|
}
|
|
|
|
pub fn get_output_config(&self) -> SupportedStreamConfig {
|
|
self.device.default_output_config().unwrap()
|
|
}
|
|
|
|
pub fn get_stream_config(&self) -> StreamConfig {
|
|
let config = self.get_output_config();
|
|
let mut stream_config: StreamConfig = config.into();
|
|
stream_config.channels = 2;
|
|
stream_config.sample_rate = SampleRate(48000);
|
|
stream_config.buffer_size = BufferSize::Fixed(960);
|
|
stream_config
|
|
}
|
|
|
|
pub fn build_stream<F>(&self, callback: F) -> Stream
|
|
where
|
|
F: FnMut(&mut [i16], &cpal::OutputCallbackInfo) + Send + 'static,
|
|
{
|
|
let config = self.get_stream_config();
|
|
|
|
self.device.build_output_stream(
|
|
&config,
|
|
callback,
|
|
|err| println!("Error output stream: {err}"),
|
|
None
|
|
).unwrap()
|
|
}
|
|
}
|
|
|
|
impl AudioPlayback {
|
|
pub fn new(event_bus: EventBus, speaker: Speaker, mixer: AudioMixer) -> Self {
|
|
Self {
|
|
event_bus,
|
|
speaker,
|
|
running: Arc::new(AtomicBool::new(false)),
|
|
stream: None,
|
|
worker: None,
|
|
mixer
|
|
}
|
|
}
|
|
|
|
pub fn default(event_bus: EventBus, mixer: AudioMixer) -> Self {
|
|
let speaker = Speaker::default();
|
|
AudioPlayback::new(event_bus, speaker, mixer)
|
|
}
|
|
|
|
pub async fn start(&mut self) {
|
|
self.running.store(true, Ordering::SeqCst);
|
|
let stream_running = self.running.clone();
|
|
let event_bus = self.event_bus.clone();
|
|
let mixer = self.mixer.clone();
|
|
// stream cpal
|
|
println!("Setting up audio playback stream...");
|
|
let last_time = Mutex::new(Instant::now());
|
|
let stream = self.speaker.build_stream(move |data, info| {
|
|
println!(
|
|
"CALLBACK : reçu {} samples, type info = {:?}",
|
|
data.len(),
|
|
info
|
|
);
|
|
|
|
let now = Instant::now();
|
|
let mut last = last_time.lock().unwrap();
|
|
let dt = now.duration_since(*last);
|
|
println!("Callback audio appelée chaque {:?} ms (≈ {:.1} Hz)", dt.as_millis(), 1000.0 / dt.as_millis().max(1) as f32);
|
|
*last = now;
|
|
|
|
if !stream_running.load(Ordering::Relaxed){
|
|
return;
|
|
}
|
|
println!("Audio playback stream tick");
|
|
|
|
let audio_mixer = mixer.read(data.len());
|
|
data.copy_from_slice(&audio_mixer);
|
|
// println!("data content : {:?}", data);
|
|
|
|
let _ = event_bus.emit_sync(Event::PlaybackTick(data.len()));
|
|
});
|
|
stream.play().unwrap();
|
|
self.stream = Some(stream);
|
|
println!("Audio playback stream started");
|
|
}
|
|
|
|
pub async fn stop(&mut self) {
|
|
self.running.store(false, Ordering::SeqCst);
|
|
|
|
}
|
|
} |