Revert visible:false approach which broke WM buttons on Wayland.
Instead, set html/body background to #0f0f0f (dark theme default)
so the brief frame before webview renders shows a dark surface
instead of a white flash.
Create the window with visible:false so the empty frame + title bar
don't flash while the webview loads. The frontend calls
show_main_window from onMount (after first DOM paint) to reveal the
window with content already rendered.
Since the window must be created with the correct decoration state
(runtime toggling doesn't work on Linux/Wayland), persist the setting
to the Rust backend and restart the app immediately.
Add restart_app Tauri command using AppHandle::restart(). Update i18n
descriptions to inform the user the app will restart.
On Linux/Wayland, windows created with decorations:false cannot
reliably switch to decorations:true at runtime - the WM buttons
render but don't function until a maximize/restore cycle.
Fix by removing the declarative window from tauri.conf.json and
creating it programmatically in the setup hook with the correct
decorations value from the start. The WM sees the right state when
the window is first mapped, so buttons work immediately.
Also fixes the empty frame flash from visible:false + early show().
Move decoration setting to Rust side so the WM sees correct state when
the window is first mapped. Window starts hidden (visible: false in
tauri.conf.json), Rust reads the persisted setting from SQLite, applies
decorations, then shows the window.
Frontend now persists the setting via Tauri invoke (in addition to
localStorage) so Rust can read it at startup. Inline script in app.html
prevents flash of custom title bar before Svelte mounts.
- Save existing quality data before DELETE in plex_cache_save_tracks,
restore hydrated container/sampling_rate_hz/bit_depth after re-insert
so bulk sync no longer overwrites per-track quality from hydration
- Add plex_cache_get_tracks_needing_hydration command returning
rating_keys where sampling_rate_hz or bit_depth is NULL (limit param)
- Add likely_single_file_album field to PlexCachedAlbum struct, set true
when track_count == 1 and total_duration_secs > 600
Add persistent metadata cache tables (reco_album_meta, reco_track_meta,
reco_artist_meta) with no TTL for stable played-item metadata.
Implement reco_get_home_resolved command that returns fully-resolved
card data in a single IPC call using 3-tier resolution:
1. Reco meta cache (persistent, sub-ms)
2. API cache (24h TTL, sub-ms)
3. Qobuz API (parallel HTTP fallback)
Also refactors reco_get_home_ml to use shared get_home_seeds_internal
to avoid seed-gathering duplication.
Add PageArtistResponse and ReleasesGridResponse types with all
supporting structs for the /artist/page and /artist/getReleasesGrid
Qobuz API endpoints. Add client methods and Tauri commands.
Hardware acceleration is OFF by default for maximum AppImage
compatibility. Users can enable it in Settings > Appearance.
Env var QBZ_HARDWARE_ACCEL=1|0 always overrides the DB value,
providing crash recovery from the terminal.
Developer settings: SQLite-backed store for force_dmabuf toggle.
Logging: TeeWriter captures env_logger output to ring buffer;
log_startup() captures pre-logger startup messages.
Upload: multipart POST to 0x0.st for log sharing.
CLI: --reset-dmabuf flag resets force_dmabuf and exits for recovery.
Tears down all per-user stores, clears credentials from keyring,
then removes ~/.local/share/qbz/, ~/.cache/qbz/, and ~/.config/qbz/.
Makes teardown_type_alias_state public for reuse.
Adds reset_all() to both AudioSettingsStore and PlaybackPreferencesStore.
The reset_audio_settings tauri command resets both audio and playback
preferences to their default values in a single call.
Add a toggleable gapless button next to the repeat button in the
NowPlayingBar. The setting persists in audio_settings.db and controls
whether the audio thread pre-queues the next track for gapless
transitions. Includes i18n keys for all 4 locales.
Backend: Add PlayNext command to audio thread that appends decoded
sources to the existing Rodio Sink for seamless transitions. The audio
thread detects when ~5s remain and signals gapless_ready via SharedState.
Position-based transition detection updates track metadata when the
queued source begins playing.
Frontend: playerStore detects gapless_ready flag, invokes
play_next_gapless (cache-only lookup), and handles transitions by
advancing the queue without stop/play cycle. playbackService gains
gaplessTransition option to skip stop_playback when backend already
transitioned.
Gapless is only eligible when: same sample rate/channels, cached data,
Rodio backend (not ALSA Direct), not streaming, not a user skip.
Falls back to normal stop-play flow when ineligible.
Add normalization_gain field to SharedState and PlaybackEvent so the
frontend can display whether normalization is actively applied to the
current track. The gain factor is stored as AtomicU32 (f32 bits) and
emitted with each playback:state event.
cc
Add ReplayGain-based volume normalization to the audio pipeline.
When enabled, extracts ReplayGain track gain/peak tags from audio
file metadata (Vorbis comments, ID3v2 TXXX) and applies a gain
factor via rodio's Amplify wrapper.
Pipeline order: Diagnostic (raw) -> Amplify (normalization) -> Visualizer
When normalization is OFF (default), no Amplify wrapper is inserted
and the pipeline remains 100% bit-perfect.
- New module: audio/loudness.rs (extraction + gain calculation)
- New settings: normalization_enabled, normalization_target_lufs
- New Tauri commands: set_audio_normalization_enabled/target
- Supports -14 LUFS (default), -18 LUFS, -23 LUFS targets
- Clipping prevention using peak metadata
- Gain preserved across resume/seek operations
cc
Lock-free OR-mask analysis of f32 samples converted to i32,
bypassing PipeWire processing entirely. DiagnosticSource wraps
the audio source at decode level for both rodio and ALSA Direct
paths. Tauri commands: start_bitdepth_capture / stop_bitdepth_capture.
cc
Visualizer FFT thread, remote control API server, and Last.fm session
restore were all initializing before user session activation, causing
errors ("No active session") and wasting resources.
Move all three to run after activate_user_session:
- Visualizer: add started guard to prevent double-start
- Remote control: sync_server now has per-user settings available
- Last.fm: restoreLastfmSession moved from bootstrapApp to handleLoginSuccess
Saves the active user_id to a flat-path file on activate_user_session
and clears it on deactivate_user_session (explicit logout). On startup,
if saved credentials and a last_user_id both exist, the per-user session
is restored before loading ToS acceptance or attempting auto-login.
This fixes the chicken-and-egg problem where ToS acceptance lived in the
per-user DB but was needed before login to allow auto-login.
LoginResponse now includes user_id from the Qobuz API session.
activate_user_session: called after login with user_id, runs one-time
flat-to-user migration, then initializes all 22+ per-user stores at
~/.local/share/qbz/users/{uid}/ and ~/.cache/qbz/users/{uid}/.
Also runs deferred subscription purge check.
deactivate_user_session: called before logout, tears down all per-user
stores to close database connections and clears the active user.
Phase 1 (device-level): Read audio/tray settings from flat path once
for player and tray init. Initialize cast, DLNA, API server.
Phase 2 (per-user): All 22 per-user states init as new_empty().
They get populated after login via activate_user_session.
Subscription purge check deferred to activate_user_session.
Modify callers in commands/, cast/, library/, and lib.rs to unwrap
Option<Store> with appropriate error messages. Fix drop(db) to
drop(guard__) for correct mutex release.
One-time migration moves all existing DB files and cache directories
from the flat layout into users/{uid}/ subdirectories. The first user
to log in after the update inherits all existing data. A .migrated
marker file prevents re-running.
Handles WAL/SHM journal files, cross-device moves via copy+delete
fallback, and recursive directory copying.
Central path provider that holds the current user_id behind RwLock.
Provides user-scoped data and cache directory paths:
- ~/.local/share/qbz/users/{uid}/
- ~/.cache/qbz/users/{uid}/
Registered as Tauri managed state. No behavior change yet -
user paths are not used by any module until activate_user_session
is implemented.
- Add backend endpoint for /discover/playlists API
- Add PlaylistTagFilter dropdown component for filtering by genre
- Add QobuzPlaylistCard with CSS blur background effect (color-thief style)
- Add HorizontalScrollRow header snippet for custom headers with scroll controls
- Add session cache store for caching API responses
- Add i18n keys for playlist filter and discover section
cc
Security improvements based on code review:
1. Credential Encryption (Critical)
- Replace XOR obfuscation with AES-256-GCM encryption
- Derive key from machine ID (tied to specific machine)
- Add migration support for legacy XOR format
- Automatic re-encryption on first load of legacy credentials
2. HTTPS Default (Medium)
- Change default `secure` setting to `true` for new installs
- Existing users keep their current setting
3. Configurable CORS Origins (High)
- Replace hardcoded domain whitelist with SQLite-backed storage
- Default origins: vicrodh.github.io, control.qbz.lol
- Add commands: get/add/remove origins, restore defaults
- Origins can be customized for third-party clients
- Server restarts automatically when origins change
New dependencies:
- aes-gcm: AES-256-GCM authenticated encryption
- sha2: SHA-256 for key derivation
- Add shuffle/repeat fields to PlaybackEvent struct
- Emit queue:state event when shuffle/repeat changes via API
- Add queue event listener in desktop frontend
- Include shuffle/repeat in WebSocket broadcasts
- PWA updates shuffle/repeat from WebSocket messages
This enables bidirectional sync: changes from PWA update desktop UI,
and changes from desktop update PWA via WebSocket.
Features:
- Axum REST API server for remote control
- WebSocket real-time playback updates
- Token-based authentication with QR pairing
- LAN-only security middleware
- Settings UI for enabling/configuring remote control
Phase 1 of artist blacklist implementation:
- Add artist_blacklist module with HashSet-based service for O(1) lookups
- Add SQLite persistence with WAL mode
- Add global enable/disable feature flag
- Add Tauri commands for CRUD operations
- Register BlacklistState in app state
cc
- Add reco_backfill_genres command to populate genre_id for existing events
- Add reco_needs_genre_backfill command to check if backfill is needed
- Fetches album details from Qobuz API and updates events in batches
- Includes rate limiting to avoid API throttling
- Add limit_quality_to_device setting (enabled by default)
- Add device_max_sample_rate field to store selected device's max rate
- Implement limit_quality_for_device() to restrict quality based on device
- Apply quality limiting in play_track and prefetch_track commands
- Add set_audio_device_max_sample_rate Tauri command
This ensures bit-perfect playback by not requesting tracks that
exceed the device's sample rate capabilities. When enabled:
- Devices <= 48kHz: limited to Lossless (44.1kHz)
- Devices <= 96kHz: limited to HiRes (up to 96kHz)
- Devices > 96kHz: allow UltraHiRes (up to 192kHz)
Add new audio setting to limit streaming quality based on device
capabilities. When enabled (default: true), QBZ will avoid requesting
tracks that exceed the device's max supported sample rate.
This ensures bit-perfect playback by preventing the need to resample
high-res tracks on devices that don't support them.
- Add limit_quality_to_device field to AudioSettings
- Add database migration for new column
- Add Tauri command for frontend integration
cc
- Add VisualizerTap to Player for sample capture
- Create wrap_source helper in audio thread
- Wrap all audio sources with TappedSource at 4 append points
- Player now captures samples for visualization when enabled
- Zero overhead when disabled (fast atomic check)
Audio samples flow: Source -> TappedSource -> RingBuffer -> FFT Thread -> Frontend
Add streaming_only setting that skips L1+L2 cache writes while still
respecting offline cache (local-first). When enabled:
- download_and_stream() skips final cache.insert()
- Standard download path skips cache.insert()
- Offline cache continues to work normally
This reduces storage usage for users who prefer pure streaming.
Issue #34 - Display actual stream quality, not track metadata
Backend changes:
- Add sample_rate and bit_depth to PlaybackEvent
- Add stream quality tracking to SharedState
- Extract bit_depth from FLAC/M4A headers in streaming path
- Player sets stream quality when decoding audio
Frontend changes:
- Update PlaybackEvent interface with new fields
- Update currentTrack with actual stream quality from backend
This allows the UI to show the actual quality being played (e.g., 44.1kHz
when streaming a 192kHz track at CD Quality) instead of the track's
maximum advertised quality.
Backend:
- Add get_artist_tracks command for fetching artist's popular tracks
Frontend:
- Fallback to artist's popular tracks when tracks_appears_on is sparse
- Remove card hover movement, only image moves up on hover
- Add hover overlay with (add to queue) (play) (play next) buttons
- Use playlist.svg icon for playlist cards and glyph
- Radio glyph shown by default, replaced by action buttons on hover
- Fix icon sizes: QBZ (22px) vs Qobuz (18px) for visual balance
- Track playlist.svg asset