Initial implementation of qobuz-qt

- Rust backend (qobuz-backend static lib): Qobuz API client (reqwest/tokio),
  Symphonia audio decoder, CPAL audio output, extern "C" FFI bridge
- Qt 6 frontend mirroring spotify-qt layout: toolbar with playback controls,
  left library dock, central track list, right search panel
- Auth: email/password login with MD5-signed requests; session token persisted
  via QSettings
- Playback: double-click a track → Rust fetches stream URL → Symphonia decodes
  → CPAL outputs to default audio device
- Dark Fusion palette matching spotify-qt feel

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

rust/src/player/decoder.rs

@@ -0,0 +1,207 @@
+use anyhow::Result;
+use std::io::{self, Read, Seek, SeekFrom};
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+
+use symphonia::core::{
+    codecs::DecoderOptions,
+    errors::Error as SymphoniaError,
+    formats::FormatOptions,
+    io::{MediaSource, MediaSourceStream},
+    meta::MetadataOptions,
+    probe::Hint,
+};
+
+use crate::player::{output::AudioOutput, PlayerStatus};
+
+/// First 512 KiB of stream kept in memory to support backward seeks during probing.
+const HEAD_SIZE: usize = 512 * 1024;
+
+struct HttpStreamSource {
+    reader: reqwest::blocking::Response,
+    head: Vec<u8>,
+    reader_pos: u64,
+    pos: u64,
+    content_length: Option<u64>,
+}
+
+impl HttpStreamSource {
+    fn new(response: reqwest::blocking::Response, content_length: Option<u64>) -> Self {
+        Self {
+            reader: response,
+            head: Vec::new(),
+            reader_pos: 0,
+            pos: 0,
+            content_length,
+        }
+    }
+}
+
+impl Read for HttpStreamSource {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let pos = self.pos as usize;
+        if pos < self.head.len() {
+            let avail = self.head.len() - pos;
+            let n = buf.len().min(avail);
+            buf[..n].copy_from_slice(&self.head[pos..pos + n]);
+            self.pos += n as u64;
+            return Ok(n);
+        }
+
+        let n = self.reader.read(buf)?;
+        if n > 0 {
+            if self.reader_pos < HEAD_SIZE as u64 {
+                let capacity = HEAD_SIZE.saturating_sub(self.head.len());
+                let to_buf = n.min(capacity);
+                if to_buf > 0 {
+                    self.head.extend_from_slice(&buf[..to_buf]);
+                }
+            }
+            self.reader_pos += n as u64;
+            self.pos += n as u64;
+        }
+        Ok(n)
+    }
+}
+
+impl Seek for HttpStreamSource {
+    fn seek(&mut self, from: SeekFrom) -> io::Result<u64> {
+        let cl = self.content_length.unwrap_or(u64::MAX);
+        let target: u64 = match from {
+            SeekFrom::Start(n) => n,
+            SeekFrom::End(n) if n < 0 => cl.saturating_sub((-n) as u64),
+            SeekFrom::End(_) => cl,
+            SeekFrom::Current(n) if n >= 0 => self.pos.saturating_add(n as u64),
+            SeekFrom::Current(n) => self.pos.saturating_sub((-n) as u64),
+        };
+
+        if target == self.pos {
+            return Ok(self.pos);
+        }
+
+        if target < self.reader_pos {
+            if target < self.head.len() as u64 {
+                self.pos = target;
+                return Ok(self.pos);
+            }
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "backward seek past head buffer",
+            ));
+        }
+
+        let mut remaining = target - self.reader_pos;
+        while remaining > 0 {
+            let mut discard = [0u8; 8192];
+            let want = (remaining as usize).min(discard.len());
+            match self.reader.read(&mut discard[..want]) {
+                Ok(0) => break,
+                Ok(n) => {
+                    if self.reader_pos < HEAD_SIZE as u64 {
+                        let capacity = HEAD_SIZE.saturating_sub(self.head.len());
+                        let to_buf = n.min(capacity);
+                        if to_buf > 0 {
+                            self.head.extend_from_slice(&discard[..to_buf]);
+                        }
+                    }
+                    self.reader_pos += n as u64;
+                    remaining -= n as u64;
+                }
+                Err(e) => return Err(e),
+            }
+        }
+        self.pos = self.reader_pos;
+        Ok(self.pos)
+    }
+}
+
+impl MediaSource for HttpStreamSource {
+    fn is_seekable(&self) -> bool {
+        true
+    }
+    fn byte_len(&self) -> Option<u64> {
+        self.content_length
+    }
+}
+
+/// Stream and decode audio from `url`. Runs on a dedicated OS thread.
+pub fn play_track(
+    url: &str,
+    status: &PlayerStatus,
+    stop: &Arc<AtomicBool>,
+    paused: &Arc<AtomicBool>,
+) -> Result<()> {
+    let response = reqwest::blocking::get(url)?;
+    let content_length = response.content_length();
+    let source = HttpStreamSource::new(response, content_length);
+    let mss = MediaSourceStream::new(Box::new(source), Default::default());
+
+    let hint = Hint::new();
+    let probed = symphonia::default::get_probe()
+        .format(&hint, mss, &FormatOptions::default(), &MetadataOptions::default())
+        .map_err(|e| anyhow::anyhow!("probe failed: {e}"))?;
+
+    let mut format = probed.format;
+    let track = format
+        .tracks()
+        .iter()
+        .find(|t| t.codec_params.codec != symphonia::core::codecs::CODEC_TYPE_NULL)
+        .ok_or_else(|| anyhow::anyhow!("no audio tracks"))?
+        .clone();
+
+    let track_id = track.id;
+    let sample_rate = track.codec_params.sample_rate.unwrap_or(44100);
+    let channels = track.codec_params.channels.map(|c| c.count()).unwrap_or(2);
+
+    let mut decoder = symphonia::default::get_codecs()
+        .make(&track.codec_params, &DecoderOptions::default())
+        .map_err(|e| anyhow::anyhow!("decoder init failed: {e}"))?;
+
+    let mut audio_output = AudioOutput::try_open(sample_rate, channels)?;
+
+    loop {
+        if stop.load(Ordering::SeqCst) {
+            break;
+        }
+        while paused.load(Ordering::SeqCst) {
+            std::thread::sleep(std::time::Duration::from_millis(50));
+            if stop.load(Ordering::SeqCst) {
+                return Ok(());
+            }
+        }
+
+        let packet = match format.next_packet() {
+            Ok(p) => p,
+            Err(SymphoniaError::IoError(e)) if e.kind() == std::io::ErrorKind::UnexpectedEof => {
+                break;
+            }
+            Err(SymphoniaError::ResetRequired) => {
+                decoder.reset();
+                continue;
+            }
+            Err(e) => return Err(anyhow::anyhow!("format error: {e}")),
+        };
+
+        if packet.track_id() != track_id {
+            continue;
+        }
+
+        if let Some(ts) = packet.ts().checked_div(sample_rate as u64) {
+            status.position_secs.store(ts, std::sync::atomic::Ordering::Relaxed);
+        }
+
+        match decoder.decode(&packet) {
+            Ok(decoded) => {
+                let volume = status.volume.load(Ordering::Relaxed) as f32 / 100.0;
+                audio_output.write(decoded, volume, stop)?;
+            }
+            Err(SymphoniaError::IoError(_)) => break,
+            Err(SymphoniaError::DecodeError(e)) => eprintln!("decode error: {e}"),
+            Err(e) => return Err(anyhow::anyhow!("decode error: {e}")),
+        }
+    }
+
+    Ok(())
+}