Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 10 additions & 0 deletions crates/app/src/app.rs
Original file line number Diff line number Diff line change
Expand Up @@ -189,6 +189,7 @@ impl App {
let audio_cfg: clubcraft_engine::AudioConfig = cc.storage.and_then(|s| eframe::get_value(s, "audio")).unwrap_or_default();
let midi_port: Option<String> = cc.storage.and_then(|s| eframe::get_value(s, "midi_port"));
let mut app = App { lib, sh, jobs, view, library: LibraryView::default(), status: String::new(), devctl: crate::devctl::DevCtl::from_env(), live: Default::default(), decks: vec![Default::default(); 2], mixer: Default::default(), browser: LibraryView::default(), studio: Default::default(), mixes: Vec::new(), eng: crate::live::adapter::LiveEngine::start(audio_cfg.clone()), settings: crate::settings::Settings::new(audio_cfg, midi_port), home: Default::default(), prefs, applied_prefs: None, menu: crate::menu::AppMenu::install(&cc.egui_ctx), ui_ctx_cmd: None, mix_summaries: Vec::new(), prepared: (-1, 0), preview_serial: 0, stems_queued: Default::default(), full_stems_queued: Default::default(), pending_export: None, queued: Default::default(), external: (std::fs::metadata(crate::mcp::change_marker()).and_then(|m| m.modified()).ok(), 0.0) };
if let Some(config) = &app.eng.startup_audio_config { app.settings.sync_audio(config.clone()); }
app.settings.connect_midi(app.eng.handle.as_ref());
if let Some(e) = &app.eng.error {
app.status = e.clone();
Expand Down Expand Up @@ -1436,6 +1437,15 @@ impl eframe::App for App {
self.handle_home_actions(home_actions);
let mut sa = Vec::new();
self.settings.ui(&ctx, self.eng.handle.as_ref(), &mut sa, &mut self.prefs);
if std::mem::take(&mut self.settings.restart_audio) && self.eng.handle.is_none() {
self.eng = crate::live::adapter::LiveEngine::start(self.settings.audio.clone());
if self.eng.handle.is_some() {
if let Some(config) = &self.eng.startup_audio_config { self.settings.sync_audio(config.clone()); }
self.settings.connect_midi(self.eng.handle.as_ref());
self.applied_prefs = None;
}
self.settings.message = self.eng.error.clone().unwrap_or_else(|| "Audio output started".into());
}
self.apply_prefs(&ctx);
for a in sa {
match a {
Expand Down
126 changes: 122 additions & 4 deletions crates/app/src/live/adapter.rs
Original file line number Diff line number Diff line change
Expand Up @@ -365,6 +365,9 @@ pub struct Export {
pub struct LiveEngine {
pub handle: Option<EngineHandle>,
pub error: Option<String>,
/// Canonical settings only when the requested setup started. A temporary
/// system-default fallback must never replace the user's persisted choice.
pub startup_audio_config: Option<AudioConfig>,
pub cache: TrackCache,
pub sep: Arc<LiveSeparator>,
tx: Sender<LoadResult>,
Expand All @@ -387,12 +390,118 @@ pub struct LiveEngine {
pub prefs: crate::prefs::Prefs,
}

// Keep the legacy startup recovery for one-device setups. SeparateDevice must
// never substitute the selected master or reroute cue onto the system speakers.
struct AudioStartup<T> {
handle: T,
warning: Option<String>,
used_fallback: bool,
}

impl<T> AudioStartup<T> {
fn config_to_save(&self, resolved: AudioConfig) -> Option<AudioConfig> {
if self.used_fallback { None } else { Some(resolved) }
}
}

fn start_audio<T>(config: AudioConfig, mut open: impl FnMut(AudioConfig) -> anyhow::Result<T>) -> anyhow::Result<AudioStartup<T>> {
let separate = config.headphones == clubcraft_engine::HeadphoneRouting::SeparateDevice;
open(config).map(|handle| AudioStartup { handle, warning: None, used_fallback: false }).or_else(|error| {
if separate { return Err(error); }
log::warn!("Saved audio setup unavailable; trying system default: {error:#}");
open(AudioConfig::default()).map(|handle| AudioStartup {
handle, warning: Some(format!("Saved audio setup unavailable; using system default: {error:#}")), used_fallback: true,
})
.map_err(|fallback| fallback.context(format!("saved audio setup failed: {error:#}")))
})
}

#[cfg(test)]
mod audio_start_tests {
use super::*;
use clubcraft_engine::HeadphoneRouting;

#[test]
fn missing_single_device_retries_system_default_and_reports_fallback() {
for routing in [HeadphoneRouting::Auto, HeadphoneRouting::Off, HeadphoneRouting::Split,
HeadphoneRouting::Channels { master: [2, 3], cue: [0, 1] }] {
let config = AudioConfig { device: Some("disconnected".into()), headphones: routing, ..AudioConfig::default() };
let mut attempts = Vec::new();
let started = start_audio(config.clone(), |candidate| {
attempts.push(candidate.clone());
if candidate.device.is_some() { anyhow::bail!("device missing"); }
Ok(())
}).unwrap();
assert_eq!(attempts, [config, AudioConfig::default()]);
assert!(started.warning.as_ref().unwrap().contains("using system default"));
assert!(started.used_fallback);
}
}

#[test]
fn fallback_keeps_saved_config_across_exit_and_retries_the_original_device() {
let original = AudioConfig { device: Some("external-interface".into()), sample_rate: Some(48000),
buffer_frames: Some(512), headphones: HeadphoneRouting::Split, ..AudioConfig::default() };
let mut saved = original.clone();
// Both initial startup and a restart from Settings use the same optional
// canonical config; neither may sync the fallback into persisted audio.
for _ in 0..2 {
let started = start_audio(saved.clone(), |candidate| {
if candidate.device.is_some() { anyhow::bail!("interface unplugged"); }
Ok(candidate)
}).unwrap();
assert_eq!(started.handle, AudioConfig::default());
if let Some(config) = started.config_to_save(started.handle.clone()) { saved = config; }
saved = serde_json::from_str(&serde_json::to_string(&saved).unwrap()).unwrap();
assert_eq!(saved, original);
}
let recovered = start_audio(saved.clone(), |candidate| {
assert_eq!(candidate.device, original.device);
let mut resolved = candidate;
resolved.device = Some("resolved-interface-id".into());
Ok(resolved)
}).unwrap();
let canonical = recovered.config_to_save(recovered.handle.clone()).unwrap();
assert_eq!(canonical.device.as_deref(), Some("resolved-interface-id"));
assert_eq!(canonical.sample_rate, original.sample_rate);
}

#[test]
fn separate_device_never_substitutes_system_default() {
let config = AudioConfig { headphones: HeadphoneRouting::SeparateDevice, ..AudioConfig::default() };
let mut attempts = 0;
let result = start_audio::<()>(config, |_| {
attempts += 1;
anyhow::bail!("master unavailable")
});
assert!(result.is_err());
assert_eq!(attempts, 1);
}

#[test]
fn working_setup_is_not_reopened_and_double_failure_is_reported() {
let config = AudioConfig::default();
let mut attempts = 0;
let started = start_audio(config.clone(), |_| { attempts += 1; Ok(()) }).unwrap();
assert_eq!(attempts, 1);
assert!(started.warning.is_none());
assert!(!started.used_fallback);
let failure = start_audio::<()>(config, |_| anyhow::bail!("device missing")).err().unwrap();
assert!(format!("{failure:#}").contains("saved audio setup failed"));
}
}

impl LiveEngine {
pub fn start(config: AudioConfig) -> LiveEngine {
let (tx, rx) = unbounded();
let (handle, error) = match Engine::start(config).or_else(|_| Engine::start(AudioConfig::default())) {
Ok(h) => (Some(h), None),
Err(e) => (None, Some(format!("Audio output unavailable: {e:#}"))),
let started = start_audio(config, Engine::start);
let (handle, error, startup_audio_config) = match started {
Ok(started) => {
let config_to_save = started.config_to_save(started.handle.audio_config());
let warning = started.warning.or_else(|| started.handle.stream_info().warning);
(Some(started.handle), warning, config_to_save)
}
Err(e) => (None, Some(format!("Audio output unavailable: {e:#}")), None),
};
if let Some(h) = &handle {
let _ = h.send(Command::SetAutoGain(true));
Expand All @@ -405,6 +514,7 @@ impl LiveEngine {
LiveEngine {
handle,
error,
startup_audio_config,
cache,
sep: Arc::new(LiveSeparator::new()),
tx,
Expand Down Expand Up @@ -897,7 +1007,15 @@ pub fn mixer_ui(st: &EngineState, eng: &LiveEngine) -> MixerUi {
automix: eng.live_player.is_some() || (eng.loading_mix.is_some()),
output_name: eng.handle.as_ref().map(|h| {
let i = h.stream_info();
format!("{} · {} Hz", i.device, i.sample_rate)
if i.master.failed {
"Master output stopped · open Audio settings to retry".into()
} else if i.headphones.as_ref().is_some_and(|cue| cue.failed) {
format!("{} · headphones stopped · open Audio settings", i.device)
} else if let Some(warning) = i.warning {
format!("{} · {warning}", i.device)
} else {
format!("{} · {} Hz", i.device, i.sample_rate)
}
}).or_else(|| eng.error.clone()).unwrap_or_default(),
}
}
Expand Down
Loading
Loading