diff --git a/crates/qbz-qobuz/src/cmaf.rs b/crates/qbz-qobuz/src/cmaf.rs new file mode 100644 index 000000000..f052aa276 --- /dev/null +++ b/crates/qbz-qobuz/src/cmaf.rs @@ -0,0 +1,391 @@ +//! CMAF streaming pipeline for Qobuz. +//! +//! Qobuz's modern mobile client uses CMAF (Common Media Application Format) +//! segmented streaming over Akamai CDN, with AES-CTR per-frame encryption. +//! This is the pipeline that the v9.7.0.3 Android app uses and the one we +//! need to match if we want to stay compatible as Qobuz deprecates the +//! legacy `/track/getFileUrl` nginx path. +//! +//! # Pipeline shape +//! +//! 1. `/file/url` returns `{ url_template, key (wrapped), n_segments, ... }` +//! 2. `/session/start` returns `{ session_id, infos }` — the `infos` string +//! is the HKDF salt needed to derive the per-session AES key +//! 3. Session key = `HKDF(CMAF_SEED, infos)` +//! 4. Content key = unwrap(session_key, key) — this is the per-track AES key +//! 5. Fetch init segment (s=0) → parse FLAC header + segment table +//! 6. For each s=1..n_segments: fetch → parse crypto boxes → decrypt frames +//! in place → emit decrypted FLAC frames to the consumer +//! +//! # Why live in `qbz-qobuz` and not `qbz-cmaf` +//! +//! `qbz-cmaf` is pure parsing + crypto primitives (no I/O, no Qobuz client). +//! This module is the Qobuz-specific orchestration: it calls `/file/url`, +//! `/session/start`, owns the Akamai HTTP client, and returns ready-to-play +//! or ready-to-store bundles. +//! +//! # Why two variants +//! +//! - [`download_full`] — returns the fully decrypted FLAC as `Vec`. Used +//! by the playback pipeline for in-memory cache writes and eager downloads. +//! - [`download_raw`] — returns a [`CmafRawBundle`] of **encrypted** segments +//! plus key material. Used by the offline cache so we can persist +//! bit-identical bytes to what Qobuz delivered, and decrypt only at +//! playback time. This is the security-sensitive path. + +use std::sync::Arc; + +use qbz_models::Quality; + +use crate::client::QobuzClient; +use crate::error::Result; + +/// Concurrency cap for the full-download path. 3 segments in flight is the +/// empirically-determined sweet spot — Akamai CDN rate-limits with 1s windows +/// past ~5 parallel requests per client IP. +pub const CMAF_PREFETCH_CONCURRENCY: usize = 3; + +/// Info gathered from the CMAF init segment, enough to start streaming +/// playback. The caller is expected to fetch audio segments 1..n_segments +/// and feed them through [`qbz_cmaf::parse_segment_crypto`] + +/// [`qbz_cmaf::decrypt_frame`]. +pub struct CmafStreamingInfo { + pub url_template: String, + pub n_segments: u8, + pub content_key: [u8; 16], + pub flac_header: Vec, + pub segment_table: Vec, + pub format_id: u32, + pub sampling_rate: Option, + pub bit_depth: Option, + /// How long the init segment fetch took (ms), for speed estimation. + pub init_fetch_ms: u64, +} + +/// Raw (encrypted) CMAF bundle suitable for offline storage. +/// +/// Everything in this struct is **bit-identical** to what Qobuz's CDN +/// returned. In particular: +/// +/// - `init_bytes` is the raw init segment (unencrypted mp4 box with the +/// FLAC header inside — cheap to store). +/// - `segments` are the raw encrypted segment mp4 files, one per +/// `s=1..=n_segments`. These are useless without `content_key` and +/// without running them through the CMAF decrypt pipeline. +/// - `content_key` is the 16-byte AES key unwrapped from the session key; +/// it must be stored **encrypted at rest** on the caller's side. +/// - `infos` is the original `session/start` infos string. With the +/// `CMAF_SEED` constant this is enough to re-derive `session_key` and +/// re-unwrap the content key if we ever need to audit or migrate. +/// +/// The intent is that an attacker who copies the user's offline directory +/// out without also extracting the OS-keyring wrapped `content_key` gets +/// nothing usable — the segments are encrypted, the `infos` is just a +/// salt, and the seed alone isn't enough. +pub struct CmafRawBundle { + pub init_bytes: Vec, + pub segments: Vec>, + pub content_key: [u8; 16], + pub infos: String, + pub format_id: u32, + pub sampling_rate: Option, + pub bit_depth: Option, + pub n_segments: u8, +} + +/// Prepare CMAF streaming: fetch init segment only, derive keys, return info. +/// Does NOT download audio segments -- the caller streams those in background. +pub async fn setup_streaming( + client: &QobuzClient, + track_id: u64, + quality: Quality, +) -> std::result::Result { + let file_url = client.get_file_url(track_id, quality).await + .map_err(|e| format!("get_file_url failed: {}", e))?; + + let url_template = file_url + .url_template + .as_ref() + .ok_or("No url_template in file/url response")? + .clone(); + let key_str = file_url + .key + .as_ref() + .ok_or("No key in file/url response")?; + + let (_session_id, infos) = client.ensure_cmaf_session().await + .map_err(|e| format!("ensure_cmaf_session failed: {}", e))?; + + let session_key = qbz_cmaf::derive_session_key(crate::auth::CMAF_SEED, &infos) + .map_err(|e| format!("Session key derivation failed: {}", e))?; + let content_key = qbz_cmaf::unwrap_content_key(&session_key, key_str) + .map_err(|e| format!("Content key unwrap failed: {}", e))?; + + // Fetch only the init segment (s=0) -- typically small, <500ms + let http = build_cdn_client()?; + let init_url = url_template.replace("$SEGMENT$", "0"); + let init_start = std::time::Instant::now(); + + log::info!("[CMAF] Fetching init segment for track {}", track_id); + let init_data = http + .get(&init_url) + .header("User-Agent", "Mozilla/5.0") + .send() + .await + .map_err(|e| format!("Failed to fetch init segment: {}", e))? + .bytes() + .await + .map_err(|e| format!("Failed to read init segment: {}", e))?; + + let init_fetch_ms = init_start.elapsed().as_millis() as u64; + + let init_info = qbz_cmaf::parse_init_segment(&init_data) + .map_err(|e| format!("Failed to parse init segment: {}", e))?; + + log::info!( + "[CMAF] Init for track {}: FLAC header {}B, segment_table={} entries, API n_segments={}, fetched in {}ms", + track_id, + init_info.flac_header.len(), + init_info.segment_table.len(), + file_url.n_segments, + init_fetch_ms + ); + if init_info.segment_table.len() != file_url.n_segments as usize { + log::warn!( + "[CMAF] MISMATCH for track {}: segment_table has {} entries but API says n_segments={}", + track_id, + init_info.segment_table.len(), + file_url.n_segments + ); + } + + let format_id = file_url.format_id.unwrap_or(quality.id()); + + Ok(CmafStreamingInfo { + url_template, + n_segments: file_url.n_segments, + content_key, + flac_header: init_info.flac_header, + segment_table: init_info.segment_table, + format_id, + sampling_rate: file_url.sampling_rate, + bit_depth: file_url.bits_depth.or(file_url.bit_depth), + init_fetch_ms, + }) +} + +/// Download a track's complete CMAF stream and return decrypted FLAC bytes. +/// +/// Used by the playback path for in-memory cache writes. Segments are +/// fetched concurrently with a semaphore cap, decrypted, and concatenated. +pub async fn download_full( + client: &QobuzClient, + track_id: u64, + quality: Quality, +) -> std::result::Result, String> { + let setup = setup_streaming(client, track_id, quality).await?; + let http = build_cdn_client()?; + + let total_size: usize = setup.flac_header.len() + + setup.segment_table.iter().map(|s| s.byte_len as usize).sum::(); + + let segments = fetch_all_segments(&http, &setup.url_template, setup.n_segments, "CMAF-FULL").await?; + + let mut output = Vec::with_capacity(total_size); + output.extend_from_slice(&setup.flac_header); + decrypt_segments_into(&segments, &setup.content_key, &mut output)?; + + log::info!( + "[CMAF-FULL] Track {} complete: {:.2} MB FLAC, expected {:.2} MB", + track_id, + output.len() as f64 / (1024.0 * 1024.0), + total_size as f64 / (1024.0 * 1024.0), + ); + Ok(output) +} + +/// Download a track's complete CMAF stream and return it as a raw (still +/// encrypted) bundle suitable for offline storage. +/// +/// The caller is responsible for: +/// 1. Persisting `init_bytes` + `segments` to disk as bit-identical blobs +/// 2. Wrapping `content_key` with a device-bound key before storing it +/// 3. Storing `infos` (either wrapped or as plaintext — it's only a salt, +/// useless without `CMAF_SEED` + `content_key`) +/// +/// At playback time, the caller feeds `init_bytes` through +/// [`qbz_cmaf::parse_init_segment`] to recover the FLAC header + segment +/// table, then decrypts each segment with the unwrapped content key. +pub async fn download_raw( + client: &QobuzClient, + track_id: u64, + quality: Quality, +) -> std::result::Result { + let file_url = client.get_file_url(track_id, quality).await + .map_err(|e| format!("get_file_url failed: {}", e))?; + + let url_template = file_url + .url_template + .as_ref() + .ok_or("No url_template in file/url response")? + .clone(); + let key_str = file_url + .key + .as_ref() + .ok_or("No key in file/url response")?; + + let (_session_id, infos) = client.ensure_cmaf_session().await + .map_err(|e| format!("ensure_cmaf_session failed: {}", e))?; + + let session_key = qbz_cmaf::derive_session_key(crate::auth::CMAF_SEED, &infos) + .map_err(|e| format!("Session key derivation failed: {}", e))?; + let content_key = qbz_cmaf::unwrap_content_key(&session_key, key_str) + .map_err(|e| format!("Content key unwrap failed: {}", e))?; + + let http = build_cdn_client()?; + + // Init segment — used for FLAC header + segment table at playback + let init_url = url_template.replace("$SEGMENT$", "0"); + log::info!("[CMAF-RAW] Fetching init for track {}", track_id); + let init_bytes = http + .get(&init_url) + .header("User-Agent", "Mozilla/5.0") + .send() + .await + .map_err(|e| format!("Failed to fetch init segment: {}", e))? + .bytes() + .await + .map_err(|e| format!("Failed to read init segment: {}", e))? + .to_vec(); + + // Audio segments — encrypted, stored as-is + let segments = fetch_all_segments(&http, &url_template, file_url.n_segments, "CMAF-RAW").await?; + + log::info!( + "[CMAF-RAW] Track {} bundle: init={}B, {} encrypted segments, total raw size={} bytes", + track_id, + init_bytes.len(), + segments.len(), + init_bytes.len() + segments.iter().map(|s| s.len()).sum::(), + ); + + Ok(CmafRawBundle { + init_bytes, + segments, + content_key, + infos, + format_id: file_url.format_id.unwrap_or(quality.id()), + sampling_rate: file_url.sampling_rate, + bit_depth: file_url.bits_depth.or(file_url.bit_depth), + n_segments: file_url.n_segments, + }) +} + +/// Build a reqwest client configured for Akamai CDN fetches. +/// +/// Uses the workspace reqwest feature set (rustls-tls). The original in-tree +/// version in `src-tauri/commands_v2/helpers.rs` called `.use_native_tls()` +/// but the src-tauri Cargo opts into both stacks; this crate stays on +/// rustls for smaller binary + no system SSL dependency. If Akamai ever +/// surfaces a cert issue, adding the `native-tls` feature to qbz-qobuz is +/// the escape hatch. +fn build_cdn_client() -> std::result::Result { + reqwest::Client::builder() + .connect_timeout(std::time::Duration::from_secs(10)) + .build() + .map_err(|e| format!("CMAF client error: {}", e)) +} + +/// Fetch segments 1..=n_segments concurrently with a semaphore cap and a +/// cooldown per slot to stay under CDN rate limits. +async fn fetch_all_segments( + http: &reqwest::Client, + url_template: &str, + n_segments: u8, + log_tag: &str, +) -> std::result::Result>, String> { + let semaphore = Arc::new(tokio::sync::Semaphore::new(CMAF_PREFETCH_CONCURRENCY)); + let seg_indices: Vec = (1..=n_segments).collect(); + let mut handles = Vec::with_capacity(seg_indices.len()); + + for seg_idx in seg_indices { + let sem = semaphore.clone(); + let http = http.clone(); + let seg_url = url_template.replace("$SEGMENT$", &seg_idx.to_string()); + let log_tag = log_tag.to_string(); + + handles.push(tokio::spawn(async move { + let permit = sem.acquire_owned().await.map_err(|e| format!("semaphore: {}", e))?; + let seg_data = http + .get(&seg_url) + .header("User-Agent", "Mozilla/5.0") + .send() + .await + .map_err(|e| format!("[{}] seg {} fetch: {}", log_tag, seg_idx, e))? + .bytes() + .await + .map_err(|e| format!("[{}] seg {} read: {}", log_tag, seg_idx, e))?; + // Cooldown before releasing the slot — keeps requests spaced out + // to stay under CDN rate limits (most use 1s windows) + tokio::time::sleep(std::time::Duration::from_millis(500)).await; + drop(permit); + Ok::<(u8, Vec), String>((seg_idx, seg_data.to_vec())) + })); + } + + // Collect results in arrival order, then re-sort by segment index + let mut segments: Vec<(u8, Vec)> = Vec::with_capacity(handles.len()); + for handle in handles { + let (idx, data) = handle + .await + .map_err(|e| format!("[{}] task panic: {}", log_tag, e))? + .map_err(|e| format!("[{}] download failed: {}", log_tag, e))?; + segments.push((idx, data)); + } + segments.sort_by_key(|(idx, _)| *idx); + Ok(segments.into_iter().map(|(_, data)| data).collect()) +} + +/// Decrypt a sequence of encrypted CMAF segments in order and append the +/// decrypted frames to `output`. +/// +/// This is the common decryption logic shared between the full-download +/// path (decrypt-then-return) and the offline playback path (decrypt-from- +/// disk-then-feed-player). +pub fn decrypt_segments_into( + segments: &[Vec], + content_key: &[u8; 16], + output: &mut Vec, +) -> std::result::Result<(), String> { + for (seg_idx, seg_data) in segments.iter().enumerate() { + // seg_idx is 0-based here but the original segment number is idx+1 + let log_idx = seg_idx + 1; + let crypto = qbz_cmaf::parse_segment_crypto(seg_data) + .map_err(|e| format!("CMAF seg {} parse: {}", log_idx, e))?; + + let mut data_pos = crypto.data_offset; + for entry in &crypto.entries { + let frame_end = data_pos + entry.size as usize; + if frame_end > seg_data.len() { + return Err(format!("CMAF seg {} frame overflow", log_idx)); + } + let mut frame = seg_data[data_pos..frame_end].to_vec(); + if entry.flags != 0 { + qbz_cmaf::decrypt_frame(content_key, &entry.iv, &mut frame); + } + output.extend_from_slice(&frame); + data_pos = frame_end; + } + if data_pos < crypto.mdat_end && crypto.mdat_end <= seg_data.len() { + output.extend_from_slice(&seg_data[data_pos..crypto.mdat_end]); + } + } + Ok(()) +} + +// Silence "unused imports" if we end up not using everything at some point; +// the Result alias is kept for future variants that want to surface ApiError. +#[allow(dead_code)] +fn _type_assertions() { + let _: fn() -> Result<()> = || Ok(()); +} diff --git a/crates/qbz-qobuz/src/lib.rs b/crates/qbz-qobuz/src/lib.rs index b93b63b87..19f265a13 100644 --- a/crates/qbz-qobuz/src/lib.rs +++ b/crates/qbz-qobuz/src/lib.rs @@ -33,6 +33,7 @@ pub mod auth; pub mod bundle; pub mod client; +pub mod cmaf; pub mod endpoints; pub mod error; pub mod link_resolver; @@ -41,5 +42,10 @@ pub mod performers; // Re-export main types pub use bundle::BundleTokens; pub use client::QobuzClient; +pub use cmaf::{ + decrypt_segments_into, download_full as cmaf_download_full, + download_raw as cmaf_download_raw, setup_streaming as cmaf_setup_streaming, CmafRawBundle, + CmafStreamingInfo, CMAF_PREFETCH_CONCURRENCY, +}; pub use error::{ApiError, Result}; pub use link_resolver::{resolve_link, LinkResolverError, ResolvedLink}; diff --git a/src-tauri/src/commands_v2/helpers.rs b/src-tauri/src/commands_v2/helpers.rs index 7ce56af7e..7b4aef687 100644 --- a/src-tauri/src/commands_v2/helpers.rs +++ b/src-tauri/src/commands_v2/helpers.rs @@ -615,207 +615,43 @@ pub async fn download_with_backoff( )) } -/// Max concurrent segment downloads for CMAF prefetch. -/// Conservative to avoid CDN rate limiting (Qobuz uses Akamai). -const CMAF_PREFETCH_CONCURRENCY: usize = 3; - /// Full CMAF download for prefetch/cache — downloads ALL segments, decrypts, returns FLAC bytes. -/// Unlike streaming, this blocks until complete, but produces data suitable for cache insertion. -/// Segments are downloaded concurrently (up to CMAF_PREFETCH_CONCURRENCY) for speed. +/// +/// Thin wrapper over [`qbz_qobuz::cmaf::download_full`]; the real pipeline lives +/// in the `qbz-qobuz` crate so it can be reused by offline cache and the +/// daemon without pulling Tauri as a dependency. pub async fn try_cmaf_full_download( bridge: &crate::core_bridge::CoreBridge, track_id: u64, quality: Quality, ) -> Result, String> { - let setup = try_cmaf_streaming_setup(bridge, track_id, quality).await?; - - let client = reqwest::Client::builder() - .connect_timeout(std::time::Duration::from_secs(10)) - .use_native_tls() - .build() - .map_err(|e| format!("CMAF client error: {}", e))?; - - let total_size: usize = setup.flac_header.len() - + setup.segment_table.iter().map(|s| s.byte_len as usize).sum::(); - - // Download all segments concurrently in batches - let semaphore = Arc::new(tokio::sync::Semaphore::new(CMAF_PREFETCH_CONCURRENCY)); - let seg_indices: Vec = (1..=setup.n_segments).collect(); - let mut handles = Vec::with_capacity(seg_indices.len()); - - for seg_idx in seg_indices { - let sem = semaphore.clone(); - let client = client.clone(); - let seg_url = setup.url_template.replace("$SEGMENT$", &seg_idx.to_string()); - - handles.push(tokio::spawn(async move { - let permit = sem.acquire_owned().await.map_err(|e| format!("semaphore: {}", e))?; - let seg_data = client - .get(&seg_url) - .header("User-Agent", "Mozilla/5.0") - .send().await - .map_err(|e| format!("CMAF prefetch seg {} fetch: {}", seg_idx, e))? - .bytes().await - .map_err(|e| format!("CMAF prefetch seg {} read: {}", seg_idx, e))?; - // Cooldown before releasing the slot — keeps requests spaced out - // to stay under CDN rate limits (most use 1s windows) - tokio::time::sleep(std::time::Duration::from_millis(500)).await; - drop(permit); - Ok::<(u8, Vec), String>((seg_idx, seg_data.to_vec())) - })); - } - - // Collect results and sort by segment index to preserve order - let mut segments: Vec<(u8, Vec)> = Vec::with_capacity(handles.len()); - for handle in handles { - let (idx, data) = handle.await - .map_err(|e| format!("CMAF prefetch task panic: {}", e))? - .map_err(|e| format!("CMAF prefetch download failed: {}", e))?; - segments.push((idx, data)); - } - segments.sort_by_key(|(idx, _)| *idx); - - // Decrypt and assemble in order - let mut output = Vec::with_capacity(total_size); - output.extend_from_slice(&setup.flac_header); - - for (seg_idx, seg_data) in &segments { - let crypto = qbz_cmaf::parse_segment_crypto(seg_data) - .map_err(|e| format!("CMAF prefetch seg {} parse: {}", seg_idx, e))?; - - let mut data_pos = crypto.data_offset; - for entry in &crypto.entries { - let frame_end = data_pos + entry.size as usize; - if frame_end > seg_data.len() { - return Err(format!("CMAF prefetch seg {} frame overflow", seg_idx)); - } - let mut frame = seg_data[data_pos..frame_end].to_vec(); - if entry.flags != 0 { - qbz_cmaf::decrypt_frame(&setup.content_key, &entry.iv, &mut frame); - } - output.extend_from_slice(&frame); - data_pos = frame_end; - } - if data_pos < crypto.mdat_end && crypto.mdat_end <= seg_data.len() { - output.extend_from_slice(&seg_data[data_pos..crypto.mdat_end]); - } - } - - log::info!( - "[V2/CMAF-PREFETCH] Complete: track {} ({:.2} MB FLAC, expected {:.2} MB, segments 1..{}, table={} entries, n_segments={}, concurrency={})", - track_id, - output.len() as f64 / (1024.0 * 1024.0), - total_size as f64 / (1024.0 * 1024.0), - setup.n_segments - 1, - setup.segment_table.len(), - setup.n_segments, - CMAF_PREFETCH_CONCURRENCY, - ); - Ok(output) + let client_arc = bridge.core().client(); + let client_guard = client_arc.read().await; + let client = client_guard + .as_ref() + .ok_or_else(|| "QobuzClient not initialized".to_string())?; + qbz_qobuz::cmaf::download_full(client, track_id, quality).await } -/// Info gathered from the CMAF init segment, enough to start streaming playback. -pub struct CmafStreamingInfo { - pub url_template: String, - pub n_segments: u8, - pub content_key: [u8; 16], - pub flac_header: Vec, - pub segment_table: Vec, - pub format_id: u32, - pub sampling_rate: Option, - pub bit_depth: Option, - /// How long the init segment fetch took (ms), for speed estimation. - pub init_fetch_ms: u64, -} +/// Re-export `CmafStreamingInfo` so in-tree callers can keep using +/// `crate::commands_v2::helpers::CmafStreamingInfo` unchanged. +pub use qbz_qobuz::cmaf::CmafStreamingInfo; /// Prepare CMAF streaming: fetch init segment only, derive keys, return info. /// Does NOT download audio segments -- the caller streams those in background. +/// +/// Thin wrapper over [`qbz_qobuz::cmaf::setup_streaming`]. pub async fn try_cmaf_streaming_setup( bridge: &crate::core_bridge::CoreBridge, track_id: u64, quality: Quality, ) -> Result { - let file_url = bridge.get_file_url(track_id, quality).await?; - - let url_template = file_url - .url_template + let client_arc = bridge.core().client(); + let client_guard = client_arc.read().await; + let client = client_guard .as_ref() - .ok_or("No url_template in file/url response")? - .clone(); - let key_str = file_url - .key - .as_ref() - .ok_or("No key in file/url response")?; - - let (_session_id, infos) = bridge.ensure_cmaf_session().await?; - - let session_key = qbz_cmaf::derive_session_key(qbz_qobuz::auth::CMAF_SEED, &infos) - .map_err(|e| format!("Session key derivation failed: {}", e))?; - let content_key = qbz_cmaf::unwrap_content_key(&session_key, key_str) - .map_err(|e| format!("Content key unwrap failed: {}", e))?; - - // Fetch only the init segment (s=0) -- typically small, <500ms - let client = reqwest::Client::builder() - .connect_timeout(std::time::Duration::from_secs(10)) - .use_native_tls() - .build() - .map_err(|e| format!("CMAF client error: {}", e))?; - - let init_url = url_template.replace("$SEGMENT$", "0"); - let init_start = std::time::Instant::now(); - - log::info!("[V2/CMAF] Fetching init segment for streaming setup"); - let init_data = client - .get(&init_url) - .header("User-Agent", "Mozilla/5.0") - .send() - .await - .map_err(|e| format!("Failed to fetch init segment: {}", e))? - .bytes() - .await - .map_err(|e| format!("Failed to read init segment: {}", e))?; - - let init_fetch_ms = init_start.elapsed().as_millis() as u64; - - let init_info = qbz_cmaf::parse_init_segment(&init_data) - .map_err(|e| format!("Failed to parse init segment: {}", e))?; - - // Detailed diagnostics: segment table vs API n_segments - let table_total_bytes: u64 = init_info.segment_table.iter().map(|s| s.byte_len as u64).sum(); - let table_total_samples: u64 = init_info.segment_table.iter().map(|s| s.sample_count as u64).sum(); - log::info!( - "[V2/CMAF] Init segment: FLAC header {}B, segment_table={} entries, API n_segments={}, \ - table_total_bytes={}, table_total_samples={}, fetched in {}ms", - init_info.flac_header.len(), - init_info.segment_table.len(), - file_url.n_segments, - table_total_bytes, - table_total_samples, - init_fetch_ms - ); - if init_info.segment_table.len() != file_url.n_segments as usize { - log::warn!( - "[V2/CMAF] MISMATCH: segment_table has {} entries but API says n_segments={}", - init_info.segment_table.len(), - file_url.n_segments - ); - } - - let format_id = file_url.format_id.unwrap_or(quality.id()); - let sampling_rate = file_url.sampling_rate; - let bit_depth = file_url.bits_depth.or(file_url.bit_depth); - - Ok(CmafStreamingInfo { - url_template, - n_segments: file_url.n_segments, - content_key, - flac_header: init_info.flac_header, - segment_table: init_info.segment_table, - format_id, - sampling_rate, - bit_depth, - init_fetch_ms, - }) + .ok_or_else(|| "QobuzClient not initialized".to_string())?; + qbz_qobuz::cmaf::setup_streaming(client, track_id, quality).await } /// Stream info from probing a URL (HEAD + first 64KB)