fix: add quality fallback when CDN fails at current quality level

When download fails after retry at the same quality (e.g. HiRes),
automatically try the next lower quality (e.g. Lossless). This handles
CDN edges that consistently serve broken responses for specific tracks
at certain quality levels. Applied to all three download paths: standard
download, streaming probe fallback, and prefetch. Also fixes prefetch
retry using wrong quality variable.
This commit is contained in:
vicrodh committed 2026-03-12 09:15:57 -06:00
1 parent d34fb4eb3e
commit d7fd24b2e9
2 files changed
+109 -18

No files matched your search

+11
View File
@@ -54,6 +54,17 @@ impl Quality {
Quality::Mp3, Quality::Mp3,
] ]
} }
/// Returns the next lower quality level, or None if already at the lowest (Mp3).
/// Used for CDN fallback when a quality level consistently fails.
pub fn lower(&self) -> Option<Quality> {
match self {
Quality::UltraHiRes => Some(Quality::HiRes),
Quality::HiRes => Some(Quality::Lossless),
Quality::Lossless => Some(Quality::Mp3),
Quality::Mp3 => None,
}
}
} }
impl Default for Quality { impl Default for Quality {
+98 -18
View File
@@ -1883,32 +1883,33 @@ fn spawn_v2_prefetch_with_hw_check(
} }
}; };
let result = async { // Determine effective quality (may be downgraded for hardware compatibility)
let bridge_guard = bridge_clone.read().await; let effective_quality = {
let bridge = bridge_guard.as_ref().ok_or("CoreBridge not initialized")?; let mut eq = quality;
let mut effective_quality = quality;
// Smart quality downgrade: check if hardware supports the track's sample rate
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
if let Some(ref device_id) = hw_device_clone { if let Some(ref device_id) = hw_device_clone {
if quality == Quality::UltraHiRes { if quality == Quality::UltraHiRes {
let stream_url = bridge.get_stream_url(track_id, quality).await?; let bridge_guard = bridge_clone.read().await;
if let Some(bridge) = bridge_guard.as_ref() {
if let Ok(stream_url) = bridge.get_stream_url(track_id, quality).await {
let track_rate = (stream_url.sampling_rate * 1000.0) as u32; let track_rate = (stream_url.sampling_rate * 1000.0) as u32;
if qbz_audio::device_supports_sample_rate(device_id, track_rate) == Some(false) { if qbz_audio::device_supports_sample_rate(device_id, track_rate) == Some(false) {
log::info!( log::info!(
"[V2/PREFETCH] Track {} at {}Hz incompatible with hardware, prefetching at Hi-Res", "[V2/PREFETCH] Track {} at {}Hz incompatible with hardware, prefetching at Hi-Res",
track_id, track_rate track_id, track_rate
); );
effective_quality = Quality::HiRes; eq = Quality::HiRes;
} else {
// Rate is supported, use the URL we already got
drop(bridge_guard);
let data = download_audio(&stream_url.url).await?;
return Ok::<Vec<u8>, String>(data);
} }
} }
} }
}
}
eq
};
let result = async {
let bridge_guard = bridge_clone.read().await;
let bridge = bridge_guard.as_ref().ok_or("CoreBridge not initialized")?;
let stream_url = bridge.get_stream_url(track_id, effective_quality).await?; let stream_url = bridge.get_stream_url(track_id, effective_quality).await?;
drop(bridge_guard); drop(bridge_guard);
@@ -1932,7 +1933,7 @@ fn spawn_v2_prefetch_with_hw_check(
let retry_result = async { let retry_result = async {
let bridge_guard = bridge_clone.read().await; let bridge_guard = bridge_clone.read().await;
let bridge = bridge_guard.as_ref().ok_or("CoreBridge not initialized")?; let bridge = bridge_guard.as_ref().ok_or("CoreBridge not initialized")?;
let stream_url = bridge.get_stream_url(track_id, quality).await?; let stream_url = bridge.get_stream_url(track_id, effective_quality).await?;
drop(bridge_guard); drop(bridge_guard);
download_audio(&stream_url.url).await download_audio(&stream_url.url).await
}.await; }.await;
@@ -1942,7 +1943,36 @@ fn spawn_v2_prefetch_with_hw_check(
log::info!("[V2/PREFETCH] Complete for track {} (retry succeeded)", track_id); log::info!("[V2/PREFETCH] Complete for track {} (retry succeeded)", track_id);
} }
Err(e2) => { Err(e2) => {
log::warn!("[V2/PREFETCH] Failed for track {} (attempt 2): {}", track_id, e2); // Both attempts at current quality failed — try lower quality
if let Some(fallback_q) = effective_quality.lower() {
log::warn!(
"[V2/PREFETCH] Retry also failed for track {}: {}. Trying quality fallback to {}",
track_id, e2, fallback_q.label()
);
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
let fallback_result = async {
let bridge_guard = bridge_clone.read().await;
let bridge = bridge_guard.as_ref().ok_or("CoreBridge not initialized")?;
let stream_url = bridge.get_stream_url(track_id, fallback_q).await?;
log::info!(
"[V2/PREFETCH] Quality fallback: {} → {} (format_id={})",
effective_quality.label(), fallback_q.label(), stream_url.format_id
);
drop(bridge_guard);
download_audio(&stream_url.url).await
}.await;
match fallback_result {
Ok(data) => {
cache_clone.insert(track_id, data);
log::info!("[V2/PREFETCH] Complete for track {} (quality fallback succeeded)", track_id);
}
Err(e3) => {
log::warn!("[V2/PREFETCH] Quality fallback also failed for track {}: {}", track_id, e3);
}
}
} else {
log::warn!("[V2/PREFETCH] Failed for track {} (attempt 2, no lower quality): {}", track_id, e2);
}
} }
} }
} }
@@ -7364,16 +7394,41 @@ pub async fn v2_play_track(
.await .await
.map_err(RuntimeError::Internal)?; .map_err(RuntimeError::Internal)?;
stream_url = retry_url; stream_url = retry_url;
// Set stream_first_enabled to false to skip the streaming block
// and fall through to the standard download path
let audio_data = match download_audio(&stream_url.url).await { let audio_data = match download_audio(&stream_url.url).await {
Ok(data) => data, Ok(data) => data,
Err(e2) => { Err(e2) => {
// Fresh URL at same quality also failed — try lower quality
if let Some(fallback_q) = final_quality.lower() {
log::warn!(
"[V2/DOWNLOAD] Streaming fallback also failed for track {}: {}. Trying quality fallback to {}",
track_id, e2, fallback_q.label()
);
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
let fallback_url = bridge_guard
.get_stream_url(track_id, fallback_q)
.await
.map_err(RuntimeError::Internal)?;
log::info!(
"[V2/DOWNLOAD] Streaming quality fallback: {} → {} (format_id={})",
final_quality.label(), fallback_q.label(), fallback_url.format_id
);
stream_url = fallback_url;
match download_audio(&stream_url.url).await {
Ok(data) => data,
Err(e3) => {
log::warn!("[V2/DOWNLOAD] Quality fallback also failed for track {}: {}", track_id, e3);
return Err(RuntimeError::Internal(format!(
"Download failed after quality fallback: {}", e3
)));
}
}
} else {
log::warn!("[V2/DOWNLOAD] Retry also failed for track {}: {}", track_id, e2); log::warn!("[V2/DOWNLOAD] Retry also failed for track {}: {}", track_id, e2);
return Err(RuntimeError::Internal(format!( return Err(RuntimeError::Internal(format!(
"Download failed after retry: {}", e2 "Download failed after retry: {}", e2
))); )));
} }
}
}; };
let data_size = audio_data.len(); let data_size = audio_data.len();
if !streaming_only { if !streaming_only {
@@ -7482,9 +7537,34 @@ pub async fn v2_play_track(
.get_stream_url(track_id, final_quality) .get_stream_url(track_id, final_quality)
.await .await
.map_err(RuntimeError::Internal)?; .map_err(RuntimeError::Internal)?;
download_audio(&retry_url.url) match download_audio(&retry_url.url).await {
Ok(data) => data,
Err(e2) => {
// Both attempts at current quality failed — try lower quality
if let Some(fallback_q) = final_quality.lower() {
log::warn!(
"[V2/DOWNLOAD] Retry also failed for track {}: {}. Trying quality fallback to {}",
track_id, e2, fallback_q.label()
);
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
let fallback_url = bridge_guard
.get_stream_url(track_id, fallback_q)
.await
.map_err(RuntimeError::Internal)?;
log::info!(
"[V2/DOWNLOAD] Quality fallback: {} → {} (format_id={})",
final_quality.label(), fallback_q.label(), fallback_url.format_id
);
download_audio(&fallback_url.url)
.await .await
.map_err(RuntimeError::Internal)? .map_err(RuntimeError::Internal)?
} else {
return Err(RuntimeError::Internal(format!(
"Download failed after retry (no lower quality available): {}", e2
)));
}
}
}
} }
}; };
let data_size = audio_data.len(); let data_size = audio_data.len();