Gregor Klevze
694f335408
- Add tools/sync-version.js script to read root package.json version and update src-tauri/tauri.conf.json and src-tauri/Cargo.toml. - Update only the [package] version line in Cargo.toml to preserve formatting. - Include JSON read/write helpers and basic error handling/reporting.
780 lines
26 KiB
Rust
780 lines
26 KiB
Rust
use serde::Serialize;
|
|
use std::io::Read;
|
|
use std::process::{Command, Stdio};
|
|
use std::ffi::OsString;
|
|
use std::sync::{
|
|
atomic::{AtomicBool, AtomicU32, Ordering},
|
|
mpsc, Arc, Mutex,
|
|
};
|
|
use std::time::Duration;
|
|
|
|
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
|
|
use ringbuf::HeapRb;
|
|
|
|
#[cfg(windows)]
|
|
use std::os::windows::process::CommandExt;
|
|
|
|
#[cfg(windows)]
|
|
const CREATE_NO_WINDOW: u32 = 0x08000000;
|
|
|
|
fn command_hidden(program: &OsString) -> Command {
|
|
let mut cmd = Command::new(program);
|
|
#[cfg(windows)]
|
|
{
|
|
cmd.creation_flags(CREATE_NO_WINDOW);
|
|
}
|
|
cmd
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
|
|
#[serde(rename_all = "lowercase")]
|
|
pub enum PlayerStatus {
|
|
Idle,
|
|
Buffering,
|
|
Playing,
|
|
Stopped,
|
|
Error,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize)]
|
|
pub struct PlayerState {
|
|
pub status: PlayerStatus,
|
|
pub url: Option<String>,
|
|
pub volume: f32,
|
|
pub error: Option<String>,
|
|
}
|
|
|
|
impl Default for PlayerState {
|
|
fn default() -> Self {
|
|
Self {
|
|
status: PlayerStatus::Idle,
|
|
url: None,
|
|
volume: 0.5,
|
|
error: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct PlayerShared {
|
|
pub state: Mutex<PlayerState>,
|
|
}
|
|
|
|
impl PlayerShared {
|
|
pub fn snapshot(&self) -> PlayerState {
|
|
self.state.lock().unwrap().clone()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum PlayerCommand {
|
|
Play { url: String },
|
|
// Cast-only playback: decode to PCM and keep it available for cast taps,
|
|
// but do not open a CPAL output stream.
|
|
PlayCast { url: String },
|
|
Stop,
|
|
SetVolume { volume: f32 },
|
|
CastTapStart {
|
|
port: u16,
|
|
reply: mpsc::Sender<Result<(), String>>,
|
|
},
|
|
CastTapStop,
|
|
Shutdown,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct PlayerController {
|
|
pub tx: mpsc::Sender<PlayerCommand>,
|
|
}
|
|
|
|
pub fn spawn_player_thread(shared: &'static PlayerShared) -> PlayerController {
|
|
let (tx, rx) = mpsc::channel::<PlayerCommand>();
|
|
|
|
std::thread::spawn(move || player_thread(shared, rx));
|
|
PlayerController { tx }
|
|
}
|
|
|
|
fn clamp01(v: f32) -> f32 {
|
|
if v.is_nan() {
|
|
0.0
|
|
} else if v < 0.0 {
|
|
0.0
|
|
} else if v > 1.0 {
|
|
1.0
|
|
} else {
|
|
v
|
|
}
|
|
}
|
|
|
|
fn volume_to_bits(v: f32) -> u32 {
|
|
clamp01(v).to_bits()
|
|
}
|
|
|
|
fn volume_from_bits(bits: u32) -> f32 {
|
|
f32::from_bits(bits)
|
|
}
|
|
|
|
fn set_status(shared: &'static PlayerShared, status: PlayerStatus) {
|
|
let mut s = shared.state.lock().unwrap();
|
|
if s.status != status {
|
|
s.status = status;
|
|
}
|
|
}
|
|
|
|
fn set_error(shared: &'static PlayerShared, message: String) {
|
|
let mut s = shared.state.lock().unwrap();
|
|
s.status = PlayerStatus::Error;
|
|
s.error = Some(message);
|
|
}
|
|
|
|
pub(crate) fn ffmpeg_command() -> OsString {
|
|
// Step 2: external ffmpeg binary.
|
|
// Lookup order:
|
|
// 1) RADIOPLAYER_FFMPEG (absolute or relative)
|
|
// 2) ffmpeg next to the application executable
|
|
// 3) PATH lookup (ffmpeg / ffmpeg.exe)
|
|
if let Ok(p) = std::env::var("RADIOPLAYER_FFMPEG") {
|
|
if !p.trim().is_empty() {
|
|
return OsString::from(p);
|
|
}
|
|
}
|
|
|
|
let local_name = if cfg!(windows) { "ffmpeg.exe" } else { "ffmpeg" };
|
|
if let Ok(exe) = std::env::current_exe() {
|
|
if let Some(dir) = exe.parent() {
|
|
// Common locations depending on bundler/platform.
|
|
let candidates = [
|
|
dir.join(local_name),
|
|
// Some packagers place resources in a sibling folder.
|
|
dir.join("resources").join(local_name),
|
|
dir.join("Resources").join(local_name),
|
|
// Or one level above.
|
|
dir.join("..").join("resources").join(local_name),
|
|
dir.join("..").join("Resources").join(local_name),
|
|
];
|
|
for candidate in candidates {
|
|
if candidate.exists() {
|
|
return candidate.into_os_string();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
OsString::from(local_name)
|
|
}
|
|
|
|
pub fn preflight_ffmpeg_only() -> Result<(), String> {
|
|
let ffmpeg = ffmpeg_command();
|
|
let status = command_hidden(&ffmpeg)
|
|
.arg("-version")
|
|
.stdout(Stdio::null())
|
|
.stderr(Stdio::null())
|
|
.status()
|
|
.map_err(|e| {
|
|
let ffmpeg_disp = ffmpeg.to_string_lossy();
|
|
format!(
|
|
"FFmpeg not available ({ffmpeg_disp}): {e}. Set RADIOPLAYER_FFMPEG, bundle ffmpeg next to the app, or install ffmpeg on PATH."
|
|
)
|
|
})?;
|
|
if !status.success() {
|
|
return Err("FFmpeg exists but returned non-zero for -version".to_string());
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn preflight_check() -> Result<(), String> {
|
|
// Ensure we have an output device up-front so UI gets a synchronous error.
|
|
let host = cpal::default_host();
|
|
let device = host
|
|
.default_output_device()
|
|
.ok_or_else(|| "No default audio output device".to_string())?;
|
|
let _ = device
|
|
.default_output_config()
|
|
.map_err(|e| format!("Failed to get output config: {e}"))?;
|
|
|
|
preflight_ffmpeg_only()?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum PipelineMode {
|
|
WithOutput,
|
|
Headless,
|
|
}
|
|
|
|
struct CastTapProc {
|
|
child: std::process::Child,
|
|
writer_join: Option<std::thread::JoinHandle<()>>,
|
|
}
|
|
|
|
struct Pipeline {
|
|
stop_flag: Arc<AtomicBool>,
|
|
volume_bits: Arc<AtomicU32>,
|
|
_stream: Option<cpal::Stream>,
|
|
decoder_join: Option<std::thread::JoinHandle<()>>,
|
|
cast_tx: Arc<Mutex<Option<mpsc::SyncSender<Vec<u8>>>>>,
|
|
cast_proc: Option<CastTapProc>,
|
|
sample_rate: u32,
|
|
channels: u16,
|
|
}
|
|
|
|
impl Pipeline {
|
|
fn start(shared: &'static PlayerShared, url: String, mode: PipelineMode) -> Result<Self, String> {
|
|
let (device, sample_format, cfg, sample_rate, channels) = match mode {
|
|
PipelineMode::WithOutput => {
|
|
let host = cpal::default_host();
|
|
let device = host
|
|
.default_output_device()
|
|
.ok_or_else(|| "No default audio output device".to_string())?;
|
|
let default_cfg = device
|
|
.default_output_config()
|
|
.map_err(|e| format!("Failed to get output config: {e}"))?;
|
|
let sample_format = default_cfg.sample_format();
|
|
let cfg = default_cfg.config();
|
|
let sample_rate = cfg.sample_rate.0;
|
|
let channels = cfg.channels as u16;
|
|
(Some(device), Some(sample_format), Some(cfg), sample_rate, channels)
|
|
}
|
|
PipelineMode::Headless => {
|
|
// For cast-only, pick a sane, widely-supported PCM format.
|
|
// This does not depend on an audio device.
|
|
(None, None, None, 48_000u32, 2u16)
|
|
}
|
|
};
|
|
|
|
// 5 seconds of PCM buffering (i16 samples)
|
|
let (mut prod_opt, mut cons_opt) = if mode == PipelineMode::WithOutput {
|
|
let cfg = cfg.as_ref().expect("cfg must exist for WithOutput");
|
|
let capacity_samples = (sample_rate as usize)
|
|
.saturating_mul(cfg.channels as usize)
|
|
.saturating_mul(5);
|
|
let rb = HeapRb::<i16>::new(capacity_samples);
|
|
let (prod, cons) = rb.split();
|
|
(Some(prod), Some(cons))
|
|
} else {
|
|
(None, None)
|
|
};
|
|
|
|
let stop_flag = Arc::new(AtomicBool::new(false));
|
|
let volume_bits = Arc::new(AtomicU32::new({
|
|
let s = shared.state.lock().unwrap();
|
|
volume_to_bits(s.volume)
|
|
}));
|
|
|
|
let cast_tx: Arc<Mutex<Option<mpsc::SyncSender<Vec<u8>>>>> = Arc::new(Mutex::new(None));
|
|
|
|
// Decoder thread: spawns ffmpeg, reads PCM, writes into ring buffer.
|
|
let stop_for_decoder = Arc::clone(&stop_flag);
|
|
let shared_for_decoder = shared;
|
|
let decoder_url = url.clone();
|
|
let cast_tx_for_decoder = Arc::clone(&cast_tx);
|
|
let decoder_join = std::thread::spawn(move || {
|
|
let mut backoff_ms: u64 = 250;
|
|
let mut pushed_since_start: usize = 0;
|
|
let playing_threshold_samples = (sample_rate as usize)
|
|
.saturating_mul(channels as usize)
|
|
.saturating_div(4); // ~250ms
|
|
|
|
'outer: loop {
|
|
if stop_for_decoder.load(Ordering::SeqCst) {
|
|
break;
|
|
}
|
|
|
|
set_status(shared_for_decoder, PlayerStatus::Buffering);
|
|
|
|
let ffmpeg = ffmpeg_command();
|
|
let ffmpeg_disp = ffmpeg.to_string_lossy();
|
|
let mut child = match command_hidden(&ffmpeg)
|
|
.arg("-nostdin")
|
|
.arg("-hide_banner")
|
|
.arg("-loglevel")
|
|
.arg("warning")
|
|
// basic reconnect flags (best-effort; not all protocols honor these)
|
|
.arg("-reconnect")
|
|
.arg("1")
|
|
.arg("-reconnect_streamed")
|
|
.arg("1")
|
|
.arg("-reconnect_delay_max")
|
|
.arg("5")
|
|
.arg("-i")
|
|
.arg(&decoder_url)
|
|
.arg("-vn")
|
|
.arg("-ac")
|
|
.arg(channels.to_string())
|
|
.arg("-ar")
|
|
.arg(sample_rate.to_string())
|
|
.arg("-f")
|
|
.arg("s16le")
|
|
.arg("pipe:1")
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::null())
|
|
.spawn()
|
|
{
|
|
Ok(c) => c,
|
|
Err(e) => {
|
|
// If ffmpeg isn't available, this is a hard failure.
|
|
set_error(
|
|
shared_for_decoder,
|
|
format!(
|
|
"Failed to start ffmpeg ({ffmpeg_disp}): {e}. Set RADIOPLAYER_FFMPEG, bundle ffmpeg next to the app, or install ffmpeg on PATH."
|
|
),
|
|
);
|
|
break;
|
|
}
|
|
};
|
|
|
|
let mut stdout = match child.stdout.take() {
|
|
Some(s) => s,
|
|
None => {
|
|
set_error(shared_for_decoder, "ffmpeg stdout not available".to_string());
|
|
let _ = child.kill();
|
|
break;
|
|
}
|
|
};
|
|
|
|
let mut buf = [0u8; 8192];
|
|
let mut leftover: Option<u8> = None;
|
|
|
|
loop {
|
|
if stop_for_decoder.load(Ordering::SeqCst) {
|
|
let _ = child.kill();
|
|
let _ = child.wait();
|
|
break 'outer;
|
|
}
|
|
|
|
let n = match stdout.read(&mut buf) {
|
|
Ok(0) => 0,
|
|
Ok(n) => n,
|
|
Err(_) => 0,
|
|
};
|
|
|
|
if n == 0 {
|
|
// EOF / disconnect. Try to reconnect after backoff.
|
|
let _ = child.kill();
|
|
let _ = child.wait();
|
|
if stop_for_decoder.load(Ordering::SeqCst) {
|
|
break 'outer;
|
|
}
|
|
set_status(shared_for_decoder, PlayerStatus::Buffering);
|
|
std::thread::sleep(Duration::from_millis(backoff_ms));
|
|
backoff_ms = (backoff_ms * 2).min(5000);
|
|
continue 'outer;
|
|
}
|
|
|
|
backoff_ms = 250;
|
|
|
|
// Forward raw PCM bytes to cast tap (if enabled).
|
|
if let Some(tx) = cast_tx_for_decoder.lock().unwrap().as_ref() {
|
|
// Best-effort: never block local playback.
|
|
let _ = tx.try_send(buf[..n].to_vec());
|
|
}
|
|
|
|
// Convert bytes to i16 LE samples
|
|
let mut i = 0usize;
|
|
if let Some(b0) = leftover.take() {
|
|
if n >= 1 {
|
|
let b1 = buf[0];
|
|
let sample = i16::from_le_bytes([b0, b1]);
|
|
if let Some(prod) = prod_opt.as_mut() {
|
|
let _ = prod.push(sample);
|
|
}
|
|
pushed_since_start += 1;
|
|
i = 1;
|
|
} else {
|
|
leftover = Some(b0);
|
|
}
|
|
}
|
|
|
|
while i + 1 < n {
|
|
let sample = i16::from_le_bytes([buf[i], buf[i + 1]]);
|
|
if let Some(prod) = prod_opt.as_mut() {
|
|
let _ = prod.push(sample);
|
|
}
|
|
pushed_since_start += 1;
|
|
i += 2;
|
|
}
|
|
|
|
if i < n {
|
|
leftover = Some(buf[i]);
|
|
}
|
|
|
|
// Move to Playing once we've decoded a small buffer.
|
|
if pushed_since_start >= playing_threshold_samples {
|
|
set_status(shared_for_decoder, PlayerStatus::Playing);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
let stream = if mode == PipelineMode::WithOutput {
|
|
let device = device.expect("device must exist for WithOutput");
|
|
let sample_format = sample_format.expect("sample_format must exist for WithOutput");
|
|
let cfg = cfg.expect("cfg must exist for WithOutput");
|
|
let mut cons = cons_opt.take().expect("cons must exist for WithOutput");
|
|
|
|
// Audio callback: drain ring buffer and write to output.
|
|
let shared_for_cb = shared;
|
|
let stop_for_cb = Arc::clone(&stop_flag);
|
|
let volume_for_cb = Arc::clone(&volume_bits);
|
|
|
|
let mut last_was_underrun = false;
|
|
|
|
let err_fn = move |err| {
|
|
let msg = format!("Audio output error: {err}");
|
|
set_error(shared_for_cb, msg);
|
|
};
|
|
|
|
let built = match sample_format {
|
|
cpal::SampleFormat::F32 => device.build_output_stream(
|
|
&cfg,
|
|
move |data: &mut [f32], _| {
|
|
if stop_for_cb.load(Ordering::Relaxed) {
|
|
for s in data.iter_mut() {
|
|
*s = 0.0;
|
|
}
|
|
return;
|
|
}
|
|
|
|
let vol = volume_from_bits(volume_for_cb.load(Ordering::Relaxed));
|
|
let mut underrun = false;
|
|
for s in data.iter_mut() {
|
|
if let Some(v) = cons.pop() {
|
|
*s = (v as f32 / 32768.0) * vol;
|
|
} else {
|
|
*s = 0.0;
|
|
underrun = true;
|
|
}
|
|
}
|
|
if underrun != last_was_underrun {
|
|
last_was_underrun = underrun;
|
|
set_status(
|
|
shared_for_cb,
|
|
if underrun {
|
|
PlayerStatus::Buffering
|
|
} else {
|
|
PlayerStatus::Playing
|
|
},
|
|
);
|
|
}
|
|
},
|
|
err_fn,
|
|
None,
|
|
),
|
|
cpal::SampleFormat::I16 => device.build_output_stream(
|
|
&cfg,
|
|
move |data: &mut [i16], _| {
|
|
if stop_for_cb.load(Ordering::Relaxed) {
|
|
for s in data.iter_mut() {
|
|
*s = 0;
|
|
}
|
|
return;
|
|
}
|
|
|
|
let vol = volume_from_bits(volume_for_cb.load(Ordering::Relaxed));
|
|
let mut underrun = false;
|
|
for s in data.iter_mut() {
|
|
if let Some(v) = cons.pop() {
|
|
let scaled =
|
|
(v as f32 * vol).clamp(i16::MIN as f32, i16::MAX as f32);
|
|
*s = scaled as i16;
|
|
} else {
|
|
*s = 0;
|
|
underrun = true;
|
|
}
|
|
}
|
|
if underrun != last_was_underrun {
|
|
last_was_underrun = underrun;
|
|
set_status(
|
|
shared_for_cb,
|
|
if underrun {
|
|
PlayerStatus::Buffering
|
|
} else {
|
|
PlayerStatus::Playing
|
|
},
|
|
);
|
|
}
|
|
},
|
|
err_fn,
|
|
None,
|
|
),
|
|
cpal::SampleFormat::U16 => device.build_output_stream(
|
|
&cfg,
|
|
move |data: &mut [u16], _| {
|
|
if stop_for_cb.load(Ordering::Relaxed) {
|
|
for s in data.iter_mut() {
|
|
*s = 0;
|
|
}
|
|
return;
|
|
}
|
|
|
|
let vol = volume_from_bits(volume_for_cb.load(Ordering::Relaxed));
|
|
let mut underrun = false;
|
|
for s in data.iter_mut() {
|
|
if let Some(v) = cons.pop() {
|
|
// Convert signed i16 to unsigned with bias.
|
|
let f = (v as f32 / 32768.0) * vol;
|
|
let scaled = (f * 32767.0 + 32768.0).clamp(0.0, 65535.0);
|
|
*s = scaled as u16;
|
|
} else {
|
|
*s = 0;
|
|
underrun = true;
|
|
}
|
|
}
|
|
if underrun != last_was_underrun {
|
|
last_was_underrun = underrun;
|
|
set_status(
|
|
shared_for_cb,
|
|
if underrun {
|
|
PlayerStatus::Buffering
|
|
} else {
|
|
PlayerStatus::Playing
|
|
},
|
|
);
|
|
}
|
|
},
|
|
err_fn,
|
|
None,
|
|
),
|
|
_ => return Err("Unsupported output sample format".to_string()),
|
|
}
|
|
.map_err(|e| format!("Failed to create output stream: {e}"))?;
|
|
|
|
built
|
|
.play()
|
|
.map_err(|e| format!("Failed to start output stream: {e}"))?;
|
|
Some(built)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
Ok(Self {
|
|
stop_flag,
|
|
volume_bits,
|
|
_stream: stream,
|
|
decoder_join: Some(decoder_join),
|
|
cast_tx,
|
|
cast_proc: None,
|
|
sample_rate,
|
|
channels,
|
|
})
|
|
}
|
|
|
|
fn start_cast_tap(&mut self, port: u16, sample_rate: u32, channels: u16) -> Result<(), String> {
|
|
// Stop existing tap first.
|
|
self.stop_cast_tap();
|
|
|
|
let ffmpeg = ffmpeg_command();
|
|
let ffmpeg_disp = ffmpeg.to_string_lossy();
|
|
|
|
let spawn = |codec: &str| -> Result<std::process::Child, String> {
|
|
command_hidden(&ffmpeg)
|
|
.arg("-nostdin")
|
|
.arg("-hide_banner")
|
|
.arg("-loglevel")
|
|
.arg("warning")
|
|
.arg("-f")
|
|
.arg("s16le")
|
|
.arg("-ac")
|
|
.arg(channels.to_string())
|
|
.arg("-ar")
|
|
.arg(sample_rate.to_string())
|
|
.arg("-i")
|
|
.arg("pipe:0")
|
|
.arg("-vn")
|
|
.arg("-c:a")
|
|
.arg(codec)
|
|
.arg("-b:a")
|
|
.arg("128k")
|
|
.arg("-f")
|
|
.arg("mp3")
|
|
.arg("-content_type")
|
|
.arg("audio/mpeg")
|
|
.arg("-listen")
|
|
.arg("1")
|
|
.arg(format!("http://0.0.0.0:{port}/stream.mp3"))
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::null())
|
|
.stderr(Stdio::piped())
|
|
.spawn()
|
|
.map_err(|e| {
|
|
format!(
|
|
"Failed to start ffmpeg cast tap ({ffmpeg_disp}): {e}. Set RADIOPLAYER_FFMPEG, bundle ffmpeg next to the app, or install ffmpeg on PATH."
|
|
)
|
|
})
|
|
};
|
|
|
|
let mut child = spawn("libmp3lame")?;
|
|
std::thread::sleep(Duration::from_millis(150));
|
|
if let Ok(Some(status)) = child.try_wait() {
|
|
if !status.success() {
|
|
// Some builds lack libmp3lame; fall back to built-in encoder.
|
|
child = spawn("mp3")?;
|
|
}
|
|
}
|
|
|
|
let stdin = child
|
|
.stdin
|
|
.take()
|
|
.ok_or_else(|| "ffmpeg cast tap stdin not available".to_string())?;
|
|
|
|
let (tx, rx) = mpsc::sync_channel::<Vec<u8>>(256);
|
|
*self.cast_tx.lock().unwrap() = Some(tx);
|
|
|
|
let writer_join = std::thread::spawn(move || {
|
|
use std::io::Write;
|
|
let mut stdin = stdin;
|
|
while let Ok(chunk) = rx.recv() {
|
|
if chunk.is_empty() {
|
|
continue;
|
|
}
|
|
if stdin.write_all(&chunk).is_err() {
|
|
break;
|
|
}
|
|
}
|
|
let _ = stdin.flush();
|
|
});
|
|
|
|
self.cast_proc = Some(CastTapProc {
|
|
child,
|
|
writer_join: Some(writer_join),
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn stop_cast_tap(&mut self) {
|
|
*self.cast_tx.lock().unwrap() = None;
|
|
if let Some(mut proc) = self.cast_proc.take() {
|
|
let _ = proc.child.kill();
|
|
let _ = proc.child.wait();
|
|
if let Some(j) = proc.writer_join.take() {
|
|
let _ = j.join();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn stop(mut self, shared: &'static PlayerShared) {
|
|
self.stop_flag.store(true, Ordering::SeqCst);
|
|
self.stop_cast_tap();
|
|
// dropping stream stops audio
|
|
if let Some(j) = self.decoder_join.take() {
|
|
let _ = j.join();
|
|
}
|
|
set_status(shared, PlayerStatus::Stopped);
|
|
}
|
|
|
|
fn set_volume(&self, volume: f32) {
|
|
self.volume_bits.store(volume_to_bits(volume), Ordering::Relaxed);
|
|
}
|
|
}
|
|
|
|
fn player_thread(shared: &'static PlayerShared, rx: mpsc::Receiver<PlayerCommand>) {
|
|
// Step 2: FFmpeg decode + CPAL playback.
|
|
let mut pipeline: Option<Pipeline> = None;
|
|
let mut pipeline_cast_owned = false;
|
|
while let Ok(cmd) = rx.recv() {
|
|
match cmd {
|
|
PlayerCommand::Play { url } => {
|
|
if let Some(p) = pipeline.take() {
|
|
p.stop(shared);
|
|
}
|
|
|
|
pipeline_cast_owned = false;
|
|
|
|
{
|
|
let mut s = shared.state.lock().unwrap();
|
|
s.error = None;
|
|
s.url = Some(url.clone());
|
|
s.status = PlayerStatus::Buffering;
|
|
}
|
|
|
|
match Pipeline::start(shared, url, PipelineMode::WithOutput) {
|
|
Ok(p) => {
|
|
// Apply current volume to pipeline atomics.
|
|
let vol = { shared.state.lock().unwrap().volume };
|
|
p.set_volume(vol);
|
|
pipeline = Some(p);
|
|
}
|
|
Err(e) => {
|
|
set_error(shared, e);
|
|
pipeline = None;
|
|
}
|
|
}
|
|
}
|
|
PlayerCommand::PlayCast { url } => {
|
|
if let Some(p) = pipeline.take() {
|
|
p.stop(shared);
|
|
}
|
|
|
|
pipeline_cast_owned = true;
|
|
|
|
{
|
|
let mut s = shared.state.lock().unwrap();
|
|
s.error = None;
|
|
s.url = Some(url.clone());
|
|
s.status = PlayerStatus::Buffering;
|
|
}
|
|
|
|
match Pipeline::start(shared, url, PipelineMode::Headless) {
|
|
Ok(p) => {
|
|
let vol = { shared.state.lock().unwrap().volume };
|
|
p.set_volume(vol);
|
|
pipeline = Some(p);
|
|
}
|
|
Err(e) => {
|
|
set_error(shared, e);
|
|
pipeline = None;
|
|
}
|
|
}
|
|
}
|
|
PlayerCommand::Stop => {
|
|
if let Some(p) = pipeline.take() {
|
|
p.stop(shared);
|
|
} else {
|
|
let mut s = shared.state.lock().unwrap();
|
|
s.status = PlayerStatus::Stopped;
|
|
s.error = None;
|
|
}
|
|
pipeline_cast_owned = false;
|
|
}
|
|
PlayerCommand::SetVolume { volume } => {
|
|
let v = clamp01(volume);
|
|
{
|
|
let mut s = shared.state.lock().unwrap();
|
|
s.volume = v;
|
|
}
|
|
if let Some(p) = pipeline.as_ref() {
|
|
p.set_volume(v);
|
|
}
|
|
}
|
|
PlayerCommand::CastTapStart { port, reply } => {
|
|
if let Some(p) = pipeline.as_mut() {
|
|
// Current pipeline sample format is always s16le.
|
|
let res = p.start_cast_tap(port, p.sample_rate, p.channels);
|
|
let _ = reply.send(res);
|
|
} else {
|
|
let _ = reply.send(Err("No active decoder pipeline".to_string()));
|
|
}
|
|
}
|
|
PlayerCommand::CastTapStop => {
|
|
if let Some(p) = pipeline.as_mut() {
|
|
p.stop_cast_tap();
|
|
}
|
|
if pipeline_cast_owned {
|
|
if let Some(p) = pipeline.take() {
|
|
p.stop(shared);
|
|
}
|
|
pipeline_cast_owned = false;
|
|
}
|
|
}
|
|
PlayerCommand::Shutdown => break,
|
|
}
|
|
}
|
|
|
|
if let Some(p) = pipeline.take() {
|
|
p.stop(shared);
|
|
} else {
|
|
set_status(shared, PlayerStatus::Stopped);
|
|
}
|
|
}
|